Merge branch 'develop' into flag_messages_in_api
This commit is contained in:
Blade Barringer
@@ -0,0 +1,122 @@
|
||||
import {
|
||||
generateGroup,
|
||||
generateUser,
|
||||
resetHabiticaDB,
|
||||
requester,
|
||||
} from '../../../helpers/api-integration.helper';
|
||||
|
||||
describe('GET /groups', () => {
|
||||
const NUMBER_OF_PUBLIC_GUILDS = 3;
|
||||
const NUMBER_OF_USERS_GUILDS = 2;
|
||||
|
||||
let user, api;
|
||||
|
||||
before(() => {
|
||||
let leader, createdGroup;
|
||||
|
||||
// Set up a world with a mixture of public and private guilds
|
||||
// Invite user to a few of them
|
||||
return resetHabiticaDB().then(() => {
|
||||
return generateUser();
|
||||
}).then((_user) => {
|
||||
user = _user;
|
||||
|
||||
return generateUser({
|
||||
balance: 10,
|
||||
});
|
||||
}).then((_user) => {
|
||||
leader = _user;
|
||||
api = requester(leader);
|
||||
|
||||
let publicGuildWithUserAsMember = generateGroup(leader, {
|
||||
name: 'public guild - is member',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
members: [leader._id, user._id],
|
||||
});
|
||||
|
||||
let publicGuildWithoutUserAsMember = generateGroup(leader, {
|
||||
name: 'public guild - is not member',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
});
|
||||
|
||||
let privateGuildWithUserAsMember = generateGroup(leader, {
|
||||
name: 'private guild - is member',
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
members: [leader._id, user._id],
|
||||
});
|
||||
|
||||
let privateGuildWithoutUserAsMember = generateGroup(leader, {
|
||||
name: 'private guild - is not member',
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
});
|
||||
|
||||
let partyWithoutUserAsMember = generateGroup(leader, {
|
||||
name: 'party name',
|
||||
type: 'party',
|
||||
privacy: 'private',
|
||||
});
|
||||
|
||||
let promises = [
|
||||
publicGuildWithUserAsMember,
|
||||
publicGuildWithoutUserAsMember,
|
||||
privateGuildWithUserAsMember,
|
||||
privateGuildWithoutUserAsMember,
|
||||
partyWithoutUserAsMember,
|
||||
];
|
||||
|
||||
return Promise.all(promises);
|
||||
}).then((groups) => {
|
||||
api = requester(user);
|
||||
return api.post('/groups', {
|
||||
type: 'party',
|
||||
name: 'user\'s party',
|
||||
privacy: 'private',
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('no query passed in', () => {
|
||||
|
||||
xit('lists all public guilds, the tavern, user\'s party, and any private guilds that user is a part of - TODO query includes duplicates - IE, tavern is included as tavern and part of public guilds. Refactor so this is not the case');
|
||||
});
|
||||
|
||||
context('tavern passed in as query', () => {
|
||||
|
||||
it('returns only the tavern', () => {
|
||||
return expect(api.get('/groups', null, {type: 'tavern'}))
|
||||
.to.eventually.have.a.lengthOf(1)
|
||||
.and.to.have.deep.property('[0]')
|
||||
.and.to.have.property('_id', 'habitrpg');
|
||||
});
|
||||
});
|
||||
|
||||
context('party passed in as query', () => {
|
||||
|
||||
it('returns only the user\'s party', () => {
|
||||
return expect(api.get('/groups', null, {type: 'party'}))
|
||||
.to.eventually.have.a.lengthOf(1)
|
||||
.and.to.have.deep.property('[0]')
|
||||
.and.to.have.property('leader', user._id);
|
||||
});
|
||||
});
|
||||
|
||||
context('public passed in as query', () => {
|
||||
|
||||
it('returns all public guilds', () => {
|
||||
return expect(api.get('/groups', null, {type: 'public'}))
|
||||
.to.eventually.have.a.lengthOf(NUMBER_OF_PUBLIC_GUILDS);
|
||||
});
|
||||
});
|
||||
|
||||
context('guilds passed in as query', () => {
|
||||
|
||||
it('returns all guilds user is a part of ', () => {
|
||||
return expect(api.get('/groups', null, {type: 'guilds'}))
|
||||
.to.eventually.have.a.lengthOf(NUMBER_OF_USERS_GUILDS);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,361 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateUser,
|
||||
requester,
|
||||
translate as t,
|
||||
} from '../../../helpers/api-integration.helper';
|
||||
import {
|
||||
find,
|
||||
each
|
||||
} from 'lodash';
|
||||
|
||||
describe('GET /groups/:id', () => {
|
||||
|
||||
let typesOfGroups = {};
|
||||
typesOfGroups['public guild'] = { type: 'guild', privacy: 'public' };
|
||||
typesOfGroups['private guild'] = { type: 'guild', privacy: 'private' };
|
||||
typesOfGroups['party'] = { type: 'party', privacy: 'private' };
|
||||
|
||||
each(typesOfGroups, (groupData, groupType) => {
|
||||
context(`Member of a ${groupType}`, () => {
|
||||
let leader, member, createdGroup;
|
||||
|
||||
before(() => {
|
||||
return createAndPopulateGroup({
|
||||
members: 30,
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
leader = res.leader;
|
||||
member = res.members[0];
|
||||
createdGroup = res.group;
|
||||
});
|
||||
});
|
||||
|
||||
it('returns the group object', () => {
|
||||
let api = requester(member);
|
||||
return api.get(`/groups/${createdGroup._id}`).then((group) => {
|
||||
expect(group._id).to.eql(createdGroup._id);
|
||||
expect(group.name).to.eql(createdGroup.name);
|
||||
expect(group.type).to.eql(createdGroup.type);
|
||||
expect(group.privacy).to.eql(createdGroup.privacy);
|
||||
});
|
||||
});
|
||||
|
||||
it('transforms members array to an array of user objects', () => {
|
||||
let api = requester(member);
|
||||
return api.get(`/groups/${createdGroup._id}`).then((group) => {
|
||||
let member = group.members[0];
|
||||
expect(member._id).to.exist;
|
||||
expect(member.profile.name).to.exist;
|
||||
expect(member.contributor).to.exist;
|
||||
expect(member.achievements).to.exist;
|
||||
expect(member.items).to.exist;
|
||||
});
|
||||
});
|
||||
|
||||
it('transforms leader id to leader object', () => {
|
||||
let api = requester(member);
|
||||
return api.get(`/groups/${createdGroup._id}`).then((group) => {
|
||||
expect(group.leader._id).to.eql(leader._id);
|
||||
expect(group.leader.profile.name).to.eql(leader.profile.name);
|
||||
expect(group.leader.items).to.exist;
|
||||
expect(group.leader.stats).to.exist;
|
||||
expect(group.leader.achievements).to.exist;
|
||||
expect(group.leader.contributor).to.exist;
|
||||
});
|
||||
});
|
||||
|
||||
it('includes the user in the members list', () => {
|
||||
let api = requester(member);
|
||||
return api.get(`/groups/${createdGroup._id}`).then((group) => {
|
||||
let members = group.members;
|
||||
let userInGroup = find(members, (user) => {
|
||||
return member._id === user._id;
|
||||
});
|
||||
expect(userInGroup).to.be.ok;
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('flagged messages', () => {
|
||||
let group;
|
||||
|
||||
let chat1 = {
|
||||
id: 'chat1',
|
||||
text: 'chat 1',
|
||||
flags: {},
|
||||
};
|
||||
|
||||
let chat2 = {
|
||||
id: 'chat2',
|
||||
text: 'chat 2',
|
||||
flags: {},
|
||||
flagCount: 0,
|
||||
};
|
||||
|
||||
let chat3 = {
|
||||
id: 'chat3',
|
||||
text: 'chat 3',
|
||||
flags: {
|
||||
'user-id': true,
|
||||
},
|
||||
flagCount: 1,
|
||||
};
|
||||
|
||||
let chat4 = {
|
||||
id: 'chat4',
|
||||
text: 'chat 4',
|
||||
flags: {
|
||||
'user-id': true,
|
||||
'other-user-id': true,
|
||||
},
|
||||
flagCount: 2,
|
||||
};
|
||||
|
||||
let chat5 = {
|
||||
id: 'chat5',
|
||||
text: 'chat 5',
|
||||
flags: {
|
||||
'user-id': true,
|
||||
'other-user-id': true,
|
||||
'yet-another-user-id': true,
|
||||
},
|
||||
flagCount: 3,
|
||||
};
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
chat: [
|
||||
chat1,
|
||||
chat2,
|
||||
chat3,
|
||||
chat4,
|
||||
chat5,
|
||||
],
|
||||
},
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
});
|
||||
});
|
||||
|
||||
context('non-admin', () => {
|
||||
let api;
|
||||
|
||||
beforeEach(() => {
|
||||
return generateUser().then((user) => {
|
||||
api = requester(user);
|
||||
});
|
||||
});
|
||||
|
||||
it('does not include messages with a flag count of 2 or greater', () => {
|
||||
return api.get(`/groups/${group._id}`).then((_group) => {
|
||||
expect(_group.chat).to.have.lengthOf(3);
|
||||
expect(_group.chat[0].id).to.eql(chat1.id);
|
||||
expect(_group.chat[1].id).to.eql(chat2.id);
|
||||
expect(_group.chat[2].id).to.eql(chat3.id);
|
||||
});
|
||||
});
|
||||
|
||||
it('does not include user ids in flags object', () => {
|
||||
return api.get(`/groups/${group._id}`).then((_group) => {
|
||||
let chatWithOneFlag = _group.chat[2];
|
||||
expect(chatWithOneFlag.id).to.eql(chat3.id);
|
||||
expect(chat3.flags).to.eql({ 'user-id': true });
|
||||
expect(chatWithOneFlag.flags).to.eql({});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('admin', () => {
|
||||
let api;
|
||||
|
||||
beforeEach(() => {
|
||||
return generateUser({
|
||||
'contributor.admin': true,
|
||||
}).then((user) => {
|
||||
api = requester(user);
|
||||
});
|
||||
});
|
||||
|
||||
it('includes all messages', () => {
|
||||
return api.get(`/groups/${group._id}`).then((_group) => {
|
||||
expect(_group.chat).to.have.lengthOf(5);
|
||||
expect(_group.chat[0].id).to.eql(chat1.id);
|
||||
expect(_group.chat[1].id).to.eql(chat2.id);
|
||||
expect(_group.chat[2].id).to.eql(chat3.id);
|
||||
expect(_group.chat[3].id).to.eql(chat4.id);
|
||||
expect(_group.chat[4].id).to.eql(chat5.id);
|
||||
});
|
||||
});
|
||||
|
||||
it('includes user ids in flags object', () => {
|
||||
return api.get(`/groups/${group._id}`).then((_group) => {
|
||||
let chatWithOneFlag = _group.chat[2];
|
||||
expect(chatWithOneFlag.id).to.eql(chat3.id);
|
||||
expect(chat3.flags).to.eql({ 'user-id': true });
|
||||
expect(chatWithOneFlag.flags).to.eql(chat3.flags);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('Non-member of a public guild', () => {
|
||||
let leader, nonMember, createdGroup;
|
||||
|
||||
before(() => {
|
||||
return createAndPopulateGroup({
|
||||
members: 1,
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
leader = res.leader;
|
||||
createdGroup = res.group;
|
||||
return generateUser();
|
||||
}).then((user) => {
|
||||
nonMember = user;
|
||||
});
|
||||
});
|
||||
|
||||
it('returns the group object for a non-member', () => {
|
||||
let api = requester(nonMember);
|
||||
return api.get(`/groups/${createdGroup._id}`)
|
||||
.then((group) => {
|
||||
expect(group._id).to.eql(createdGroup._id);
|
||||
expect(group.name).to.eql(createdGroup.name);
|
||||
expect(group.type).to.eql(createdGroup.type);
|
||||
expect(group.privacy).to.eql(createdGroup.privacy);
|
||||
});
|
||||
});
|
||||
|
||||
it('does not include user in members list', () => {
|
||||
let api = requester(nonMember);
|
||||
return api.get(`/groups/${createdGroup._id}`).then((group) => {
|
||||
let userInGroup = find(group.members, (user) => {
|
||||
return nonMember._id === user._id;
|
||||
});
|
||||
expect(userInGroup).to.not.be.ok;
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('Private Guilds', () => {
|
||||
let leader, nonMember, createdGroup;
|
||||
|
||||
before(() => {
|
||||
return createAndPopulateGroup({
|
||||
members: 1,
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
},
|
||||
}).then((res) => {
|
||||
leader = res.leader;
|
||||
createdGroup = res.group;
|
||||
return generateUser();
|
||||
}).then((user) => {
|
||||
nonMember = user;
|
||||
});
|
||||
});
|
||||
|
||||
it('does not return the group object for a non-member', () => {
|
||||
let api = requester(nonMember);
|
||||
return expect(api.get(`/groups/${createdGroup._id}`))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageGroupNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('Non-member of a party', () => {
|
||||
let leader, nonMember, createdGroup;
|
||||
|
||||
before(() => {
|
||||
return createAndPopulateGroup({
|
||||
members: 1,
|
||||
groupDetails: {
|
||||
name: 'test party',
|
||||
type: 'party',
|
||||
privacy: 'private',
|
||||
},
|
||||
}).then((res) => {
|
||||
leader = res.leader;
|
||||
createdGroup = res.group;
|
||||
return generateUser();
|
||||
}).then((user) => {
|
||||
nonMember = user;
|
||||
});
|
||||
});
|
||||
|
||||
it('does not return the group object for a non-member', () => {
|
||||
let api = requester(nonMember);
|
||||
return expect(api.get(`/groups/${createdGroup._id}`))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageGroupNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('Member of a party', () => {
|
||||
let leader, member, createdGroup;
|
||||
|
||||
before(() => {
|
||||
return createAndPopulateGroup({
|
||||
members: 1,
|
||||
groupDetails: {
|
||||
name: 'test party',
|
||||
type: 'party',
|
||||
privacy: 'private',
|
||||
},
|
||||
}).then((res) => {
|
||||
leader = res.leader;
|
||||
createdGroup = res.group;
|
||||
member = res.members[0];
|
||||
});
|
||||
});
|
||||
|
||||
it('returns the user\'s party if an id of "party" is passed in', () => {
|
||||
let api = requester(member);
|
||||
return api.get('/groups/party')
|
||||
.then((group) => {
|
||||
expect(group._id).to.eql(createdGroup._id);
|
||||
expect(group.name).to.eql(createdGroup.name);
|
||||
expect(group.type).to.eql(createdGroup.type);
|
||||
expect(group.privacy).to.eql(createdGroup.privacy);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('Non-existent group', () => {
|
||||
let user;
|
||||
|
||||
beforeEach(() => {
|
||||
return generateUser().then((_user) => {
|
||||
user = _user;
|
||||
});
|
||||
});
|
||||
|
||||
it('returns error if group does not exist', () => {
|
||||
let api = requester(user);
|
||||
return expect(api.get('/groups/group-that-does-not-exist'))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageGroupNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,151 @@
|
||||
import {
|
||||
generateGroup,
|
||||
generateUser,
|
||||
requester,
|
||||
translate as t,
|
||||
} from '../../../helpers/api-integration.helper';
|
||||
|
||||
describe('POST /groups', () => {
|
||||
|
||||
context('All groups', () => {
|
||||
let api, leader;
|
||||
|
||||
beforeEach(() => {
|
||||
return generateUser().then((user) => {
|
||||
leader = user;
|
||||
api = requester(user);
|
||||
});
|
||||
});
|
||||
|
||||
xit('returns defaults? (TODO: it\'s possible to create a group without a type. Should the group default to party? Should we require type to be set?', () => {
|
||||
return api.post('/groups').then((group) => {
|
||||
expect(group._id).to.exist;
|
||||
expect(group.name).to.eql(`${leader.profile.name}'s group`);
|
||||
expect(group.type).to.eql('party');
|
||||
expect(group.privacy).to.eql('private');
|
||||
});
|
||||
});
|
||||
|
||||
it('returns a group object', () => {
|
||||
let group = {
|
||||
name: 'Test Group',
|
||||
type: 'party',
|
||||
leaderOnly: { challenges: true },
|
||||
description: 'Test Group Description',
|
||||
leaderMessage: 'Test Group Message',
|
||||
};
|
||||
|
||||
return api.post('/groups', group).then((createdGroup) => {
|
||||
expect(createdGroup._id).to.exist;
|
||||
expect(createdGroup.leader).to.eql(leader._id);
|
||||
expect(createdGroup.name).to.eql(group.name);
|
||||
expect(createdGroup.description).to.eql(group.description);
|
||||
expect(createdGroup.leaderMessage).to.eql(group.leaderMessage);
|
||||
expect(createdGroup.leaderOnly).to.eql(group.leaderOnly);
|
||||
expect(createdGroup.memberCount).to.eql(1);
|
||||
});
|
||||
});
|
||||
|
||||
it('returns a populated members array', () => {
|
||||
return api.post('/groups', {
|
||||
type: 'party',
|
||||
}).then((party) => {
|
||||
let member = party.members[0];
|
||||
expect(member._id).to.eql(leader._id);
|
||||
expect(member.profile).to.eql(leader.profile);
|
||||
expect(member.contributor).to.eql(leader.contributor);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('Parties', () => {
|
||||
let api, leader;
|
||||
|
||||
beforeEach(() => {
|
||||
return generateUser().then((user) => {
|
||||
leader = user;
|
||||
api = requester(user);
|
||||
});
|
||||
});
|
||||
|
||||
it('allows party creation without gems', () => {
|
||||
return expect(api.post('/groups', {
|
||||
type: 'party',
|
||||
})).to.eventually.have.property('_id');
|
||||
});
|
||||
|
||||
it('prevents party creation if user is already in party', () => {
|
||||
return expect(generateGroup(leader, {
|
||||
type: 'party',
|
||||
}).then((group) => {
|
||||
return api.post('/groups', {
|
||||
type: 'party',
|
||||
});
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 400,
|
||||
text: t('messageGroupAlreadyInParty'),
|
||||
});
|
||||
});
|
||||
|
||||
xit('prevents creating a public party. TODO: it is possible to create a public party. Should we send back an error? Automatically switch the privacy to private?', () => {
|
||||
return expect(api.post('/groups', {
|
||||
type: 'party',
|
||||
privacy: 'public',
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 400,
|
||||
text: 'Parties must be private',
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('Guilds', () => {
|
||||
let api, leader;
|
||||
|
||||
beforeEach(() => {
|
||||
return generateUser({
|
||||
balance: 2,
|
||||
}).then((user) => {
|
||||
leader = user;
|
||||
api = requester(user);
|
||||
});
|
||||
});
|
||||
|
||||
it('prevents guild creation when user does not have enough gems', () => {
|
||||
return expect(generateUser({
|
||||
balance: 0.75,
|
||||
}).then((user) => {
|
||||
api = requester(user);
|
||||
return api.post('/groups', {
|
||||
type: 'guild',
|
||||
});
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageInsufficientGems'),
|
||||
});
|
||||
});
|
||||
|
||||
it('can create a public guild', () => {
|
||||
return expect(api.post('/groups', {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
})).to.eventually.have.property('leader', leader._id);
|
||||
});
|
||||
|
||||
it('can create a private guild', () => {
|
||||
return expect(api.post('/groups', {
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
})).to.eventually.have.property('leader', leader._id);
|
||||
});
|
||||
|
||||
it('deducts gems from user and adds them to guild bank', () => {
|
||||
return expect(api.post('/groups', {
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
}).then((group) => {
|
||||
expect(group.balance).to.eql(1);
|
||||
return api.get('/user');
|
||||
})).to.eventually.have.deep.property('balance', 1);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,75 @@
|
||||
import {
|
||||
generateGroup,
|
||||
generateUser,
|
||||
requester,
|
||||
translate as t,
|
||||
} from '../../../helpers/api-integration.helper';
|
||||
|
||||
describe('POST /groups/:id', () => {
|
||||
|
||||
context('user is not the leader of the group', () => {
|
||||
let api, user, otherUser, groupUserDoesNotOwn;
|
||||
|
||||
beforeEach(() => {
|
||||
return Promise.all([
|
||||
generateUser({ balance: 10 }),
|
||||
generateUser({ balance: 10 }),
|
||||
]).then((users) => {
|
||||
user = users[0];
|
||||
otherUser = users[1];
|
||||
api = requester(user);
|
||||
|
||||
return generateGroup(otherUser, {
|
||||
name: 'Group not Owned By User',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
members: [user, otherUser],
|
||||
});
|
||||
}).then((group) => {
|
||||
groupUserDoesNotOwn = group;
|
||||
});
|
||||
});
|
||||
|
||||
it('does not allow user to update group', () => {
|
||||
return expect(api.post(`/groups/${groupUserDoesNotOwn._id}`, {
|
||||
name: 'Change'
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageGroupOnlyLeaderCanUpdate'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('user is the leader of the group', () => {
|
||||
let api, user, usersGroup;
|
||||
|
||||
beforeEach(() => {
|
||||
return generateUser({
|
||||
balance: 10,
|
||||
}).then((_user) => {
|
||||
user = _user;
|
||||
api = requester(user);
|
||||
|
||||
return generateGroup(user, {
|
||||
name: 'Original Group Title',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
});
|
||||
}).then((group) => {
|
||||
usersGroup = group;
|
||||
});
|
||||
});
|
||||
|
||||
it('allows user to update group', () => {
|
||||
return api.post(`/groups/${usersGroup._id}`, {
|
||||
name: 'New Group Title',
|
||||
description: 'New group description',
|
||||
}).then((group) => {
|
||||
return api.get(`/groups/${usersGroup._id}`);
|
||||
}).then((group) => {
|
||||
expect(group.name).to.eql('New Group Title');
|
||||
expect(group.description).to.eql('New group description');
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,144 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateUser,
|
||||
requester,
|
||||
translate as t,
|
||||
} from '../../../helpers/api-integration.helper';
|
||||
import { each, find } from 'lodash';
|
||||
|
||||
describe('POST /groups/:id/join', () => {
|
||||
|
||||
context('user is already a member of the group', () => {
|
||||
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: t('messageGroupRequiresInvite'),
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
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;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
return requester(res.leader).post(`/groups/${group._id}/leave`);
|
||||
}).then((res) => {
|
||||
return generateUser();
|
||||
}).then((generatedUser) => {
|
||||
user = generatedUser;
|
||||
});
|
||||
});
|
||||
|
||||
it('makes the joining user the leader', () => {
|
||||
let api = requester(user);
|
||||
return expect(api.post(`/groups/${group._id}/join`).then((result) => {
|
||||
return api.get(`/groups/${group._id}`);
|
||||
})).to.eventually.have.deep.property('leader._id', user._id);
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,161 @@
|
||||
import {
|
||||
checkExistence,
|
||||
createAndPopulateGroup,
|
||||
generateUser,
|
||||
requester,
|
||||
translate as t,
|
||||
} from '../../../helpers/api-integration.helper';
|
||||
import { find } from 'lodash';
|
||||
|
||||
describe('POST /groups/:id/leave', () => {
|
||||
|
||||
context('user is not member of the group', () => {
|
||||
it('returns an error');
|
||||
});
|
||||
|
||||
context('user is a non-leader member of a guild', () => {
|
||||
let api, user, group;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
members: 3,
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
user = res.members[0];
|
||||
api = requester(user);
|
||||
group = res.group;
|
||||
});
|
||||
});
|
||||
|
||||
it('leaves the group', () => {
|
||||
return api.post(`/groups/${group._id}/leave`).then((result) => {
|
||||
return api.get(`/groups/${group._id}`);
|
||||
}).then((group) => {
|
||||
let userInGroup = find(group.members, (member) => {
|
||||
return member._id === user._id;
|
||||
});
|
||||
expect(userInGroup).to.not.be.ok;
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('user is the last member of a public guild', () => {
|
||||
let api, user, group;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
user = res.leader;
|
||||
api = requester(user);
|
||||
group = res.group;
|
||||
});
|
||||
});
|
||||
|
||||
it('leaves the group accessible', () => {
|
||||
return expect(api.post(`/groups/${group._id}/leave`).then((result) => {
|
||||
return api.get(`/groups/${group._id}`);
|
||||
})).to.eventually.have.property('_id', group._id);
|
||||
});
|
||||
});
|
||||
|
||||
context('user is the last member of a private group', () => {
|
||||
let api, user, group;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
},
|
||||
}).then((res) => {
|
||||
user = res.leader;
|
||||
api = requester(user);
|
||||
group = res.group;
|
||||
});
|
||||
});
|
||||
|
||||
it('group is deleted', () => {
|
||||
return expect(api.post(`/groups/${group._id}/leave`).then((result) => {
|
||||
return checkExistence('groups', group._id);
|
||||
})).to.eventually.eql(false);
|
||||
});
|
||||
});
|
||||
|
||||
context('user is the last member of a private group with pending invites', () => {
|
||||
let api, user, inviteeRequest1, inviteeRequest2, group;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
invites: 2,
|
||||
groupDetails: {
|
||||
name: 'test guild',
|
||||
type: 'guild',
|
||||
privacy: 'private',
|
||||
},
|
||||
}).then((res) => {
|
||||
user = res.leader;
|
||||
inviteeRequest1 = requester(res.invitees[0]);
|
||||
inviteeRequest2 = requester(res.invitees[1]);
|
||||
api = requester(user);
|
||||
group = res.group;
|
||||
});
|
||||
});
|
||||
|
||||
it('deletes the group invitations from users', () => {
|
||||
return api.post(`/groups/${group._id}/leave`).then((result) => {
|
||||
return Promise.all([
|
||||
expect(inviteeRequest1.get(`/user`))
|
||||
.to.eventually.have.deep.property('invitations.guilds')
|
||||
.and.to.be.empty,
|
||||
expect(inviteeRequest2.get(`/user`))
|
||||
.to.eventually.have.deep.property('invitations.guilds')
|
||||
.and.to.be.empty,
|
||||
]);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('user is the last member of a party with pending invites', () => {
|
||||
let api, user, inviteeRequest1, inviteeRequest2, group;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
invites: 2,
|
||||
groupDetails: {
|
||||
name: 'test party',
|
||||
type: 'party',
|
||||
privacy: 'private',
|
||||
},
|
||||
}).then((res) => {
|
||||
user = res.leader;
|
||||
inviteeRequest1 = requester(res.invitees[0]);
|
||||
inviteeRequest2 = requester(res.invitees[1]);
|
||||
api = requester(user);
|
||||
group = res.group;
|
||||
});
|
||||
});
|
||||
|
||||
it('deletes the group invitations from users', () => {
|
||||
return api.post(`/groups/${group._id}/leave`).then((result) => {
|
||||
return Promise.all([
|
||||
expect(inviteeRequest1.get(`/user`))
|
||||
.to.eventually.have.deep.property('invitations.party')
|
||||
.and.to.be.empty,
|
||||
expect(inviteeRequest2.get(`/user`))
|
||||
.to.eventually.have.deep.property('invitations.party')
|
||||
.and.to.be.empty,
|
||||
]);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,59 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateGroup,
|
||||
generateUser,
|
||||
requester,
|
||||
translate as t,
|
||||
} from '../../../helpers/api-integration.helper';
|
||||
|
||||
describe('POST /groups/:id/removeMember', () => {
|
||||
|
||||
context('user is not member of the group', () => {
|
||||
it('returns an error');
|
||||
});
|
||||
|
||||
context('user is a non-leader member of a guild', () => {
|
||||
it('returns an error');
|
||||
});
|
||||
|
||||
context('user is the leader of a guild', () => {
|
||||
let api, leader, member, group;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
members: 1,
|
||||
groupDetails: {
|
||||
name: 'test group',
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
leader = res.leader;
|
||||
member = res.members[0];
|
||||
group = res.group;
|
||||
|
||||
api = requester(leader);
|
||||
});
|
||||
});
|
||||
|
||||
it('does not allow leader to remove themselves', () => {
|
||||
return expect(api.post(`/groups/${group._id}/removeMember`, null, {
|
||||
uuid: leader._id,
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageGroupCannotRemoveSelf'),
|
||||
});
|
||||
});
|
||||
|
||||
it('can remove other members of guild', () => {
|
||||
return api.post(`/groups/${group._id}/removeMember`, null, {
|
||||
uuid: member._id,
|
||||
}).then((res) => {
|
||||
return api.get(`/groups/${group._id}`);
|
||||
}).then((guild) => {
|
||||
expect(guild.members).to.have.a.lengthOf(1);
|
||||
expect(guild.members[0]._id).to.not.eql(member._id);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,42 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateUser,
|
||||
requester,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-integration.helper';
|
||||
|
||||
describe('DELETE /groups/:id/chat', () => {
|
||||
let api, group, message, user;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.leader;
|
||||
api = requester(user);
|
||||
|
||||
return api.post(`/groups/${group._id}/chat`, null, { message: 'Some message', });
|
||||
}).then((res) => {
|
||||
message = res.message;
|
||||
});
|
||||
});
|
||||
|
||||
it('deletes a message', () => {
|
||||
return api.del(`/groups/${group._id}/chat/${message.id}`).then((res) => {
|
||||
return api.get(`/groups/${group._id}/chat/`);
|
||||
}).then((messages) => {
|
||||
expect(messages).to.have.length(0);
|
||||
});
|
||||
});
|
||||
|
||||
it('returns an error is message does not exist', () => {
|
||||
return expect(api.del(`/groups/${group._id}/chat/some-fake-id`)).to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageGroupChatNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,48 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateUser,
|
||||
requester,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-integration.helper';
|
||||
|
||||
describe('GET /groups/:id/chat', () => {
|
||||
|
||||
context('group with multiple messages', () => {
|
||||
let group, member, message1, message2, user;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
members: 1,
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.leader;
|
||||
member = res.members[0];
|
||||
|
||||
return requester(member).post(`/groups/${group._id}/chat`, null, { message: 'Group member message' });
|
||||
}).then((res) => {
|
||||
message1 = res.message;
|
||||
|
||||
return requester(user).post(`/groups/${group._id}/chat`, null, { message: 'User message' });
|
||||
}).then((res) => {
|
||||
message2 = res.message;
|
||||
});
|
||||
});
|
||||
|
||||
it('gets messages', () => {
|
||||
let api = requester(user);
|
||||
|
||||
return api.get(`/groups/${group._id}/chat`).then((messages) => {
|
||||
expect(messages).to.have.length(2);
|
||||
|
||||
let message = messages[0];
|
||||
expect(message.id).to.exist;
|
||||
expect(message.text).to.exist;
|
||||
expect(message.uuid).to.exist;
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,46 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateUser,
|
||||
requester,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-integration.helper';
|
||||
|
||||
describe('POST /groups/:id/chat', () => {
|
||||
|
||||
let api, group, user;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.leader;
|
||||
api = requester(user);
|
||||
});
|
||||
});
|
||||
|
||||
it('creates a chat message', () => {
|
||||
return api.post(`/groups/${group._id}/chat`, null, {
|
||||
message: 'Test Message',
|
||||
}).then((res) => {
|
||||
let message = res.message;
|
||||
|
||||
expect(message.id).to.exist;
|
||||
expect(message.timestamp).to.exist;
|
||||
expect(message.text).to.eql('Test Message');
|
||||
expect(message.uuid).to.eql(user._id);
|
||||
});
|
||||
});
|
||||
|
||||
it('does not post an empty message', () => {
|
||||
return expect(api.post(`/groups/${group._id}/chat`, null, {
|
||||
message: '',
|
||||
})).to.eventually.be.rejected.and.eql({
|
||||
code: 400,
|
||||
text: t('messageGroupChatBlankMessage'),
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,102 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateUser,
|
||||
requester,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-integration.helper';
|
||||
|
||||
describe('POST /groups/:id/chat/:id/flag', () => {
|
||||
|
||||
context('another member\'s message', () => {
|
||||
let group, member, message, user;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
members: 1,
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.leader;
|
||||
member = res.members[0];
|
||||
|
||||
return requester(member)
|
||||
.post(`/groups/${group._id}/chat`, null, { message: 'Group member message', });
|
||||
}).then((res) => {
|
||||
message = res.message;
|
||||
});
|
||||
});
|
||||
|
||||
it('flags message', () => {
|
||||
let api = requester(user);
|
||||
|
||||
return api.post(`/groups/${group._id}/chat/${message.id}/flag`).then((messages) => {
|
||||
return api.get(`/groups/${group._id}/chat`);
|
||||
}).then((messages) => {
|
||||
let message = messages[0];
|
||||
expect(message.flagCount).to.eql(1);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('own message', () => {
|
||||
let api, group, message, user;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
members: 1,
|
||||
},
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.leader;
|
||||
api = requester(user);
|
||||
|
||||
return api.post(`/groups/${group._id}/chat`, null, { message: 'User\'s own message', });
|
||||
}).then((res) => {
|
||||
message = res.message;
|
||||
});
|
||||
});
|
||||
|
||||
it('cannot flag message', () => {
|
||||
let api = requester(user);
|
||||
|
||||
return expect(api.post(`/groups/${group._id}/chat/${message.id}/flag`))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageGroupChatFlagOwnMessage'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('nonexistant message', () => {
|
||||
let api, group, message, user;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.leader;
|
||||
api = requester(user);
|
||||
});
|
||||
});
|
||||
|
||||
it('returns error', () => {
|
||||
let api = requester(user);
|
||||
|
||||
return expect(api.post(`/groups/${group._id}/chat/non-existant-message/flag`))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageGroupChatNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
@@ -0,0 +1,111 @@
|
||||
import {
|
||||
createAndPopulateGroup,
|
||||
generateUser,
|
||||
requester,
|
||||
translate as t,
|
||||
} from '../../../../helpers/api-integration.helper';
|
||||
|
||||
describe('POST /groups/:id/chat/:id/like', () => {
|
||||
|
||||
context('another member\'s message', () => {
|
||||
let group, member, message, user;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
members: 1,
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.leader;
|
||||
member = res.members[0];
|
||||
|
||||
return requester(member)
|
||||
.post(`/groups/${group._id}/chat`, null, { message: 'Group member message', });
|
||||
}).then((res) => {
|
||||
message = res.message;
|
||||
});
|
||||
});
|
||||
|
||||
it('likes message', () => {
|
||||
let api = requester(user);
|
||||
|
||||
return api.post(`/groups/${group._id}/chat/${message.id}/like`).then((messages) => {
|
||||
let message = messages[0];
|
||||
expect(message.likes[user._id]).to.eql(true);
|
||||
});
|
||||
});
|
||||
|
||||
it('returns the message object', () => {
|
||||
let api = requester(user);
|
||||
|
||||
return api.post(`/groups/${group._id}/chat/${message.id}/like`).then((messages) => {
|
||||
let message = messages[0];
|
||||
expect(message.text).to.eql('Group member message');
|
||||
expect(message.uuid).to.eql(member._id);
|
||||
expect(message.user).to.eql(member.profile.name);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('own message', () => {
|
||||
let api, group, message, user;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
members: 1,
|
||||
},
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.leader;
|
||||
api = requester(user);
|
||||
|
||||
return api.post(`/groups/${group._id}/chat`, null, { message: 'User\'s own message', });
|
||||
}).then((res) => {
|
||||
message = res.message;
|
||||
});
|
||||
});
|
||||
|
||||
it('cannot like message', () => {
|
||||
let api = requester(user);
|
||||
|
||||
return expect(api.post(`/groups/${group._id}/chat/${message.id}/like`))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 401,
|
||||
text: t('messageGroupChatLikeOwnMessage'),
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
context('nonexistant message', () => {
|
||||
let api, group, message, user;
|
||||
|
||||
beforeEach(() => {
|
||||
return createAndPopulateGroup({
|
||||
groupDetails: {
|
||||
type: 'guild',
|
||||
privacy: 'public',
|
||||
},
|
||||
}).then((res) => {
|
||||
group = res.group;
|
||||
user = res.leader;
|
||||
api = requester(user);
|
||||
});
|
||||
});
|
||||
|
||||
it('returns error', () => {
|
||||
let api = requester(user);
|
||||
|
||||
return expect(api.post(`/groups/${group._id}/chat/non-existant-message/like`))
|
||||
.to.eventually.be.rejected.and.eql({
|
||||
code: 404,
|
||||
text: t('messageGroupChatNotFound'),
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user