sudoxreboot/habitica
1
0
Fork 0
mirror of https://github.com/sudoxnym/habitica.git synced 2026-07-16 00:42:18 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Move join party tests to new structure.

Browse source
This commit is contained in:
Blade Barringer 2015-10-29 07:41:49 -05:00
parent 55fcf678c3
commit 5cc790093e
2 changed files with 103 additions and 118 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

118
test/api-legacy/party.coffee
View file

@ -6,124 +6,6 @@ Group = require("../../website/src/models/group").model
app = require("../../website/src/server")
describe "Party", ->
context "creating a party", ->
it "creates a party", (done) ->
async.waterfall [
(cb) ->
registerNewUser(cb, true)
(user, cb) ->
request.post(baseURL + "/groups").send(
name: "TestGroup"
type: "party"
).end (err, res) ->
expectCode res, 200
group = res.body
expect(group.members.length).to.equal 1
expect(group.leader).to.equal user._id
cb()
], done
it "prevents user from creating a second party", (done) ->
request.post(baseURL + "/groups").send(
name: "TestGroup"
type: "party"
).end (err, res) ->
expectCode res, 400
expect(res.body.err).to.equal "Already in a party, try refreshing."
done()
context "Searching for a party", ->
group = undefined
beforeEach (done) ->
async.waterfall [
(cb) ->
registerNewUser(cb, true)
(user, cb) ->
request.post(baseURL + "/groups").send(
name: "TestGroup"
type: "party"
).end (err, res) ->
expectCode res, 200
group = res.body
expect(group.members.length).to.equal 1
expect(group.leader).to.equal user._id
cb()
], done
it "can be found by querying for group type party", (done) ->
request.get(baseURL + "/groups/").send(
type: "party"
).end (err, res) ->
expectCode res, 200
party = _.find res.body, (g) -> return g._id == group._id
expect(party._id).to.equal group._id
expect(party.leader).to.equal user._id
expect(party.name).to.equal group.name
expect(party.quest).to.deep.equal { progress: {} }
expect(party.memberCount).to.equal group.memberCount
done()
context "joining a party", ->
group = undefined
beforeEach (done) ->
async.waterfall [
(cb) ->
registerNewUser(cb, true)
(user, cb) ->
request.post(baseURL + "/groups").send(
name: "TestGroup"
type: "party"
).end (err, res) ->
expectCode res, 200
group = res.body
expect(group.members.length).to.equal 1
expect(group.leader).to.equal user._id
cb()
], done
it "prevents user from joining a party when they haven't been invited", (done) ->
registerNewUser (err, user) ->
request.post(baseURL + "/groups/" + group._id + "/join").send()
.set("X-API-User", user._id)
.set("X-API-Key", user.apiToken)
.end (err, res) ->
expectCode res, 401
expect(res.body.err).to.equal "Can't join a group you're not invited to."
done()
, false
it "allows users to join a party when they have been invited", (done) ->
tmpUser = undefined
async.waterfall [
(cb) ->
registerNewUser(cb, false)
(user, cb) ->
tmpUser = user
inviteURL = baseURL + "/groups/" + group._id + "/invite"
request.post(inviteURL).send(
uuids: [tmpUser._id]
)
.end ->
cb()
(cb) ->
request.post(baseURL + "/groups/" + group._id + "/join")
.set("X-API-User", tmpUser._id)
.set("X-API-Key", tmpUser.apiToken)
.end (err, res) ->
expectCode res, 200
cb()
(cb) ->
Group.findById group._id, (err, grp) ->
expect(grp.members).to.include(tmpUser._id)
cb()
], done
context "Quests", ->
party = undefined
group = undefined

103
test/api/groups/POST-groups_id_join.test.js
View file

@ -3,6 +3,7 @@ import {
generateUser,
requester,
} from '../../helpers/api.helper';
import { each, find } from 'lodash';
describe('POST /groups/:id/join', () => {
@ -10,6 +11,108 @@ describe('POST /groups/:id/join', () => {
it('returns an error');
});
each({
'public guild': {type: 'guild', privacy: 'public'},
'private guild': {type: 'guild', privacy: 'private'},
'party': {type: 'party', privacy: 'private'},
}, (data, groupType) => {
context(`user has invitation to a ${groupType}`, () => {
let api, group, invitee;
beforeEach(() => {
return createAndPopulateGroup({
groupDetails: {
type: data.type,
privacy: data.privacy,
},
invites: 1,
}).then((res) => {
group = res.group;
invitee = res.invitees[0];
api = requester(invitee);
});
});
it(`allows user to join a ${groupType}`, () => {
return api.post(`/groups/${group._id}/join`).then((res) => {
return api.get(`/groups/${group._id}`);
}).then((_group) => {
let members = _group.members;
let userInGroup = find(members, (user) => {
return user._id === invitee._id;
});
expect(userInGroup).to.exist;
});
});
});
});
each({
'private guild': {type: 'guild', privacy: 'private'},
'party': {type: 'party', privacy: 'private'},
}, (data, groupType) => {
context(`user does not have an invitation to a ${groupType}`, () => {
let api, group, user;
beforeEach(() => {
return createAndPopulateGroup({
groupDetails: {
type: data.type,
privacy: data.privacy,
},
}).then((res) => {
group = res.group;
return generateUser();
}).then((generatedUser) => {
user = generatedUser;
api = requester(user);
});
});
it(`does not allow user to join a ${groupType}`, () => {
return expect(api.post(`/groups/${group._id}/join`).then((res) => {
return api.get(`/groups/${group._id}`);
})).to.eventually.be.rejected.and.eql({
code: 401,
text: 'Can\'t join a group you\'re not invited to.',
});
});
});
});
context('user does not have an invitation to a public group', () => {
let api, group, user;
beforeEach(() => {
return createAndPopulateGroup({
groupDetails: {
type: 'guild',
privacy: 'public',
},
}).then((res) => {
group = res.group;
return generateUser();
}).then((generatedUser) => {
user = generatedUser;
api = requester(user);
});
});
it('allows user to join a public guild', () => {
return api.post(`/groups/${group._id}/join`).then((res) => {
return api.get(`/groups/${group._id}`);
}).then((_group) => {
let members = _group.members;
let userInGroup = find(members, (member) => {
return user._id === user._id;
});
expect(userInGroup).to.exist;
});
});
});
context('public guild has no leader', () => {
let user, group;