krikkert/habitica
1
0
Fork 0
mirror of https://github.com/HabitRPG/habitica.git synced 2025-12-19 15:48:04 +01:00
Code Issues Packages Projects Releases Wiki Activity

groups: upon group-creation, creator is automatically assigned as leader

Browse Source 
and only member. Remove sending up leader & members from the client,
should all be handled on the server
This commit is contained in:
Tyler Renelle
2014-01-05 14:45:01 -07:00
parent 8c319b6079
commit e474278ab3
3 changed files with 417 additions and 370 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
public/js/controllers/groupsCtrl.js
View File

@@ -201,7 +201,7 @@ habitrpg.controller("GroupsCtrl", ['$scope', '$rootScope', 'Groups', '$http', 'A
$scope.type = 'guild'; $scope.type = 'guild';
$scope.text = 'Guild'; $scope.text = 'Guild';
var newGroup = function(){ var newGroup = function(){
return new Groups.Group({type:'guild', privacy:'private', leader: User.user._id, members: [User.user._id]}); return new Groups.Group({type:'guild', privacy:'private'});
} }
$scope.newGroup = newGroup() $scope.newGroup = newGroup()
$scope.create = function(group){ $scope.create = function(group){
@@ -272,7 +272,7 @@ habitrpg.controller("GroupsCtrl", ['$scope', '$rootScope', 'Groups', '$http', 'A
$scope.type = 'party'; $scope.type = 'party';
$scope.text = 'Party'; $scope.text = 'Party';
$scope.group = $rootScope.party = Groups.party(); $scope.group = $rootScope.party = Groups.party();
$scope.newGroup = new Groups.Group({type:'party', leader: User.user._id, members: [User.user._id]}); $scope.newGroup = new Groups.Group({type:'party'});
$scope.create = function(group){ $scope.create = function(group){
group.$save(function(newGroup){ group.$save(function(newGroup){
$scope.group = newGroup; $scope.group = newGroup;

2
src/controllers/groups.js
View File

@@ -137,6 +137,8 @@ api.get = function(req, res) {
api.create = function(req, res, next) { api.create = function(req, res, next) {
var group = new Group(req.body); var group = new Group(req.body);
var user = res.locals.user; var user = res.locals.user;
group.members = [user._id];
group.leader = user._id;
if(group.type === 'guild'){ if(group.type === 'guild'){
if(user.balance < 1) return res.json(401, {err: 'Not enough gems!'}); if(user.balance < 1) return res.json(401, {err: 'Not enough gems!'});

775
test/api.mocha.coffee
View File

@@ -66,30 +66,39 @@ expectCode = (res, code) ->
###### Specs ###### ###### Specs ######
describe 'API', -> describe 'API', ->
server = null
user = null user = null
_id = null _id = null
apiToken = null apiToken = null
username = null username = null
password = null password = null
registerNewUser = (cb) -> registerNewUser = (cb, main=true)->
randomID = shared.uuid() randomID = shared.uuid()
password = randomID [username,password] = [randomID,randomID] if main
params = request.post("#{baseURL}/register")
.set('Accept', 'application/json')
.send({
username: randomID username: randomID
password: randomID password: randomID
confirmPassword: randomID confirmPassword: randomID
email: "#{randomID}@gmail.com" email: "#{randomID}@gmail.com"
request.post("#{baseURL}/register") })
.set('Accept', 'application/json')
.send(params)
.end (res) -> .end (res) ->
cb(res.body) 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)-> before (done)->
server = require '../src/server' require '../src/server' #start the server
# nasty hack, make a cb-compatible export of server # then wait for it to do it's thing. TODO make a cb-compatible export of server
setTimeout done, 2000 setTimeout done, 2000
describe 'Without token or user id', -> describe 'Without token or user id', ->
@@ -109,21 +118,11 @@ describe 'API', ->
expect(res.body.err).to.be 'You must include a token and uid (user id) in your request' expect(res.body.err).to.be 'You must include a token and uid (user id) in your request'
done() done()
describe.only 'With token and user id', -> describe 'With token and user id', ->
currentUser = null currentUser = null
before (done) -> before (done) ->
registerNewUser (_res) -> registerNewUser(done,true)
#console.log _res
[_id, apiToken, username] = [_res.id, _res.apiToken, _res.auth.local.username]
User.findOne {_id,apiToken}, (err, _user) ->
console.error {err} if err
user = _user
request
.set('Accept', 'application/json')
.set('X-API-User', _id)
.set('X-API-Key', apiToken)
done()
beforeEach (done) -> beforeEach (done) ->
User.findById _id, (err,_user) -> User.findById _id, (err,_user) ->
@@ -134,18 +133,20 @@ describe 'API', ->
# Groups # Groups
############ ############
describe.only 'Groups', -> describe 'Groups', ->
group = undefined group = undefined
it 'Creates a group', (done) -> before (done) ->
request.post("#{baseURL}/groups") request.post("#{baseURL}/groups")
.send({name:"TestGroup", type:"party"}) .send({name:"TestGroup", type:"party"})
.end (res) -> .end (res) ->
expectCode res, 200 expectCode res, 200
group = res.body group = res.body
expect(group.members.length).to.be 1
expect(group.leader).to.be user._id
done() done()
describe.only 'Challenges', -> describe 'Challenges', ->
challenge = undefined challenge = undefined
updateTodo = undefined updateTodo = undefined
@@ -228,353 +229,397 @@ describe 'API', ->
], done ], done
describe 'Quests', ->
party = undefined
it 'Invites some members', (done) ->
async.waterfall [
############ # Register new users
# Batch Update (cb) ->
############ async.parallel [
(cb2) -> registerNewUser(cb2,false)
(cb2) -> registerNewUser(cb2,false)
(cb2) -> registerNewUser(cb2,false)
], cb
describe 'Batch Update', -> # 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
it 'POST /api/v1/batch-update', (done) -> # Accept / Reject
userBefore = _.cloneDeep(currentUser) (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
ops = [ # Make sure the invites stuck
# Good scores (whatever, cb) ->
op: 'score', params: {id:user.habits[0].id, direction: 'up'} Group.findById group._id, (err, g) ->
op: 'score', params: {id:user.habits[1].id, direction: 'down'} expect(g.members.length).to.be 4
op: 'score', params: {id:user.dailys[0].id, direction: 'up'} cb()
op: 'score', params: {id:user.todos[0].id, direction: 'up'}
]
request.post("#{baseURL}/user/batch-update") ], (err, results) ->
.send(ops) expect(err).to.be.ok
.end (res) ->
expect(res.body.err).to.be undefined
expect(res.statusCode).to.be 200
#expectUserEqual(userBefore, res.body)
done() 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) # # Batch Update
############ # ############
#
it.skip 'POST /api/v2/batch-update (handles corrupt values)', (done) -> # describe 'Batch Update', ->
registerNewUser (_res) -> #
# corrupt the tasks, and let's see how the server handles this # it 'POST /api/v1/batch-update', (done) ->
ids = _res.dailyIds # userBefore = _.cloneDeep(currentUser)
_res.tasks[ids[0]].value = NaN #
_res.tasks[ids[1]].value = undefined # ops = [
_res.tasks[ids[2]] = {} # # Good scores
_res.tasks["undefined"] = {} # op: 'score', params: {id:user.habits[0].id, direction: 'up'}
# op: 'score', params: {id:user.habits[1].id, direction: 'down'}
_res.stats.hp = _res.stats.gp = NaN # op: 'score', params: {id:user.dailys[0].id, direction: 'up'}
# op: 'score', params: {id:user.todos[0].id, direction: 'up'}
_res.lastCron = +new Date('08/13/2013') # ]
#
ops = [ # request.post("#{baseURL}/user/batch-update")
op: 'score', task: _res.tasks[ids[0]], dir: 'up' # .send(ops)
] # .end (res) ->
# expect(res.body.err).to.be undefined
model.set "users.#{_res.id}", _res, -> # expect(res.statusCode).to.be 200
request.post("#{baseURL}/user/batch-update") # #expectUserEqual(userBefore, res.body)
.set('Accept', 'application/json') # done()
.set('X-API-User', _res.id) #
.set('X-API-Key', _res.apiToken) #
.send(ops) # ############
.end (res) -> # # 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)
expect(res.statusCode).to.be 200 # ############
console.log {stats:res.body.stats, tasks:res.body.tasks} #
done() # 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
#FIXME figure out how to compare the objects # ids = _res.dailyIds
it.skip 'GET /api/v1/user', (done) -> # _res.tasks[ids[0]].value = NaN
request.get("#{baseURL}/user") # _res.tasks[ids[1]].value = undefined
.end (res) -> # _res.tasks[ids[2]] = {}
expect(res.body.err).to.be undefined # _res.tasks["undefined"] = {}
expect(res.statusCode).to.be 200 #
expect(res.body.id).not.to.be.empty() # _res.stats.hp = _res.stats.gp = NaN
self = _.clone(currentUser) #
delete self.apiToken # _res.lastCron = +new Date('08/13/2013')
self.stats.toNextLevel = 150 #
self.stats.maxHealth = 50 # ops = [
# op: 'score', task: _res.tasks[ids[0]], dir: 'up'
expectUserEqual(res.body, self) # ]
done() #
# model.set "users.#{_res.id}", _res, ->
it.skip 'GET /api/v1/user/task/:id', (done) -> # request.post("#{baseURL}/user/batch-update")
tid = _.pluck(currentUser.tasks, 'id')[0] # .set('Accept', 'application/json')
request.get("#{baseURL}/user/task/#{tid}") # .set('X-API-User', _res.id)
.end (res) -> # .set('X-API-Key', _res.apiToken)
expect(res.body.err).to.be undefined # .send(ops)
expect(res.statusCode).to.be 200 # .end (res) ->
expect(res.body).to.eql currentUser.tasks[tid] # expect(res.statusCode).to.be 200
done() # console.log {stats:res.body.stats, tasks:res.body.tasks}
# done()
it.skip 'POST /api/v1/user/task', (done) -> #
request.post("#{baseURL}/user/task") #
.send({title: 'Title', text: 'Text', type: 'habit'}) # #FIXME figure out how to compare the objects
.end (res) -> # it.skip 'GET /api/v1/user', (done) ->
query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken) # request.get("#{baseURL}/user")
query.fetch (err, user) -> # .end (res) ->
expect(res.body.err).to.be undefined # expect(res.body.err).to.be undefined
expect(res.statusCode).to.be 201 # expect(res.statusCode).to.be 200
expect(res.body.id).not.to.be.empty() # expect(res.body.id).not.to.be.empty()
# Ensure that user owns the newly created object # self = _.clone(currentUser)
saved = user.get("tasks.#{res.body.id}") # delete self.apiToken
expect(saved).to.be.an('object') # self.stats.toNextLevel = 150
done() # self.stats.maxHealth = 50
#
it.skip 'POST /api/v1/user/task (without type)', (done) -> # expectUserEqual(res.body, self)
request.post("#{baseURL}/user/task") # done()
.send({}) #
.end (res) -> # it.skip 'GET /api/v1/user/task/:id', (done) ->
expect(res.body.err).to.be 'type must be habit, todo, daily, or reward' # tid = _.pluck(currentUser.tasks, 'id')[0]
expect(res.statusCode).to.be 400 # request.get("#{baseURL}/user/task/#{tid}")
done() # .end (res) ->
# expect(res.body.err).to.be undefined
it.skip 'POST /api/v1/user/task (only type)', (done) -> # expect(res.statusCode).to.be 200
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] # expect(res.body).to.eql currentUser.tasks[tid]
done() # done()
#
it.skip 'PUT /api/v1/user/task/:id (shouldnt update type)', (done) -> # it.skip 'POST /api/v1/user/task', (done) ->
tid = _.pluck(currentUser.tasks, 'id')[1] # request.post("#{baseURL}/user/task")
type = if currentUser.tasks[tid].type is 'habit' then 'daily' else 'habit' # .send({title: 'Title', text: 'Text', type: 'habit'})
request.put("#{baseURL}/user/task/#{tid}") # .end (res) ->
.send(type: type, text: 'fishman') # query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
.end (res) -> # query.fetch (err, user) ->
expect(res.body.err).to.be undefined # expect(res.body.err).to.be undefined
expect(res.statusCode).to.be 200 # expect(res.statusCode).to.be 201
currentUser.tasks[tid].text = 'fishman' # expect(res.body.id).not.to.be.empty()
expect(res.body).to.eql currentUser.tasks[tid] # # Ensure that user owns the newly created object
done() # saved = user.get("tasks.#{res.body.id}")
# expect(saved).to.be.an('object')
it.skip 'PUT /api/v1/user/task/:id (update notes)', (done) -> # done()
tid = _.pluck(currentUser.tasks, 'id')[2] #
request.put("#{baseURL}/user/task/#{tid}") # it.skip 'POST /api/v1/user/task (without type)', (done) ->
.send(text: 'hi',notes:'foobar matey') # request.post("#{baseURL}/user/task")
.end (res) -> # .send({})
expect(res.body.err).to.be undefined # .end (res) ->
expect(res.statusCode).to.be 200 # expect(res.body.err).to.be 'type must be habit, todo, daily, or reward'
currentUser.tasks[tid].text = 'hi' # expect(res.statusCode).to.be 400
currentUser.tasks[tid].notes = 'foobar matey' # done()
expect(res.body).to.eql currentUser.tasks[tid] #
done() # it.skip 'POST /api/v1/user/task (only type)', (done) ->
# request.post("#{baseURL}/user/task")
it.skip 'GET /api/v1/user/tasks', (done) -> # .send(type: 'habit')
request.get("#{baseURL}/user/tasks") # .end (res) ->
.end (res) -> # query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken) # query.fetch (err, user) ->
query.fetch (err, user) -> # expect(res.body.err).to.be undefined
expect(res.body.err).to.be undefined # expect(res.statusCode).to.be 201
expect(user.get()).to.be.ok() # expect(res.body.id).not.to.be.empty()
expect(res.statusCode).to.be 200 # # Ensure that user owns the newly created object
model.ref '_user', user # expect(user.get().tasks[res.body.id]).to.be.an('object')
tasks = [] # # Ensure that value gets set to 0 since not otherwise specified
for type in ['habit','todo','daily','reward'] # expect(user.get().tasks[res.body.id].value).to.be.equal(0)
model.refList "_#{type}List", "_user.tasks", "_user.#{type}Ids" # done()
tasks = tasks.concat model.get("_#{type}List") #
# Ensure that user owns the tasks # it.skip 'PUT /api/v1/user/task/:id', (done) ->
expect(res.body.length).to.equal tasks.length # tid = _.pluck(currentUser.tasks, 'id')[0]
# Ensure that the two sets are equal # request.put("#{baseURL}/user/task/#{tid}")
expect(_.difference(_.pluck(res.body,'id'), _.pluck(tasks,'id')).length).to.equal 0 # .send(text: 'bye')
done() # .end (res) ->
# expect(res.body.err).to.be undefined
it.skip 'GET /api/v1/user/tasks (todos)', (done) -> # expect(res.statusCode).to.be 200
request.get("#{baseURL}/user/tasks") # currentUser.tasks[tid].text = 'bye'
.query(type:'todo') # expectSameValues res.body, currentUser.tasks[tid], ['id','type','text']
.end (res) -> # #expect(res.body).to.eql currentUser.tasks[tid]
query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken) # done()
query.fetch (err, user) -> #
expect(res.body.err).to.be undefined # it.skip 'PUT /api/v1/user/task/:id (shouldnt update type)', (done) ->
expect(res.statusCode).to.be 200 # tid = _.pluck(currentUser.tasks, 'id')[1]
model.ref '_user', user # type = if currentUser.tasks[tid].type is 'habit' then 'daily' else 'habit'
model.refList "_todoList", "_user.tasks", "_user.todoIds" # request.put("#{baseURL}/user/task/#{tid}")
tasks = model.get("_todoList") # .send(type: type, text: 'fishman')
# Ensure that user owns the tasks # .end (res) ->
expect(res.body.length).to.equal tasks.length # expect(res.body.err).to.be undefined
# Ensure that the two sets are equal # expect(res.statusCode).to.be 200
expect(_.difference(_.pluck(res.body,'id'), _.pluck(tasks,'id')).length).to.equal 0 # currentUser.tasks[tid].text = 'fishman'
done() # expect(res.body).to.eql currentUser.tasks[tid]
# done()
it.skip 'DELETE /api/v1/user/task/:id', (done) -> #
tid = currentUser.habitIds[2] # it.skip 'PUT /api/v1/user/task/:id (update notes)', (done) ->
request.del("#{baseURL}/user/task/#{tid}") # tid = _.pluck(currentUser.tasks, 'id')[2]
.end (res) -> # request.put("#{baseURL}/user/task/#{tid}")
expect(res.body.err).to.be undefined # .send(text: 'hi',notes:'foobar matey')
expect(res.statusCode).to.be 204 # .end (res) ->
query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken) # expect(res.body.err).to.be undefined
query.fetch (err, user) -> # expect(res.statusCode).to.be 200
expect(user.get('habitIds').indexOf(tid)).to.be -1 # currentUser.tasks[tid].text = 'hi'
expect(user.get("tasks.#{tid}")).to.be undefined # currentUser.tasks[tid].notes = 'foobar matey'
done() # expect(res.body).to.eql currentUser.tasks[tid]
# done()
it.skip 'DELETE /api/v1/user/task/:id (no task found)', (done) -> #
tid = "adsfasdfjunkshouldntbeatask" # it.skip 'GET /api/v1/user/tasks', (done) ->
request.del("#{baseURL}/user/task/#{tid}") # request.get("#{baseURL}/user/tasks")
.end (res) -> # .end (res) ->
expect(res.statusCode).to.be 400 # query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
expect(res.body.err).to.be 'No task found.' # query.fetch (err, user) ->
done() # expect(res.body.err).to.be undefined
# expect(user.get()).to.be.ok()
it.skip 'POST /api/v1/user/task/:id/up (habit)', (done) -> # expect(res.statusCode).to.be 200
tid = currentUser.habitIds[0] # model.ref '_user', user
request.post("#{baseURL}/user/task/#{tid}/up") # tasks = []
.send({}) # for type in ['habit','todo','daily','reward']
.end (res) -> # model.refList "_#{type}List", "_user.tasks", "_user.#{type}Ids"
expect(res.body.err).to.be undefined # tasks = tasks.concat model.get("_#{type}List")
expect(res.statusCode).to.be 200 # # Ensure that user owns the tasks
expect(res.body).to.eql { gp: 1, exp: 7.5, lvl: 1, hp: 50, delta: 1 } # expect(res.body.length).to.equal tasks.length
done() # # Ensure that the two sets are equal
# expect(_.difference(_.pluck(res.body,'id'), _.pluck(tasks,'id')).length).to.equal 0
it.skip 'POST /api/v1/user/task/:id/up (daily)', (done) -> # done()
tid = currentUser.dailyIds[0] #
request.post("#{baseURL}/user/task/#{tid}/up") # it.skip 'GET /api/v1/user/tasks (todos)', (done) ->
.send({}) # request.get("#{baseURL}/user/tasks")
.end (res) -> # .query(type:'todo')
expect(res.body.err).to.be undefined # .end (res) ->
expect(res.statusCode).to.be 200 # query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
expect(res.body).to.eql { gp: 2, exp: 15, lvl: 1, hp: 50, delta: 1 } # query.fetch (err, user) ->
query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken) # expect(res.body.err).to.be undefined
query.fetch (err, user) -> # expect(res.statusCode).to.be 200
expect(user.get("tasks.#{tid}.completed")).to.be true # model.ref '_user', user
done() # model.refList "_todoList", "_user.tasks", "_user.todoIds"
# tasks = model.get("_todoList")
it.skip 'POST /api/v1/user/task (array)', (done) -> # # Ensure that user owns the tasks
habitId = currentUser.habitIds[0] # expect(res.body.length).to.equal tasks.length
dailyId = currentUser.dailyIds[0] # # Ensure that the two sets are equal
arr = [{ # expect(_.difference(_.pluck(res.body,'id'), _.pluck(tasks,'id')).length).to.equal 0
id: habitId # done()
text: 'hello' #
notes: 'note' # it.skip 'DELETE /api/v1/user/task/:id', (done) ->
},{ # tid = currentUser.habitIds[2]
text: 'new task' # request.del("#{baseURL}/user/task/#{tid}")
notes: 'notes!' # .end (res) ->
},{ # expect(res.body.err).to.be undefined
id: dailyId # expect(res.statusCode).to.be 204
del: true # query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
}] # query.fetch (err, user) ->
# expect(user.get('habitIds').indexOf(tid)).to.be -1
request.post("#{baseURL}/user/tasks") # expect(user.get("tasks.#{tid}")).to.be undefined
.send(arr) # done()
.end (res) -> #
expect(res.body.err).to.be undefined # it.skip 'DELETE /api/v1/user/task/:id (no task found)', (done) ->
expect(res.statusCode).to.be 201 # tid = "adsfasdfjunkshouldntbeatask"
# request.del("#{baseURL}/user/task/#{tid}")
expectSameValues res.body[0], {id: habitId,text: 'hello',notes: 'note'}, ['id','text','notes'] # .end (res) ->
expect(res.body[1].id).to.be.a 'string' # expect(res.statusCode).to.be 400
expect(res.body[1].text).to.be 'new task' # expect(res.body.err).to.be 'No task found.'
expect(res.body[1].notes).to.be 'notes!' # done()
expect(res.body[2]).to.eql deleted: true #
# it.skip 'POST /api/v1/user/task/:id/up (habit)', (done) ->
query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken) # tid = currentUser.habitIds[0]
query.fetch (err, user) -> # request.post("#{baseURL}/user/task/#{tid}/up")
expectSameValues user.get("tasks.#{habitId}"), {id: habitId,text: 'hello',notes: 'note'}, ['id','text','notes'] # .send({})
expect(user.get("tasks.#{dailyId}")).to.be undefined # .end (res) ->
expectSameValues user.get("tasks.#{res.body[1].id}"), {id: res.body[1].id, text: 'new task', notes: 'notes!'}, ['id','text','notes'] # expect(res.body.err).to.be undefined
done() # expect(res.statusCode).to.be 200
# expect(res.body).to.eql { gp: 1, exp: 7.5, lvl: 1, hp: 50, delta: 1 }
it.skip 'PUT /api/v1/user (bad path)', (done) -> # done()
# These updates should not save, as per the API changes #
userUpdates = # it.skip 'POST /api/v1/user/task/:id/up (daily)', (done) ->
stats: hp: 30 # tid = currentUser.dailyIds[0]
flags: itemsEnabled: true # request.post("#{baseURL}/user/task/#{tid}/up")
tasks: [{ # .send({})
text: 'hello2' # .end (res) ->
notes: 'note2' # 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 }
request.put("#{baseURL}/user") # query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
.send(userUpdates) # query.fetch (err, user) ->
.end (res) -> # expect(user.get("tasks.#{tid}.completed")).to.be true
expect(res.body.err).to.be.ok() # done()
expect(res.statusCode).to.be 500 #
done() # it.skip 'POST /api/v1/user/task (array)', (done) ->
# habitId = currentUser.habitIds[0]
it.skip 'PUT /api/v1/user', (done) -> # dailyId = currentUser.dailyIds[0]
userBefore = {} # arr = [{
query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken) # id: habitId
query.fetch (err, user) -> # text: 'hello'
userBefore = user.get() # notes: 'note'
# },{
habitId = currentUser.habitIds[0] # text: 'new task'
dailyId = currentUser.dailyIds[0] # notes: 'notes!'
updates = {} # },{
updates['stats.hp'] = 30 # id: dailyId
updates['flags.itemsEnabled'] = true # del: true
updates["tasks.#{habitId}.text"] = 'hello2' # }]
updates["tasks.#{habitId}.notes"] = 'note2' #
# request.post("#{baseURL}/user/tasks")
request.put("#{baseURL}/user") # .send(arr)
.send(updates) # .end (res) ->
.end (res) -> # expect(res.body.err).to.be undefined
expect(res.body.err).to.be undefined # expect(res.statusCode).to.be 201
expect(res.statusCode).to.be 200 #
changesWereMade = (obj) -> # expectSameValues res.body[0], {id: habitId,text: 'hello',notes: 'note'}, ['id','text','notes']
expect(obj.stats.hp).to.be 30 # expect(res.body[1].id).to.be.a 'string'
expect(obj.flags.itemsEnabled).to.be true # expect(res.body[1].text).to.be 'new task'
expectSameValues _.find(obj.tasks,{id:habitId}), {id: habitId,text: 'hello2',notes: 'note2'}, ['id','text','notes'] # expect(res.body[1].notes).to.be 'notes!'
changesWereMade res.body # expect(res.body[2]).to.eql deleted: true
query.fetch (err, user) -> #
changesWereMade user.get() # query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
done() # query.fetch (err, user) ->
# expectSameValues user.get("tasks.#{habitId}"), {id: habitId,text: 'hello',notes: 'note'}, ['id','text','notes']
it.skip 'POST /api/v1/user/auth/local', (done) -> # expect(user.get("tasks.#{dailyId}")).to.be undefined
userAuth = {username, password} # expectSameValues user.get("tasks.#{res.body[1].id}"), {id: res.body[1].id, text: 'new task', notes: 'notes!'}, ['id','text','notes']
request.post("#{baseURL}/user/auth/local") # done()
.set('Accept', 'application/json') #
.send(userAuth) # it.skip 'PUT /api/v1/user (bad path)', (done) ->
.end (res) -> # # These updates should not save, as per the API changes
expect(res.body.err).to.be undefined # userUpdates =
expect(res.statusCode).to.be 200 # stats: hp: 30
expect(res.body.id).to.be currentUser.id # flags: itemsEnabled: true
expect(res.body.token).to.be currentUser.apiToken # tasks: [{
done() # text: 'hello2'
# notes: 'note2'
it.skip 'POST /api/v1/user/auth/facebook', (done) -> # }]
id = shared.uuid() #
userAuth = facebook_id: 12345, name: 'Tyler Renelle', email: 'x@y.com' # request.put("#{baseURL}/user")
newUser = helpers.newUser(true) # .send(userUpdates)
newUser.id = id # .end (res) ->
newUser.auth = facebook: # expect(res.body.err).to.be.ok()
id: userAuth.facebook_id # expect(res.statusCode).to.be 500
name: userAuth.name # done()
email: userAuth.email #
model.set "users.#{id}", newUser, -> # it.skip 'PUT /api/v1/user', (done) ->
# userBefore = {}
request.post("#{baseURL}/user/auth/facebook") # query = model.query('users').withIdAndToken(currentUser.id, currentUser.apiToken)
.set('Accept', 'application/json') # query.fetch (err, user) ->
.send(userAuth) # userBefore = user.get()
.end (res) -> #
expect(res.body.err).to.be undefined # habitId = currentUser.habitIds[0]
expect(res.statusCode).to.be 200 # dailyId = currentUser.dailyIds[0]
expect(res.body.id).to.be newUser.id # updates = {}
#expect(res.body.token).to.be newUser.apiToken # updates['stats.hp'] = 30
done() # 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()
#
#