mirror of
https://github.com/HabitRPG/habitica.git
synced 2025-12-17 14:47:53 +01:00
501 lines
16 KiB
CoffeeScript
501 lines
16 KiB
CoffeeScript
'use strict'
|
|
|
|
diff = require("deep-diff")
|
|
|
|
Group = require("../../website/src/models/group").model
|
|
app = require("../../website/src/server")
|
|
|
|
describe "Guilds", ->
|
|
context "creating groups", ->
|
|
before (done) ->
|
|
registerNewUser ->
|
|
User.findByIdAndUpdate user._id,
|
|
$set:
|
|
"balance": 40
|
|
, (err, _user) ->
|
|
done()
|
|
, true
|
|
|
|
it "can create a public guild", (done) ->
|
|
request.post(baseURL + "/groups").send(
|
|
name: "TestGroup"
|
|
type: "guild",
|
|
privacy: "public"
|
|
).end (res) ->
|
|
expectCode res, 200
|
|
guild = res.body
|
|
expect(guild.members.length).to.equal 1
|
|
expect(guild.leader).to.equal user._id
|
|
done()
|
|
|
|
it "can create a private guild", (done) ->
|
|
request.post(baseURL + "/groups").send(
|
|
name: "TestGroup"
|
|
type: "guild",
|
|
privacy: "private"
|
|
).end (res) ->
|
|
expectCode res, 200
|
|
guild = res.body
|
|
expect(guild.members.length).to.equal 1
|
|
expect(guild.leader).to.equal user._id
|
|
done()
|
|
|
|
it "prevents user from creating a guild when the user has 0 gems", (done) ->
|
|
registerNewUser (err, user_with_0_gems) ->
|
|
request.post(baseURL + "/groups").send(
|
|
name: "TestGroup"
|
|
type: "guild",
|
|
)
|
|
.set("X-API-User", user_with_0_gems._id)
|
|
.set("X-API-Key", user_with_0_gems.apiToken)
|
|
.end (res) ->
|
|
expectCode res, 401
|
|
done()
|
|
, false
|
|
|
|
context "get guilds", ->
|
|
guild = undefined
|
|
|
|
beforeEach (done)->
|
|
request.post(baseURL + "/groups").send(
|
|
name: "TestGroup2"
|
|
type: "guild"
|
|
).end (res) ->
|
|
guild = res.body
|
|
done()
|
|
|
|
it "can find a guild", (done) ->
|
|
request.get(baseURL + "/groups/" + guild._id)
|
|
.end (res) ->
|
|
expectCode res, 200
|
|
expect(res.body._id).to.equal res.body._id
|
|
done()
|
|
|
|
it "transforms members array to an arrray of user objects", (done) ->
|
|
request.get(baseURL + "/groups/" + guild._id)
|
|
.end (res) ->
|
|
expectCode res, 200
|
|
members = res.body.members
|
|
# @TODO: would be more instructive if it had more members in guild :(
|
|
_(members).each (member) ->
|
|
expect(member).to.be.an 'object'
|
|
expect(member.profile.name).to.exist
|
|
done()
|
|
|
|
it "transforms leader id to a user object", (done) ->
|
|
request.get(baseURL + "/groups/" + guild._id)
|
|
.end (res) ->
|
|
expectCode res, 200
|
|
leader = res.body.leader
|
|
expect(leader).to.be.an 'object'
|
|
expect(leader.profile.name).to.exist
|
|
done()
|
|
|
|
it "can list guilds", (done) ->
|
|
request.get(baseURL + "/groups").send()
|
|
.end (res) ->
|
|
expectCode res, 200
|
|
guild = res.body[0]
|
|
expect(guild).to.exist
|
|
done()
|
|
|
|
context "updating groups", ->
|
|
groupToUpdate = undefined
|
|
before (done) ->
|
|
request.post(baseURL + "/groups").send(
|
|
name: "TestGroup"
|
|
type: "guild"
|
|
description: "notUpdatedDesc"
|
|
).end (res) ->
|
|
groupToUpdate = res.body
|
|
done()
|
|
|
|
it "prevents user from updating a party when they aren't the leader", (done) ->
|
|
registerNewUser (err, tmpUser) ->
|
|
request.post(baseURL + "/groups/" + groupToUpdate._id).send(
|
|
name: "TestGroupName"
|
|
description: "updatedDesc"
|
|
)
|
|
.set("X-API-User", tmpUser._id)
|
|
.set("X-API-Key", tmpUser.apiToken)
|
|
.end (res) ->
|
|
expectCode res, 401
|
|
expect(res.body.err).to.equal "Only the group leader can update the group!"
|
|
done()
|
|
, false
|
|
|
|
it "allows user to update a group", (done) ->
|
|
request.post(baseURL + "/groups/" + groupToUpdate._id).send(
|
|
description: "updatedDesc"
|
|
)
|
|
.end (res) ->
|
|
expectCode res, 204
|
|
request.get(baseURL + "/groups/" + groupToUpdate._id).send()
|
|
.end (res) ->
|
|
updatedGroup = res.body
|
|
expect(updatedGroup.description).to.equal "updatedDesc"
|
|
done()
|
|
|
|
context "leaving groups", ->
|
|
it "can leave a guild", (done) ->
|
|
guildToLeave = undefined
|
|
request.post(baseURL + "/groups").send(
|
|
name: "TestGroupToLeave"
|
|
type: "guild"
|
|
).end (res) ->
|
|
guildToLeave = res.body
|
|
request.post(baseURL + "/groups/" + guildToLeave._id + "/leave")
|
|
.send()
|
|
.end (res) ->
|
|
expectCode res, 204
|
|
done()
|
|
|
|
it "deletes a group when the last member leaves", (done) ->
|
|
groupToDeleteAfterLeave = undefined
|
|
request.post(baseURL + "/groups").send(
|
|
name: "TestGroupToDeleteAfteLeave"
|
|
type: "guild"
|
|
privacy: "private"
|
|
).end (res) ->
|
|
groupToDeleteAfterLeave = res.body
|
|
async.waterfall [
|
|
(cb) ->
|
|
request.post(baseURL + "/groups/" + groupToDeleteAfterLeave._id + "/leave")
|
|
.end (res) ->
|
|
expectCode res, 204
|
|
cb()
|
|
|
|
(cb) ->
|
|
request.post(baseURL + "/groups/" + groupToDeleteAfterLeave._id)
|
|
.end (res) ->
|
|
expectCode res, 404
|
|
cb()
|
|
], done
|
|
|
|
it "deletes all invites to a group (guild) when the last member leaves", (done) ->
|
|
groupToDeleteAfterLeave = undefined
|
|
userToRemoveInvite = undefined
|
|
request.post(baseURL + "/groups").send(
|
|
name: "TestGroupToDeleteAfterLeave"
|
|
type: "guild"
|
|
privacy: "private"
|
|
).end (res) ->
|
|
groupToDeleteAfterLeave = res.body
|
|
async.waterfall [
|
|
(cb) ->
|
|
registerManyUsers 1, cb
|
|
|
|
(_members, cb) ->
|
|
userToRemoveInvite = _members[0]
|
|
inviteURL = baseURL + "/groups/" + groupToDeleteAfterLeave._id + "/invite"
|
|
request.post(inviteURL).send(
|
|
uuids: [userToRemoveInvite._id]
|
|
)
|
|
.end ->
|
|
cb()
|
|
|
|
(cb) ->
|
|
request.post(baseURL + "/groups/" + groupToDeleteAfterLeave._id + "/leave")
|
|
.end (res) ->
|
|
expectCode res, 204
|
|
cb()
|
|
|
|
(cb) ->
|
|
request.get(baseURL + '/user')
|
|
.set("X-API-User", userToRemoveInvite._id)
|
|
.set("X-API-Key", userToRemoveInvite.apiToken)
|
|
.end (err, res) ->
|
|
expectCode res, 200
|
|
groupInvitation = _.find(res.body.invitations.guilds, {id: groupToDeleteAfterLeave._id})
|
|
expect(groupInvitation).to.not.exist
|
|
cb()
|
|
|
|
(cb) ->
|
|
request.post(baseURL + "/groups/" + groupToDeleteAfterLeave._id)
|
|
.end (res) ->
|
|
expectCode res, 404
|
|
cb()
|
|
], done
|
|
|
|
it "deletes all invites to a group (party) when the last member leaves", (done) ->
|
|
partyToDeleteAfterLeave = undefined
|
|
userToRemovePartyInvite = undefined
|
|
request.post(baseURL + "/groups").send(
|
|
name: "TestPartyToDeleteAfterLeave"
|
|
type: "party"
|
|
).end (res) ->
|
|
partyToDeleteAfterLeave = res.body
|
|
async.waterfall [
|
|
(cb) ->
|
|
registerManyUsers 1, cb
|
|
|
|
(_members, cb) ->
|
|
userToRemovePartyInvite = _members[0]
|
|
inviteURL = baseURL + "/groups/" + partyToDeleteAfterLeave._id + "/invite"
|
|
request.post(inviteURL).send(
|
|
uuids: [userToRemovePartyInvite._id]
|
|
)
|
|
.end ->
|
|
cb()
|
|
|
|
(cb) ->
|
|
request.post(baseURL + "/groups/" + partyToDeleteAfterLeave._id + "/leave")
|
|
.end (res) ->
|
|
expectCode res, 204
|
|
cb()
|
|
|
|
(cb) ->
|
|
request.get(baseURL + '/user')
|
|
.set("X-API-User", userToRemovePartyInvite._id)
|
|
.set("X-API-Key", userToRemovePartyInvite.apiToken)
|
|
.end (err, res) ->
|
|
expectCode res, 200
|
|
party = partyToDeleteAfterLeave
|
|
partyInvitation = _.find(res.body.invitations.party, (invite) ->
|
|
return invite == party._id
|
|
)
|
|
expect(partyInvitation).to.not.exist
|
|
cb()
|
|
|
|
(cb) ->
|
|
request.post(baseURL + "/groups/" + partyToDeleteAfterLeave._id)
|
|
.end (res) ->
|
|
expectCode res, 404
|
|
cb()
|
|
], done
|
|
|
|
context "removing users groups", ->
|
|
it "allows guild leaders to remove a member (but not themselves)", (done) ->
|
|
guildToRemoveMember = undefined
|
|
members = undefined
|
|
userToRemove = undefined
|
|
request.post(baseURL + "/groups").send(
|
|
name: "TestGuildToRemoveMember"
|
|
type: "guild"
|
|
).end (res) ->
|
|
guildToRemoveMember = res.body
|
|
#Add members to guild
|
|
async.waterfall [
|
|
(cb) ->
|
|
registerManyUsers 1, cb
|
|
|
|
(_members, cb) ->
|
|
userToRemove = _members[0]
|
|
members = _members
|
|
inviteURL = baseURL + "/groups/" + guildToRemoveMember._id + "/invite"
|
|
request.post(inviteURL).send(
|
|
uuids: [userToRemove._id]
|
|
)
|
|
.end ->
|
|
cb()
|
|
|
|
(cb) ->
|
|
request.post(baseURL + "/groups/" + guildToRemoveMember._id + "/join")
|
|
.set("X-API-User", userToRemove._id)
|
|
.set("X-API-Key", userToRemove.apiToken)
|
|
.end (res) ->
|
|
cb()
|
|
(cb) ->
|
|
request.post(baseURL + "/groups/" + guildToRemoveMember._id + "/removeMember?uuid=" + guildToRemoveMember.leader)
|
|
.send().end (res) ->
|
|
expectCode res, 401
|
|
cb()
|
|
|
|
(cb) ->
|
|
request.post(baseURL + "/groups/" + guildToRemoveMember._id + "/removeMember?uuid=" + userToRemove._id)
|
|
.send().end (res) ->
|
|
expectCode res, 204
|
|
cb()
|
|
|
|
(cb) ->
|
|
request.get(baseURL + "/groups/" + guildToRemoveMember._id)
|
|
.send()
|
|
.end (res) ->
|
|
g = res.body
|
|
userInGroup = _.find g.members, (member) -> return member._id == userToRemove._id
|
|
expect(userInGroup).to.not.exist
|
|
cb()
|
|
|
|
], done
|
|
|
|
describe "Private Guilds", ->
|
|
guild = undefined
|
|
before (done) ->
|
|
request.post(baseURL + "/groups").send(
|
|
name: "TestPrivateGroup"
|
|
type: "guild"
|
|
privacy: "private"
|
|
).end (res) ->
|
|
expectCode res, 200
|
|
guild = res.body
|
|
expect(guild.members.length).to.equal 1
|
|
expect(guild.leader).to.equal user._id
|
|
#Add members to guild
|
|
async.waterfall [
|
|
(cb) ->
|
|
registerManyUsers 15, cb
|
|
|
|
(_members, cb) ->
|
|
members = _members
|
|
|
|
joinGuild = (member, callback) ->
|
|
request.post(baseURL + "/groups/" + guild._id + "/join")
|
|
.set("X-API-User", member._id)
|
|
.set("X-API-Key", member.apiToken)
|
|
.end ->
|
|
callback(null, null)
|
|
|
|
async.map members, joinGuild, (err, results) -> cb()
|
|
|
|
], done
|
|
|
|
it "includes user in private group member list when user is a member", (done) ->
|
|
|
|
request.get(baseURL + "/groups/" + guild._id)
|
|
.end (res) ->
|
|
g = res.body
|
|
userInGroup = _.find g.members, (member) -> return member._id == user._id
|
|
expect(userInGroup).to.exist
|
|
done()
|
|
|
|
it "excludes user from viewing private group member list when user is not a member", (done) ->
|
|
|
|
request.post(baseURL + "/groups/" + guild._id + "/leave")
|
|
.end (res) ->
|
|
request.get(baseURL + "/groups/" + guild._id)
|
|
.end (res) ->
|
|
expect res, 404
|
|
done()
|
|
|
|
describe "Public Guilds", ->
|
|
before (done) ->
|
|
async.waterfall [
|
|
(cb) ->
|
|
registerNewUser ->
|
|
User.findByIdAndUpdate user._id, {$set: { "balance": 10 } }, (err, _user) ->
|
|
cb()
|
|
, true
|
|
], done
|
|
|
|
context "joining groups", ->
|
|
it "makes user a group leader when group is empty", (done) ->
|
|
guildToEmptyAndAssignLeader = undefined
|
|
members = undefined
|
|
userToBecomeLeader = undefined
|
|
request.post(baseURL + "/groups").send(
|
|
name: "TestGuildToEmptyAndAssignLeader"
|
|
type: "guild",
|
|
privacy: "public"
|
|
).end (res) ->
|
|
guildToEmptyAndAssignLeader = res.body
|
|
#Add members to guild
|
|
async.waterfall [
|
|
(cb) ->
|
|
registerManyUsers 1, cb
|
|
|
|
(_members, cb) ->
|
|
userToBecomeLeader = _members[0]
|
|
members = _members
|
|
inviteURL = baseURL + "/groups/" + guildToEmptyAndAssignLeader._id + "/invite"
|
|
request.post(inviteURL).send(
|
|
uuids: [userToBecomeLeader._id]
|
|
)
|
|
.end ->
|
|
cb()
|
|
|
|
(cb) ->
|
|
request.post(baseURL + "/groups/" + guildToEmptyAndAssignLeader._id + "/leave")
|
|
.send()
|
|
.end (res) ->
|
|
expectCode res, 204
|
|
cb()
|
|
|
|
(cb) ->
|
|
request.post(baseURL + "/groups/" + guildToEmptyAndAssignLeader._id + "/join")
|
|
.set("X-API-User", userToBecomeLeader._id)
|
|
.set("X-API-Key", userToBecomeLeader.apiToken)
|
|
.end (res) ->
|
|
expectCode res, 200
|
|
cb()
|
|
|
|
(cb) ->
|
|
request.get(baseURL + "/groups/" + guildToEmptyAndAssignLeader._id)
|
|
.set("X-API-User", userToBecomeLeader._id)
|
|
.set("X-API-Key", userToBecomeLeader.apiToken)
|
|
.send()
|
|
.end (res) ->
|
|
expectCode res, 200
|
|
g = res.body
|
|
expect(g.leader._id).to.equal(userToBecomeLeader._id)
|
|
cb()
|
|
|
|
], done
|
|
|
|
context "viewing", ->
|
|
guild = undefined
|
|
before (done) ->
|
|
async.waterfall [
|
|
(cb) ->
|
|
registerNewUser ->
|
|
User.findByIdAndUpdate user._id, {$set: { "balance": 10 } }, (err, _user) ->
|
|
cb()
|
|
, true
|
|
(cb) ->
|
|
request.post(baseURL + "/groups").send(
|
|
name: "TestPublicGroup"
|
|
type: "guild"
|
|
privacy: "public"
|
|
).end (res) ->
|
|
guild = res.body
|
|
expect(guild.members.length).to.equal 1
|
|
expect(guild.leader).to.equal user._id
|
|
#Add members to guild
|
|
cb()
|
|
|
|
(cb) ->
|
|
registerManyUsers 15, cb
|
|
|
|
(_members, cb) ->
|
|
members = _members
|
|
|
|
joinGuild = (member, callback) ->
|
|
request.post(baseURL + "/groups/" + guild._id + "/join")
|
|
.set("X-API-User", member._id)
|
|
.set("X-API-Key", member.apiToken)
|
|
.end ->
|
|
callback(null, null)
|
|
|
|
async.map members, joinGuild, (err, results) -> cb()
|
|
|
|
], done
|
|
|
|
context "is a member", ->
|
|
before (done) ->
|
|
registerNewUser ->
|
|
request.post(baseURL + "/groups/" + guild._id + "/join")
|
|
.end (res)->
|
|
done()
|
|
, true
|
|
|
|
it "includes user in public group member list", (done) ->
|
|
request.get(baseURL + "/groups/" + guild._id)
|
|
.end (res) ->
|
|
g = res.body
|
|
expect(g.members.length).to.equal 15
|
|
userInGroup = _.find g.members, (member) -> return member._id == user._id
|
|
expect(userInGroup).to.exist
|
|
done()
|
|
|
|
context "is not a member", ->
|
|
before (done) ->
|
|
registerNewUser done, true
|
|
|
|
it "excludes user in public group member list", (done) ->
|
|
request.get(baseURL + "/groups/" + guild._id)
|
|
.end (res) ->
|
|
g = res.body
|
|
expect(g.members.length).to.equal 15
|
|
userInGroup = _.find g.members, (member) -> return member._id == user._id
|
|
expect(userInGroup).to.not.exist
|
|
done()
|