mirror of
https://github.com/HabitRPG/habitica.git
synced 2025-12-16 06:07:21 +01:00
29b1320f4a
api.mocha.coffee into archive directory. we could depend on git history, but I want to keep them publicly visible to developers for now since they may contain valuable test worth porting to our new setup.
657 lines
24 KiB
CoffeeScript
657 lines
24 KiB
CoffeeScript
_ = require 'lodash'
|
|
expect = require 'expect.js'
|
|
require 'coffee-script'
|
|
async = require 'async'
|
|
superagentDefaults = require 'superagent-defaults'
|
|
|
|
request = superagentDefaults()
|
|
|
|
conf = require("nconf")
|
|
conf.argv().env().file({file: __dirname + '../config.json'}).defaults
|
|
conf.set('port','1337')
|
|
|
|
# Override normal ENV values with nconf ENV values (ENV values are used the same way without nconf)
|
|
#FIXME can't get nconf file above to load...
|
|
process.env.BASE_URL = conf.get("BASE_URL")
|
|
process.env.FACEBOOK_KEY = conf.get("FACEBOOK_KEY")
|
|
process.env.FACEBOOK_SECRET = conf.get("FACEBOOK_SECRET")
|
|
process.env.NODE_DB_URI = 'mongodb://localhost/habitrpg'
|
|
|
|
User = require('../../src/models/user').model
|
|
Group = require('../../src/models/group').model
|
|
Challenge = require('../../src/models/challenge').model
|
|
|
|
app = require '../../src/server'
|
|
|
|
## monkey-patch expect.js for better diffs on mocha
|
|
## see: https://github.com/LearnBoost/expect.js/pull/34
|
|
#origBe = expect.Assertion::be
|
|
#expect.Assertion::be = expect.Assertion::equal = (obj) ->
|
|
# @_expected = obj
|
|
# origBe.call this, obj
|
|
|
|
# Custom modules
|
|
shared = require 'habitrpg-shared'
|
|
|
|
###### Helpers & Variables ######
|
|
|
|
model = null
|
|
uuid = null
|
|
taskPath = null
|
|
baseURL = 'http://localhost:3000/api/v2'
|
|
|
|
###
|
|
expect().eql expects object keys to be in the correct order, this sorts that out
|
|
###
|
|
|
|
expectUserEqual = (u1, u2) ->
|
|
[u1, u2] = _.map [u1, u2], (obj) ->
|
|
'update__ stats.toNextLevel stats.maxHealth __v'.split(' ').forEach (path) ->
|
|
helpers.dotSet path, null, obj
|
|
sorted = {}
|
|
_.each _.keys(obj).sort(), (k) -> sorted[k] = obj[k]
|
|
sorted.tasks = _.sortBy sorted.tasks, 'id'
|
|
sorted
|
|
# console.log {u1, u2}
|
|
expect(u1).to.eql(u2)
|
|
|
|
expectSameValues = (obj1, obj2, paths) ->
|
|
_.each paths, (k) ->
|
|
expect(helpers.dotGet(k,obj1)).to.eql helpers.dotGet(k,obj2)
|
|
|
|
expectCode = (res, code) ->
|
|
expect(res.body.err).to.be undefined if code is 200
|
|
expect(res.statusCode).to.be code
|
|
|
|
###### Specs ######
|
|
|
|
describe 'API', ->
|
|
user = null
|
|
_id = null
|
|
apiToken = null
|
|
username = null
|
|
password = null
|
|
|
|
registerNewUser = (cb, main=true)->
|
|
randomID = shared.uuid()
|
|
[username,password] = [randomID,randomID] if main
|
|
request.post("#{baseURL}/register")
|
|
.set('Accept', 'application/json')
|
|
.send({
|
|
username: randomID
|
|
password: randomID
|
|
confirmPassword: randomID
|
|
email: "#{randomID}@gmail.com"
|
|
})
|
|
.end (res) ->
|
|
return cb(null,res.body) unless main
|
|
{_id,apiToken} = res.body
|
|
console.log {_id,apiToken}
|
|
User.findOne {_id, apiToken}, (err, _user) ->
|
|
expect(err).to.not.be.ok
|
|
user = _user
|
|
request
|
|
.set('Accept', 'application/json')
|
|
.set('X-API-User', _id)
|
|
.set('X-API-Key', apiToken)
|
|
cb null, res.body
|
|
|
|
before (done)->
|
|
require '../../src/server' #start the server
|
|
# then wait for it to do it's thing. TODO make a cb-compatible export of server
|
|
setTimeout done, 2000
|
|
|
|
describe 'Without token or user id', ->
|
|
it '/api/v2/status', (done) ->
|
|
request.get("#{baseURL}/status")
|
|
.set('Accept', 'application/json')
|
|
.end (res) ->
|
|
expect(res.statusCode).to.be 200
|
|
expect(res.body.status).to.be 'up'
|
|
done()
|
|
|
|
it '/api/v2/user', (done) ->
|
|
request.get("#{baseURL}/user")
|
|
.set('Accept', 'application/json')
|
|
.end (res) ->
|
|
expect(res.statusCode).to.be 401
|
|
expect(res.body.err).to.be 'You must include a token and uid (user id) in your request'
|
|
done()
|
|
|
|
describe 'With token and user id', ->
|
|
currentUser = null
|
|
|
|
before (done) ->
|
|
registerNewUser(done,true)
|
|
|
|
beforeEach (done) ->
|
|
User.findById _id, (err,_user) ->
|
|
currentUser = _user
|
|
done()
|
|
|
|
############
|
|
# Groups
|
|
############
|
|
|
|
describe 'Groups', ->
|
|
group = undefined
|
|
|
|
before (done) ->
|
|
request.post("#{baseURL}/groups")
|
|
.send({name:"TestGroup", type:"party"})
|
|
.end (res) ->
|
|
expectCode res, 200
|
|
group = res.body
|
|
expect(group.members.length).to.be 1
|
|
expect(group.leader).to.be user._id
|
|
done()
|
|
|
|
describe 'Challenges', ->
|
|
challenge = undefined
|
|
updateTodo = undefined
|
|
|
|
it 'Creates a challenge', (done) ->
|
|
request.post("#{baseURL}/challenges")
|
|
.send({
|
|
group:group._id
|
|
dailys: [{type:'daily',text:'Challenge Daily'}]
|
|
todos: [{type:'todo', text:'Challenge Todo', notes:'Challenge Notes'}]
|
|
rewards: []
|
|
habits: []
|
|
official: true
|
|
})
|
|
.end (res) ->
|
|
expectCode res, 200
|
|
async.parallel [
|
|
(cb) -> User.findById _id, cb
|
|
(cb) -> Challenge.findById res.body._id, cb
|
|
], (err, results) ->
|
|
[_user,challenge] = [results[0],results[1]]
|
|
expect(_user.dailys[_user.dailys.length-1].text).to.be('Challenge Daily')
|
|
updateTodo = _user.todos[_user.todos.length-1]
|
|
expect(updateTodo.text).to.be('Challenge Todo')
|
|
expect(challenge.official).to.be false
|
|
done()
|
|
|
|
it 'User updates challenge notes', (done) ->
|
|
updateTodo.notes = "User overriden notes"
|
|
request.put("#{baseURL}/user/tasks/#{updateTodo.id}")
|
|
.send(updateTodo)
|
|
.end (res) ->
|
|
done() #we'll do the check down below
|
|
|
|
it 'Change challenge daily', (done) ->
|
|
challenge.dailys[0].text = 'Updated Daily'
|
|
challenge.todos[0].notes = 'Challenge Updated Todo Notes'
|
|
request.post("#{baseURL}/challenges/#{challenge._id}")
|
|
.send(challenge)
|
|
.end (res) ->
|
|
setTimeout ->
|
|
User.findById _id, (err,_user) ->
|
|
expectCode res, 200
|
|
expect(_user.dailys[_user.dailys.length-1].text).to.be('Updated Daily')
|
|
expect(res.body.todos[0].notes).to.be('Challenge Updated Todo Notes')
|
|
expect(_user.todos[_user.todos.length-1].notes).to.be('User overriden notes')
|
|
currentUser = _user
|
|
done()
|
|
, 500 # we have to wait a while for users' tasks to be updated, called async on server
|
|
|
|
it 'Shows user notes on challenge page', (done) ->
|
|
request.get("#{baseURL}/challenges/#{challenge._id}/member/#{_id}")
|
|
.end (res) ->
|
|
expect(res.body.todos[res.body.todos.length-1].notes).to.be('User overriden notes')
|
|
done()
|
|
|
|
it 'Complete To-Dos', (done) ->
|
|
u = currentUser
|
|
request.post("#{baseURL}/user/tasks/#{u.todos[0].id}/up").end (res) ->
|
|
request.post("#{baseURL}/user/tasks/#{u.todos[1].id}/up").end (res) ->
|
|
request.post("#{baseURL}/user/tasks/").send({type:'todo'}).end (res) ->
|
|
request.post("#{baseURL}/user/tasks/clear-completed").end (res) ->
|
|
expect(_.size res.body).to.be 2
|
|
done()
|
|
|
|
it 'Admin creates a challenge', (done) ->
|
|
User.findByIdAndUpdate _id, {$set:{'contributor.admin':true}}, (err,_user) ->
|
|
expect(err).to.not.be.ok
|
|
|
|
async.parallel [
|
|
(cb)->
|
|
request.post("#{baseURL}/challenges")
|
|
.send({group:group._id, dailys: [], todos: [], rewards: [], habits: [], official: false}).end (res) ->
|
|
expect(res.body.official).to.be false
|
|
cb()
|
|
(cb)->
|
|
request.post("#{baseURL}/challenges")
|
|
.send({group:group._id, dailys: [], todos: [], rewards: [], habits: [], official: true}).end (res) ->
|
|
expect(res.body.official).to.be true
|
|
cb()
|
|
], done
|
|
|
|
|
|
describe 'Quests', ->
|
|
party = undefined
|
|
participating = []
|
|
notParticipating = []
|
|
|
|
it 'Invites some members', (done) ->
|
|
async.waterfall [
|
|
|
|
# Register new users
|
|
(cb) ->
|
|
async.parallel [
|
|
(cb2) -> registerNewUser(cb2,false)
|
|
(cb2) -> registerNewUser(cb2,false)
|
|
(cb2) -> registerNewUser(cb2,false)
|
|
], cb
|
|
|
|
# Send them invitations
|
|
(_party, cb) ->
|
|
party = _party
|
|
async.parallel [
|
|
(cb2) -> request.post("#{baseURL}/groups/#{group._id}/invite?uuid=#{party[0]._id}").end (-> cb2())
|
|
(cb2) -> request.post("#{baseURL}/groups/#{group._id}/invite?uuid=#{party[1]._id}").end (-> cb2())
|
|
(cb2) -> request.post("#{baseURL}/groups/#{group._id}/invite?uuid=#{party[2]._id}").end (-> cb2())
|
|
], cb
|
|
|
|
# Accept / Reject
|
|
(results, cb) ->
|
|
#series since they'll be modifying the same group record
|
|
async.series (_.reduce party, (m,v,i) ->
|
|
m.push (cb2) ->
|
|
request.post("#{baseURL}/groups/#{group._id}/join")
|
|
.set('X-API-User', party[i]._id)
|
|
.set('X-API-Key', party[i].apiToken)
|
|
.end (res) -> cb2()
|
|
m
|
|
, []), cb
|
|
|
|
# Make sure the invites stuck
|
|
(whatever, cb) ->
|
|
Group.findById group._id, (err, g) ->
|
|
expect(g.members.length).to.be 4
|
|
cb()
|
|
|
|
], (err, results) ->
|
|
expect(err).to.be.ok
|
|
done()
|
|
|
|
it 'Starts a quest', (done) ->
|
|
async.waterfall [
|
|
(cb)->
|
|
request.post("#{baseURL}/groups/#{group._id}/questAccept?key=evilsanta")
|
|
.end (res) ->
|
|
expectCode(res, 401)
|
|
User.findByIdAndUpdate _id, {$set:'items.quests.evilsanta':1}, cb
|
|
(_user,cb)->
|
|
request.post("#{baseURL}/groups/#{group._id}/questAccept?key=evilsanta")
|
|
.end (res) ->
|
|
expectCode(res, 200)
|
|
Group.findById group._id,cb
|
|
(_group,cb)->
|
|
group = _group #refresh local group
|
|
expect(group.quest.key).to.be 'evilsanta'
|
|
|
|
async.series (_.reduce party, (m,v,i) ->
|
|
m.push (cb2) ->
|
|
request.post("#{baseURL}/groups/#{group._id}/questAccept")
|
|
.set('X-API-User', party[i]._id)
|
|
.set('X-API-Key', party[i].apiToken)
|
|
.end (res) -> cb2()
|
|
m
|
|
, []), cb
|
|
|
|
], done
|
|
|
|
it "Doesn't include people who aren't participating"
|
|
|
|
|
|
# ############
|
|
# # Batch Update
|
|
# ############
|
|
#
|
|
# describe 'Batch Update', ->
|
|
#
|
|
# it 'POST /api/v1/batch-update', (done) ->
|
|
# userBefore = _.cloneDeep(currentUser)
|
|
#
|
|
# ops = [
|
|
# # Good scores
|
|
# op: 'score', params: {id:user.habits[0].id, direction: 'up'}
|
|
# op: 'score', params: {id:user.habits[1].id, direction: 'down'}
|
|
# op: 'score', params: {id:user.dailys[0].id, direction: 'up'}
|
|
# op: 'score', params: {id:user.todos[0].id, direction: 'up'}
|
|
# ]
|
|
#
|
|
# request.post("#{baseURL}/user/batch-update")
|
|
# .send(ops)
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 200
|
|
# #expectUserEqual(userBefore, res.body)
|
|
# done()
|
|
#
|
|
#
|
|
# ############
|
|
# # To Be Updated (these are old v1 tests which haven't been touched in over 6 months, need to be portd to new API tests or deleted)
|
|
# ############
|
|
#
|
|
# it.skip 'POST /api/v2/batch-update (handles corrupt values)', (done) ->
|
|
# registerNewUser (_res) ->
|
|
# # corrupt the tasks, and let's see how the server handles this
|
|
# ids = _res.dailyIds
|
|
# _res.tasks[ids[0]].value = NaN
|
|
# _res.tasks[ids[1]].value = undefined
|
|
# _res.tasks[ids[2]] = {}
|
|
# _res.tasks["undefined"] = {}
|
|
#
|
|
# _res.stats.hp = _res.stats.gp = NaN
|
|
#
|
|
# _res.lastCron = +new Date('08/13/2013')
|
|
#
|
|
# ops = [
|
|
# op: 'score', task: _res.tasks[ids[0]], dir: 'up'
|
|
# ]
|
|
#
|
|
# model.set "users.#{_res.id}", _res, ->
|
|
# request.post("#{baseURL}/user/batch-update")
|
|
# .set('Accept', 'application/json')
|
|
# .set('X-API-User', _res.id)
|
|
# .set('X-API-Key', _res.apiToken)
|
|
# .send(ops)
|
|
# .end (res) ->
|
|
# expect(res.statusCode).to.be 200
|
|
# console.log {stats:res.body.stats, tasks:res.body.tasks}
|
|
# done()
|
|
#
|
|
#
|
|
# #FIXME figure out how to compare the objects
|
|
# it.skip 'GET /api/v1/user', (done) ->
|
|
# request.get("#{baseURL}/user")
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 200
|
|
# expect(res.body.id).not.to.be.empty()
|
|
# self = _.clone(currentUser)
|
|
# delete self.apiToken
|
|
# self.stats.toNextLevel = 150
|
|
# self.stats.maxHealth = 50
|
|
#
|
|
# expectUserEqual(res.body, self)
|
|
# done()
|
|
#
|
|
# it.skip 'GET /api/v1/user/task/:id', (done) ->
|
|
# tid = _.pluck(currentUser.tasks, 'id')[0]
|
|
# request.get("#{baseURL}/user/task/#{tid}")
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 200
|
|
# expect(res.body).to.eql currentUser.tasks[tid]
|
|
# done()
|
|
#
|
|
# it.skip 'POST /api/v1/user/task', (done) ->
|
|
# request.post("#{baseURL}/user/task")
|
|
# .send({title: 'Title', text: 'Text', type: 'habit'})
|
|
# .end (res) ->
|
|
# query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
|
|
# query.fetch (err, user) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 201
|
|
# expect(res.body.id).not.to.be.empty()
|
|
# # Ensure that user owns the newly created object
|
|
# saved = user.get("tasks.#{res.body.id}")
|
|
# expect(saved).to.be.an('object')
|
|
# done()
|
|
#
|
|
# it.skip 'POST /api/v1/user/task (without type)', (done) ->
|
|
# request.post("#{baseURL}/user/task")
|
|
# .send({})
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be 'type must be habit, todo, daily, or reward'
|
|
# expect(res.statusCode).to.be 400
|
|
# done()
|
|
#
|
|
# it.skip 'POST /api/v1/user/task (only type)', (done) ->
|
|
# request.post("#{baseURL}/user/task")
|
|
# .send(type: 'habit')
|
|
# .end (res) ->
|
|
# query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
|
|
# query.fetch (err, user) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 201
|
|
# expect(res.body.id).not.to.be.empty()
|
|
# # Ensure that user owns the newly created object
|
|
# expect(user.get().tasks[res.body.id]).to.be.an('object')
|
|
# # Ensure that value gets set to 0 since not otherwise specified
|
|
# expect(user.get().tasks[res.body.id].value).to.be.equal(0)
|
|
# done()
|
|
#
|
|
# it.skip 'PUT /api/v1/user/task/:id', (done) ->
|
|
# tid = _.pluck(currentUser.tasks, 'id')[0]
|
|
# request.put("#{baseURL}/user/task/#{tid}")
|
|
# .send(text: 'bye')
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 200
|
|
# currentUser.tasks[tid].text = 'bye'
|
|
# expectSameValues res.body, currentUser.tasks[tid], ['id','type','text']
|
|
# #expect(res.body).to.eql currentUser.tasks[tid]
|
|
# done()
|
|
#
|
|
# it.skip 'PUT /api/v1/user/task/:id (shouldnt update type)', (done) ->
|
|
# tid = _.pluck(currentUser.tasks, 'id')[1]
|
|
# type = if currentUser.tasks[tid].type is 'habit' then 'daily' else 'habit'
|
|
# request.put("#{baseURL}/user/task/#{tid}")
|
|
# .send(type: type, text: 'fishman')
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 200
|
|
# currentUser.tasks[tid].text = 'fishman'
|
|
# expect(res.body).to.eql currentUser.tasks[tid]
|
|
# done()
|
|
#
|
|
# it.skip 'PUT /api/v1/user/task/:id (update notes)', (done) ->
|
|
# tid = _.pluck(currentUser.tasks, 'id')[2]
|
|
# request.put("#{baseURL}/user/task/#{tid}")
|
|
# .send(text: 'hi',notes:'foobar matey')
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 200
|
|
# currentUser.tasks[tid].text = 'hi'
|
|
# currentUser.tasks[tid].notes = 'foobar matey'
|
|
# expect(res.body).to.eql currentUser.tasks[tid]
|
|
# done()
|
|
#
|
|
# it.skip 'GET /api/v1/user/tasks', (done) ->
|
|
# request.get("#{baseURL}/user/tasks")
|
|
# .end (res) ->
|
|
# query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
|
|
# query.fetch (err, user) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(user.get()).to.be.ok()
|
|
# expect(res.statusCode).to.be 200
|
|
# model.ref '_user', user
|
|
# tasks = []
|
|
# for type in ['habit','todo','daily','reward']
|
|
# model.refList "_#{type}List", "_user.tasks", "_user.#{type}Ids"
|
|
# tasks = tasks.concat model.get("_#{type}List")
|
|
# # Ensure that user owns the tasks
|
|
# expect(res.body.length).to.equal tasks.length
|
|
# # Ensure that the two sets are equal
|
|
# expect(_.difference(_.pluck(res.body,'id'), _.pluck(tasks,'id')).length).to.equal 0
|
|
# done()
|
|
#
|
|
# it.skip 'GET /api/v1/user/tasks (todos)', (done) ->
|
|
# request.get("#{baseURL}/user/tasks")
|
|
# .query(type:'todo')
|
|
# .end (res) ->
|
|
# query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
|
|
# query.fetch (err, user) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 200
|
|
# model.ref '_user', user
|
|
# model.refList "_todoList", "_user.tasks", "_user.todoIds"
|
|
# tasks = model.get("_todoList")
|
|
# # Ensure that user owns the tasks
|
|
# expect(res.body.length).to.equal tasks.length
|
|
# # Ensure that the two sets are equal
|
|
# expect(_.difference(_.pluck(res.body,'id'), _.pluck(tasks,'id')).length).to.equal 0
|
|
# done()
|
|
#
|
|
# it.skip 'DELETE /api/v1/user/task/:id', (done) ->
|
|
# tid = currentUser.habitIds[2]
|
|
# request.del("#{baseURL}/user/task/#{tid}")
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 204
|
|
# query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
|
|
# query.fetch (err, user) ->
|
|
# expect(user.get('habitIds').indexOf(tid)).to.be -1
|
|
# expect(user.get("tasks.#{tid}")).to.be undefined
|
|
# done()
|
|
#
|
|
# it.skip 'DELETE /api/v1/user/task/:id (no task found)', (done) ->
|
|
# tid = "adsfasdfjunkshouldntbeatask"
|
|
# request.del("#{baseURL}/user/task/#{tid}")
|
|
# .end (res) ->
|
|
# expect(res.statusCode).to.be 400
|
|
# expect(res.body.err).to.be 'No task found.'
|
|
# done()
|
|
#
|
|
# it.skip 'POST /api/v1/user/task/:id/up (habit)', (done) ->
|
|
# tid = currentUser.habitIds[0]
|
|
# request.post("#{baseURL}/user/task/#{tid}/up")
|
|
# .send({})
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 200
|
|
# expect(res.body).to.eql { gp: 1, exp: 7.5, lvl: 1, hp: 50, delta: 1 }
|
|
# done()
|
|
#
|
|
# it.skip 'POST /api/v1/user/task/:id/up (daily)', (done) ->
|
|
# tid = currentUser.dailyIds[0]
|
|
# request.post("#{baseURL}/user/task/#{tid}/up")
|
|
# .send({})
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 200
|
|
# expect(res.body).to.eql { gp: 2, exp: 15, lvl: 1, hp: 50, delta: 1 }
|
|
# query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
|
|
# query.fetch (err, user) ->
|
|
# expect(user.get("tasks.#{tid}.completed")).to.be true
|
|
# done()
|
|
#
|
|
# it.skip 'POST /api/v1/user/task (array)', (done) ->
|
|
# habitId = currentUser.habitIds[0]
|
|
# dailyId = currentUser.dailyIds[0]
|
|
# arr = [{
|
|
# id: habitId
|
|
# text: 'hello'
|
|
# notes: 'note'
|
|
# },{
|
|
# text: 'new task'
|
|
# notes: 'notes!'
|
|
# },{
|
|
# id: dailyId
|
|
# del: true
|
|
# }]
|
|
#
|
|
# request.post("#{baseURL}/user/tasks")
|
|
# .send(arr)
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 201
|
|
#
|
|
# expectSameValues res.body[0], {id: habitId,text: 'hello',notes: 'note'}, ['id','text','notes']
|
|
# expect(res.body[1].id).to.be.a 'string'
|
|
# expect(res.body[1].text).to.be 'new task'
|
|
# expect(res.body[1].notes).to.be 'notes!'
|
|
# expect(res.body[2]).to.eql deleted: true
|
|
#
|
|
# query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
|
|
# query.fetch (err, user) ->
|
|
# expectSameValues user.get("tasks.#{habitId}"), {id: habitId,text: 'hello',notes: 'note'}, ['id','text','notes']
|
|
# expect(user.get("tasks.#{dailyId}")).to.be undefined
|
|
# expectSameValues user.get("tasks.#{res.body[1].id}"), {id: res.body[1].id, text: 'new task', notes: 'notes!'}, ['id','text','notes']
|
|
# done()
|
|
#
|
|
# it.skip 'PUT /api/v1/user (bad path)', (done) ->
|
|
# # These updates should not save, as per the API changes
|
|
# userUpdates =
|
|
# stats: hp: 30
|
|
# flags: itemsEnabled: true
|
|
# tasks: [{
|
|
# text: 'hello2'
|
|
# notes: 'note2'
|
|
# }]
|
|
#
|
|
# request.put("#{baseURL}/user")
|
|
# .send(userUpdates)
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be.ok()
|
|
# expect(res.statusCode).to.be 500
|
|
# done()
|
|
#
|
|
# it.skip 'PUT /api/v1/user', (done) ->
|
|
# userBefore = {}
|
|
# query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
|
|
# query.fetch (err, user) ->
|
|
# userBefore = user.get()
|
|
#
|
|
# habitId = currentUser.habitIds[0]
|
|
# dailyId = currentUser.dailyIds[0]
|
|
# updates = {}
|
|
# updates['stats.hp'] = 30
|
|
# updates['flags.itemsEnabled'] = true
|
|
# updates["tasks.#{habitId}.text"] = 'hello2'
|
|
# updates["tasks.#{habitId}.notes"] = 'note2'
|
|
#
|
|
# request.put("#{baseURL}/user")
|
|
# .send(updates)
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 200
|
|
# changesWereMade = (obj) ->
|
|
# expect(obj.stats.hp).to.be 30
|
|
# expect(obj.flags.itemsEnabled).to.be true
|
|
# expectSameValues _.find(obj.tasks,{id:habitId}), {id: habitId,text: 'hello2',notes: 'note2'}, ['id','text','notes']
|
|
# changesWereMade res.body
|
|
# query.fetch (err, user) ->
|
|
# changesWereMade user.get()
|
|
# done()
|
|
#
|
|
# it.skip 'POST /api/v1/user/auth/local', (done) ->
|
|
# userAuth = {username, password}
|
|
# request.post("#{baseURL}/user/auth/local")
|
|
# .set('Accept', 'application/json')
|
|
# .send(userAuth)
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 200
|
|
# expect(res.body.id).to.be currentUser.id
|
|
# expect(res.body.token).to.be currentUser.apiToken
|
|
# done()
|
|
#
|
|
# it.skip 'POST /api/v1/user/auth/facebook', (done) ->
|
|
# id = shared.uuid()
|
|
# userAuth = facebook_id: 12345, name: 'Tyler Renelle', email: 'x@y.com'
|
|
# newUser = helpers.newUser(true)
|
|
# newUser.id = id
|
|
# newUser.auth = facebook:
|
|
# id: userAuth.facebook_id
|
|
# name: userAuth.name
|
|
# email: userAuth.email
|
|
# model.set "users.#{id}", newUser, ->
|
|
#
|
|
# request.post("#{baseURL}/user/auth/facebook")
|
|
# .set('Accept', 'application/json')
|
|
# .send(userAuth)
|
|
# .end (res) ->
|
|
# expect(res.body.err).to.be undefined
|
|
# expect(res.statusCode).to.be 200
|
|
# expect(res.body.id).to.be newUser.id
|
|
# #expect(res.body.token).to.be newUser.apiToken
|
|
# done()
|
|
#
|
|
#
|