krikkert/habitica
1
0
Fork 0
mirror of https://github.com/HabitRPG/habitica.git synced 2025-12-16 06:07:21 +01:00
Code Issues Packages Projects Releases Wiki Activity

fix test lint

Browse Source
This commit is contained in:
Matteo Pagliazzi
2019-10-08 20:45:38 +02:00
parent e37f4467f8
commit 85fb5f33aa
367 changed files with 6635 additions and 6080 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
test/api/v3/integration/chat/DELETE-chat_id.test.js
View File

@@ -1,15 +1,16 @@
import { v4 as generateUUID } from 'uuid';
import {
createAndPopulateGroup,
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { v4 as generateUUID } from 'uuid';
describe('DELETE /groups/:groupId/chat/:chatId', () => {
let groupWithChat, message, user, userThatDidNotCreateChat, admin;
let groupWithChat; let message; let user; let userThatDidNotCreateChat; let
admin;
before(async () => {
let { group, groupLeader } = await createAndPopulateGroup({
const { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
type: 'guild',
privacy: 'public',
@@ -21,12 +22,12 @@ describe('DELETE /groups/:groupId/chat/:chatId', () => {
message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message' });
message = message.message;
userThatDidNotCreateChat = await generateUser();
admin = await generateUser({'contributor.admin': true});
admin = await generateUser({ 'contributor.admin': true });
});
context('Chat errors', () => {
it('returns an error is message does not exist', async () => {
let fakeChatId = generateUUID();
const fakeChatId = generateUUID();
await expect(user.del(`/groups/${groupWithChat._id}/chat/${fakeChatId}`)).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
@@ -55,9 +56,9 @@ describe('DELETE /groups/:groupId/chat/:chatId', () => {
await user.del(`/groups/${groupWithChat._id}/chat/${nextMessage.id}`);
const returnedMessages = await user.get(`/groups/${groupWithChat._id}/chat/`);
const messageFromUser = returnedMessages.find(returnedMessage => {
return returnedMessage.id === nextMessage.id;
});
const messageFromUser = returnedMessages.find(
returnedMessage => returnedMessage.id === nextMessage.id,
);
expect(returnedMessages).is.an('array');
expect(messageFromUser).to.not.exist;
@@ -67,9 +68,9 @@ describe('DELETE /groups/:groupId/chat/:chatId', () => {
await admin.del(`/groups/${groupWithChat._id}/chat/${nextMessage.id}`);
const returnedMessages = await user.get(`/groups/${groupWithChat._id}/chat/`);
const messageFromUser = returnedMessages.find(returnedMessage => {
return returnedMessage.id === nextMessage.id;
});
const messageFromUser = returnedMessages.find(
returnedMessage => returnedMessage.id === nextMessage.id,
);
expect(returnedMessages).is.an('array');
expect(messageFromUser).to.not.exist;

8
test/api/v3/integration/chat/GET-chat.test.js
View File

@@ -15,7 +15,7 @@ describe('GET /groups/:groupId/chat', () => {
let group;
before(async () => {
let leader = await generateUser({balance: 2});
const leader = await generateUser({ balance: 2 });
group = await generateGroup(leader, {
name: 'test group',
@@ -23,8 +23,8 @@ describe('GET /groups/:groupId/chat', () => {
privacy: 'public',
}, {
chat: [
{text: 'Hello', flags: {}, id: 1},
{text: 'Welcome to the Guild', flags: {}, id: 2},
{ text: 'Hello', flags: {}, id: 1 },
{ text: 'Welcome to the Guild', flags: {}, id: 2 },
],
});
});
@@ -41,7 +41,7 @@ describe('GET /groups/:groupId/chat', () => {
let group;
before(async () => {
let leader = await generateUser({balance: 2});
const leader = await generateUser({ balance: 2 });
group = await generateGroup(leader, {
name: 'test group',

83
test/api/v3/integration/chat/POST-chat.flag.test.js
View File

@@ -1,24 +1,25 @@
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { find } from 'lodash';
import moment from 'moment';
import nconf from 'nconf';
import { IncomingWebhook } from '@slack/client';
import {
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
const BASE_URL = nconf.get('BASE_URL');
describe('POST /chat/:chatId/flag', () => {
let user, admin, anotherUser, newUser, group;
let user; let admin; let anotherUser; let newUser; let
group;
const TEST_MESSAGE = 'Test Message';
const USER_AGE_FOR_FLAGGING = 3;
beforeEach(async () => {
user = await generateUser({balance: 1, 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate()});
admin = await generateUser({balance: 1, 'contributor.admin': true});
anotherUser = await generateUser({'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate()});
newUser = await generateUser({'auth.timestamps.created': moment().subtract(1, 'days').toDate()});
user = await generateUser({ balance: 1, 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate() });
admin = await generateUser({ balance: 1, 'contributor.admin': true });
anotherUser = await generateUser({ 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate() });
newUser = await generateUser({ 'auth.timestamps.created': moment().subtract(1, 'days').toDate() });
sandbox.stub(IncomingWebhook.prototype, 'send');
group = await user.post('/groups', {
@@ -42,20 +43,20 @@ describe('POST /chat/:chatId/flag', () => {
});
it('Allows players to flag their own message', async () => {
let message = await user.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
const message = await user.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
await expect(user.post(`/groups/${group._id}/chat/${message.message.id}/flag`)).to.eventually.be.ok;
});
it('Flags a chat and sends normal message to moderator Slack when user is not new', async () => {
let { message } = await anotherUser.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
const { message } = await anotherUser.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
let flagResult = await user.post(`/groups/${group._id}/chat/${message.id}/flag`);
const flagResult = await user.post(`/groups/${group._id}/chat/${message.id}/flag`);
expect(flagResult.flags[user._id]).to.equal(true);
expect(flagResult.flagCount).to.equal(1);
let groupWithFlags = await admin.get(`/groups/${group._id}`);
const groupWithFlags = await admin.get(`/groups/${group._id}`);
let messageToCheck = find(groupWithFlags.chat, {id: message.id});
const messageToCheck = find(groupWithFlags.chat, { id: message.id });
expect(messageToCheck.flags[user._id]).to.equal(true);
// Slack message to mods
@@ -81,16 +82,16 @@ describe('POST /chat/:chatId/flag', () => {
});
it('Does not increment message flag count and sends different message to moderator Slack when user is new', async () => {
let automatedComment = `The post's flag count has not been increased because the flagger's account is less than ${USER_AGE_FOR_FLAGGING} days old.`;
let { message } = await newUser.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
const automatedComment = `The post's flag count has not been increased because the flagger's account is less than ${USER_AGE_FOR_FLAGGING} days old.`;
const { message } = await newUser.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
let flagResult = await newUser.post(`/groups/${group._id}/chat/${message.id}/flag`);
const flagResult = await newUser.post(`/groups/${group._id}/chat/${message.id}/flag`);
expect(flagResult.flags[newUser._id]).to.equal(true);
expect(flagResult.flagCount).to.equal(0);
let groupWithFlags = await admin.get(`/groups/${group._id}`);
const groupWithFlags = await admin.get(`/groups/${group._id}`);
let messageToCheck = find(groupWithFlags.chat, {id: message.id});
const messageToCheck = find(groupWithFlags.chat, { id: message.id });
expect(messageToCheck.flags[newUser._id]).to.equal(true);
// Slack message to mods
@@ -116,38 +117,38 @@ describe('POST /chat/:chatId/flag', () => {
});
it('Flags a chat when the author\'s account was deleted', async () => {
let deletedUser = await generateUser();
let { message } = await deletedUser.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
const deletedUser = await generateUser();
const { message } = await deletedUser.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
await deletedUser.del('/user', {
password: 'password',
});
let flagResult = await user.post(`/groups/${group._id}/chat/${message.id}/flag`);
const flagResult = await user.post(`/groups/${group._id}/chat/${message.id}/flag`);
expect(flagResult.flags[user._id]).to.equal(true);
expect(flagResult.flagCount).to.equal(1);
let groupWithFlags = await admin.get(`/groups/${group._id}`);
const groupWithFlags = await admin.get(`/groups/${group._id}`);
let messageToCheck = find(groupWithFlags.chat, {id: message.id});
const messageToCheck = find(groupWithFlags.chat, { id: message.id });
expect(messageToCheck.flags[user._id]).to.equal(true);
});
it('Flags a chat with a higher flag acount when an admin flags the message', async () => {
let { message } = await user.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
const { message } = await user.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
let flagResult = await admin.post(`/groups/${group._id}/chat/${message.id}/flag`);
const flagResult = await admin.post(`/groups/${group._id}/chat/${message.id}/flag`);
expect(flagResult.flags[admin._id]).to.equal(true);
expect(flagResult.flagCount).to.equal(5);
let groupWithFlags = await admin.get(`/groups/${group._id}`);
const groupWithFlags = await admin.get(`/groups/${group._id}`);
let messageToCheck = find(groupWithFlags.chat, {id: message.id});
const messageToCheck = find(groupWithFlags.chat, { id: message.id });
expect(messageToCheck.flags[admin._id]).to.equal(true);
expect(messageToCheck.flagCount).to.equal(5);
});
it('allows admin to flag a message in a private group', async () => {
let privateGroup = await user.post('/groups', {
const privateGroup = await user.post('/groups', {
name: 'Test party',
type: 'party',
privacy: 'private',
@@ -156,26 +157,26 @@ describe('POST /chat/:chatId/flag', () => {
uuids: [anotherUser._id],
});
await anotherUser.post(`/groups/${privateGroup._id}/join`);
let { message } = await user.post(`/groups/${privateGroup._id}/chat`, {message: TEST_MESSAGE});
const { message } = await user.post(`/groups/${privateGroup._id}/chat`, { message: TEST_MESSAGE });
let flagResult = await admin.post(`/groups/${privateGroup._id}/chat/${message.id}/flag`);
const flagResult = await admin.post(`/groups/${privateGroup._id}/chat/${message.id}/flag`);
expect(flagResult.flags[admin._id]).to.equal(true);
expect(flagResult.flagCount).to.equal(5);
let groupWithFlags = await anotherUser.get(`/groups/${privateGroup._id}`);
let messageToCheck = find(groupWithFlags.chat, {id: message.id});
const groupWithFlags = await anotherUser.get(`/groups/${privateGroup._id}`);
const messageToCheck = find(groupWithFlags.chat, { id: message.id });
expect(messageToCheck).to.not.exist;
});
it('does not allow non member to flag message in private group', async () => {
let privateGroup = await user.post('/groups', {
const privateGroup = await user.post('/groups', {
name: 'Test party',
type: 'party',
privacy: 'private',
});
let { message } = await user.post(`/groups/${privateGroup._id}/chat`, {message: TEST_MESSAGE});
const { message } = await user.post(`/groups/${privateGroup._id}/chat`, { message: TEST_MESSAGE });
await expect(anotherUser.post(`/groups/${privateGroup._id}/chat/${message.id}/flag`))
.to.eventually.be.rejected.and.eql({
@@ -186,7 +187,7 @@ describe('POST /chat/:chatId/flag', () => {
});
it('Returns an error when user tries to flag a message that they already flagged', async () => {
let { message } = await anotherUser.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
const { message } = await anotherUser.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
await user.post(`/groups/${group._id}/chat/${message.id}/flag`);
@@ -199,17 +200,17 @@ describe('POST /chat/:chatId/flag', () => {
});
it('shows a hidden message to the original poster', async () => {
let { message } = await user.post(`/groups/${group._id}/chat`, {message: TEST_MESSAGE});
const { message } = await user.post(`/groups/${group._id}/chat`, { message: TEST_MESSAGE });
await admin.post(`/groups/${group._id}/chat/${message.id}/flag`);
let groupWithFlags = await user.get(`/groups/${group._id}`);
let messageToCheck = find(groupWithFlags.chat, {id: message.id});
const groupWithFlags = await user.get(`/groups/${group._id}`);
const messageToCheck = find(groupWithFlags.chat, { id: message.id });
expect(messageToCheck).to.exist;
let auGroupWithFlags = await anotherUser.get(`/groups/${group._id}`);
let auMessageToCheck = find(auGroupWithFlags.chat, {id: message.id});
const auGroupWithFlags = await anotherUser.get(`/groups/${group._id}`);
const auMessageToCheck = find(auGroupWithFlags.chat, { id: message.id });
expect(auMessageToCheck).to.not.exist;
});

28
test/api/v3/integration/chat/POST-chat.like.test.js
View File

@@ -1,17 +1,17 @@
import { find } from 'lodash';
import {
createAndPopulateGroup,
translate as t,
} from '../../../../helpers/api-integration/v3';
import { find } from 'lodash';
describe('POST /chat/:chatId/like', () => {
let user;
let groupWithChat;
let testMessage = 'Test Message';
const testMessage = 'Test Message';
let anotherUser;
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
@@ -22,7 +22,7 @@ describe('POST /chat/:chatId/like', () => {
user = groupLeader;
groupWithChat = group;
anotherUser = members[0];
anotherUser = members[0]; // eslint-disable-line prefer-destructuring
});
it('Returns an error when chat message is not found', async () => {
@@ -35,7 +35,7 @@ describe('POST /chat/:chatId/like', () => {
});
it('Returns an error when user tries to like their own message', async () => {
let message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
await expect(user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`))
.to.eventually.be.rejected.and.eql({
@@ -46,30 +46,30 @@ describe('POST /chat/:chatId/like', () => {
});
it('Likes a chat', async () => {
let message = await anotherUser.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const message = await anotherUser.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
let likeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
const likeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
expect(likeResult.likes[user._id]).to.equal(true);
let groupWithChatLikes = await user.get(`/groups/${groupWithChat._id}`);
const groupWithChatLikes = await user.get(`/groups/${groupWithChat._id}`);
let messageToCheck = find(groupWithChatLikes.chat, {id: message.message.id});
const messageToCheck = find(groupWithChatLikes.chat, { id: message.message.id });
expect(messageToCheck.likes[user._id]).to.equal(true);
});
it('Unlikes a chat', async () => {
let message = await anotherUser.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const message = await anotherUser.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
let likeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
const likeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
expect(likeResult.likes[user._id]).to.equal(true);
let unlikeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
const unlikeResult = await user.post(`/groups/${groupWithChat._id}/chat/${message.message.id}/like`);
expect(unlikeResult.likes[user._id]).to.equal(false);
let groupWithoutChatLikes = await user.get(`/groups/${groupWithChat._id}`);
const groupWithoutChatLikes = await user.get(`/groups/${groupWithChat._id}`);
let messageToCheck = find(groupWithoutChatLikes.chat, {id: message.message.id});
const messageToCheck = find(groupWithoutChatLikes.chat, { id: message.message.id });
expect(messageToCheck.likes[user._id]).to.equal(false);
});
});

199
test/api/v3/integration/chat/POST-chat.test.js
View File

@@ -1,5 +1,6 @@
import { IncomingWebhook } from '@slack/client';
import nconf from 'nconf';
import { v4 as generateUUID } from 'uuid';
import {
createAndPopulateGroup,
generateUser,
@@ -13,7 +14,6 @@ import {
TAVERN_ID,
} from '../../../../../website/server/models/group';
import { CHAT_FLAG_FROM_SHADOW_MUTE } from '../../../../../website/common/script/constants';
import { v4 as generateUUID } from 'uuid';
import { getMatchesByWordArray } from '../../../../../website/server/libs/stringUtils';
import bannedWords from '../../../../../website/server/libs/bannedWords';
import guildsAllowingBannedWords from '../../../../../website/server/libs/guildsAllowingBannedWords';
@@ -22,16 +22,17 @@ import * as email from '../../../../../website/server/libs/email';
const BASE_URL = nconf.get('BASE_URL');
describe('POST /chat', () => {
let user, groupWithChat, member, additionalMember;
let testMessage = 'Test Message';
let testBannedWordMessage = 'TESTPLACEHOLDERSWEARWORDHERE';
let testBannedWordMessage1 = 'TESTPLACEHOLDERSWEARWORDHERE1';
let testSlurMessage = 'message with TESTPLACEHOLDERSLURWORDHERE';
let testSlurMessage1 = 'TESTPLACEHOLDERSLURWORDHERE1';
let bannedWordErrorMessage = t('bannedWordUsed', {swearWordsUsed: testBannedWordMessage});
let user; let groupWithChat; let member; let
additionalMember;
const testMessage = 'Test Message';
const testBannedWordMessage = 'TESTPLACEHOLDERSWEARWORDHERE';
const testBannedWordMessage1 = 'TESTPLACEHOLDERSWEARWORDHERE1';
const testSlurMessage = 'message with TESTPLACEHOLDERSLURWORDHERE';
const testSlurMessage1 = 'TESTPLACEHOLDERSLURWORDHERE1';
const bannedWordErrorMessage = t('bannedWordUsed', { swearWordsUsed: testBannedWordMessage });
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Guild',
type: 'guild',
@@ -40,14 +41,14 @@ describe('POST /chat', () => {
members: 2,
});
user = groupLeader;
await user.update({'contributor.level': SPAM_MIN_EXEMPT_CONTRIB_LEVEL}); // prevent tests accidentally throwing messageGroupChatSpam
await user.update({ 'contributor.level': SPAM_MIN_EXEMPT_CONTRIB_LEVEL }); // prevent tests accidentally throwing messageGroupChatSpam
groupWithChat = group;
member = members[0];
additionalMember = members[1];
member = members[0]; // eslint-disable-line prefer-destructuring
additionalMember = members[1]; // eslint-disable-line prefer-destructuring
});
it('Returns an error when no message is provided', async () => {
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: ''}))
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: '' }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -56,7 +57,7 @@ describe('POST /chat', () => {
});
it('Returns an error when an empty message is provided', async () => {
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: ' '}))
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: ' ' }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -65,7 +66,7 @@ describe('POST /chat', () => {
});
it('Returns an error when an message containing only newlines is provided', async () => {
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: '\n\n'}))
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: '\n\n' }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -74,7 +75,7 @@ describe('POST /chat', () => {
});
it('Returns an error when group is not found', async () => {
await expect(user.post('/groups/invalidID/chat', { message: testMessage})).to.eventually.be.rejected.and.eql({
await expect(user.post('/groups/invalidID/chat', { message: testMessage })).to.eventually.be.rejected.and.eql({
code: 404,
error: 'NotFound',
message: t('groupNotFound'),
@@ -83,12 +84,12 @@ describe('POST /chat', () => {
describe('mute user', () => {
afterEach(() => {
member.update({'flags.chatRevoked': false});
member.update({ 'flags.chatRevoked': false });
});
it('returns an error when chat privileges are revoked when sending a message to a public guild', async () => {
const userWithChatRevoked = await member.update({'flags.chatRevoked': true});
await expect(userWithChatRevoked.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage})).to.eventually.be.rejected.and.eql({
const userWithChatRevoked = await member.update({ 'flags.chatRevoked': true });
await expect(userWithChatRevoked.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage })).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('chatPrivilegesRevoked'),
@@ -106,9 +107,9 @@ describe('POST /chat', () => {
});
const privateGuildMemberWithChatsRevoked = members[0];
await privateGuildMemberWithChatsRevoked.update({'flags.chatRevoked': true});
await privateGuildMemberWithChatsRevoked.update({ 'flags.chatRevoked': true });
const message = await privateGuildMemberWithChatsRevoked.post(`/groups/${group._id}/chat`, { message: testMessage});
const message = await privateGuildMemberWithChatsRevoked.post(`/groups/${group._id}/chat`, { message: testMessage });
expect(message.message.id).to.exist;
});
@@ -124,9 +125,9 @@ describe('POST /chat', () => {
});
const privatePartyMemberWithChatsRevoked = members[0];
await privatePartyMemberWithChatsRevoked.update({'flags.chatRevoked': true});
await privatePartyMemberWithChatsRevoked.update({ 'flags.chatRevoked': true });
const message = await privatePartyMemberWithChatsRevoked.post(`/groups/${group._id}/chat`, { message: testMessage});
const message = await privatePartyMemberWithChatsRevoked.post(`/groups/${group._id}/chat`, { message: testMessage });
expect(message.message.id).to.exist;
});
@@ -140,12 +141,12 @@ describe('POST /chat', () => {
afterEach(() => {
sandbox.restore();
member.update({'flags.chatShadowMuted': false});
member.update({ 'flags.chatShadowMuted': false });
});
it('creates a chat with flagCount already set and notifies mods when sending a message to a public guild', async () => {
const userWithChatShadowMuted = await member.update({'flags.chatShadowMuted': true});
const message = await userWithChatShadowMuted.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const userWithChatShadowMuted = await member.update({ 'flags.chatShadowMuted': true });
const message = await userWithChatShadowMuted.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
expect(message.message.id).to.exist;
expect(message.message.flagCount).to.eql(CHAT_FLAG_FROM_SHADOW_MUTE);
@@ -185,9 +186,9 @@ describe('POST /chat', () => {
});
const userWithChatShadowMuted = members[0];
await userWithChatShadowMuted.update({'flags.chatShadowMuted': true});
await userWithChatShadowMuted.update({ 'flags.chatShadowMuted': true });
const message = await userWithChatShadowMuted.post(`/groups/${group._id}/chat`, { message: testMessage});
const message = await userWithChatShadowMuted.post(`/groups/${group._id}/chat`, { message: testMessage });
expect(message.message.id).to.exist;
expect(message.message.flagCount).to.eql(0);
@@ -204,16 +205,16 @@ describe('POST /chat', () => {
});
const userWithChatShadowMuted = members[0];
await userWithChatShadowMuted.update({'flags.chatShadowMuted': true});
await userWithChatShadowMuted.update({ 'flags.chatShadowMuted': true });
const message = await userWithChatShadowMuted.post(`/groups/${group._id}/chat`, { message: testMessage});
const message = await userWithChatShadowMuted.post(`/groups/${group._id}/chat`, { message: testMessage });
expect(message.message.id).to.exist;
expect(message.message.flagCount).to.eql(0);
});
it('creates a chat with zero flagCount when non-shadow-muted user sends a message to a public guild', async () => {
const message = await member.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const message = await member.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
expect(message.message.id).to.exist;
expect(message.message.flagCount).to.eql(0);
});
@@ -221,7 +222,7 @@ describe('POST /chat', () => {
context('banned word', () => {
it('returns an error when chat message contains a banned word in tavern', async () => {
await expect(user.post('/groups/habitrpg/chat', { message: testBannedWordMessage}))
await expect(user.post('/groups/habitrpg/chat', { message: testBannedWordMessage }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -230,7 +231,7 @@ describe('POST /chat', () => {
});
it('returns an error when chat message contains a banned word in a public guild', async () => {
let { group, members } = await createAndPopulateGroup({
const { group, members } = await createAndPopulateGroup({
groupDetails: {
name: 'public guild',
type: 'guild',
@@ -239,7 +240,7 @@ describe('POST /chat', () => {
members: 1,
});
await expect(members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage}))
await expect(members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -248,8 +249,8 @@ describe('POST /chat', () => {
});
it('errors when word is part of a phrase', async () => {
let wordInPhrase = `phrase ${testBannedWordMessage} end`;
await expect(user.post('/groups/habitrpg/chat', { message: wordInPhrase}))
const wordInPhrase = `phrase ${testBannedWordMessage} end`;
await expect(user.post('/groups/habitrpg/chat', { message: wordInPhrase }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -258,8 +259,8 @@ describe('POST /chat', () => {
});
it('errors when word is surrounded by non alphabet characters', async () => {
let wordInPhrase = `_!${testBannedWordMessage}@_`;
await expect(user.post('/groups/habitrpg/chat', { message: wordInPhrase}))
const wordInPhrase = `_!${testBannedWordMessage}@_`;
await expect(user.post('/groups/habitrpg/chat', { message: wordInPhrase }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
@@ -268,47 +269,51 @@ describe('POST /chat', () => {
});
it('errors when word is typed in mixed case', async () => {
let substrLength = Math.floor(testBannedWordMessage.length / 2);
let chatMessage = testBannedWordMessage.substring(0, substrLength).toLowerCase() + testBannedWordMessage.substring(substrLength).toUpperCase();
const substrLength = Math.floor(testBannedWordMessage.length / 2);
const chatMessage = testBannedWordMessage.substring(0, substrLength).toLowerCase()
+ testBannedWordMessage.substring(substrLength).toUpperCase();
await expect(user.post('/groups/habitrpg/chat', { message: chatMessage }))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('bannedWordUsed', {swearWordsUsed: chatMessage}),
message: t('bannedWordUsed', { swearWordsUsed: chatMessage }),
});
});
it('checks error message has all the banned words used, regardless of case', async () => {
let testBannedWords = [testBannedWordMessage.toUpperCase(), testBannedWordMessage1.toLowerCase()];
let chatMessage = `Mixing ${testBannedWords[0]} and ${testBannedWords[1]} is bad for you.`;
await expect(user.post('/groups/habitrpg/chat', { message: chatMessage}))
const testBannedWords = [
testBannedWordMessage.toUpperCase(),
testBannedWordMessage1.toLowerCase(),
];
const chatMessage = `Mixing ${testBannedWords[0]} and ${testBannedWords[1]} is bad for you.`;
await expect(user.post('/groups/habitrpg/chat', { message: chatMessage }))
.to.eventually.be.rejected
.and.have.property('message')
.that.includes(testBannedWords.join(', '));
});
it('check all banned words are matched', async () => {
let message = bannedWords.join(',').replace(/\\/g, '');
let matches = getMatchesByWordArray(message, bannedWords);
const message = bannedWords.join(',').replace(/\\/g, '');
const matches = getMatchesByWordArray(message, bannedWords);
expect(matches.length).to.equal(bannedWords.length);
});
it('does not error when bad word is suffix of a word', async () => {
let wordAsSuffix = `prefix${testBannedWordMessage}`;
let message = await user.post('/groups/habitrpg/chat', { message: wordAsSuffix});
const wordAsSuffix = `prefix${testBannedWordMessage}`;
const message = await user.post('/groups/habitrpg/chat', { message: wordAsSuffix });
expect(message.message.id).to.exist;
});
it('does not error when bad word is prefix of a word', async () => {
let wordAsPrefix = `${testBannedWordMessage}suffix`;
let message = await user.post('/groups/habitrpg/chat', { message: wordAsPrefix});
const wordAsPrefix = `${testBannedWordMessage}suffix`;
const message = await user.post('/groups/habitrpg/chat', { message: wordAsPrefix });
expect(message.message.id).to.exist;
});
it('does not error when sending a chat message containing a banned word to a party', async () => {
let { group, members } = await createAndPopulateGroup({
const { group, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Party',
type: 'party',
@@ -317,13 +322,13 @@ describe('POST /chat', () => {
members: 1,
});
let message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage});
const message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage });
expect(message.message.id).to.exist;
});
it('does not error when sending a chat message containing a banned word to a public guild in which banned words are allowed', async () => {
let { group, members } = await createAndPopulateGroup({
const { group, members } = await createAndPopulateGroup({
groupDetails: {
name: 'public guild',
type: 'guild',
@@ -334,13 +339,13 @@ describe('POST /chat', () => {
guildsAllowingBannedWords[group._id] = true;
let message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage});
const message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage });
expect(message.message.id).to.exist;
});
it('does not error when sending a chat message containing a banned word to a private guild', async () => {
let { group, members } = await createAndPopulateGroup({
const { group, members } = await createAndPopulateGroup({
groupDetails: {
name: 'private guild',
type: 'guild',
@@ -349,7 +354,7 @@ describe('POST /chat', () => {
members: 1,
});
let message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage});
const message = await members[0].post(`/groups/${group._id}/chat`, { message: testBannedWordMessage });
expect(message.message.id).to.exist;
});
@@ -363,11 +368,11 @@ describe('POST /chat', () => {
afterEach(() => {
sandbox.restore();
user.update({'flags.chatRevoked': false});
user.update({ 'flags.chatRevoked': false });
});
it('errors and revokes privileges when chat message contains a banned slur', async () => {
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: testSlurMessage})).to.eventually.be.rejected.and.eql({
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: testSlurMessage })).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('bannedSlurUsed'),
@@ -398,7 +403,7 @@ describe('POST /chat', () => {
/* eslint-enable camelcase */
// Chat privileges are revoked
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage})).to.eventually.be.rejected.and.eql({
await expect(user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage })).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('chatPrivilegesRevoked'),
@@ -406,7 +411,7 @@ describe('POST /chat', () => {
});
it('does not allow slurs in private groups', async () => {
let { group, members } = await createAndPopulateGroup({
const { group, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Party',
type: 'party',
@@ -415,7 +420,7 @@ describe('POST /chat', () => {
members: 1,
});
await expect(members[0].post(`/groups/${group._id}/chat`, { message: testSlurMessage})).to.eventually.be.rejected.and.eql({
await expect(members[0].post(`/groups/${group._id}/chat`, { message: testSlurMessage })).to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('bannedSlurUsed'),
@@ -446,7 +451,7 @@ describe('POST /chat', () => {
/* eslint-enable camelcase */
// Chat privileges are revoked
await expect(members[0].post(`/groups/${groupWithChat._id}/chat`, { message: testMessage})).to.eventually.be.rejected.and.eql({
await expect(members[0].post(`/groups/${groupWithChat._id}/chat`, { message: testMessage })).to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('chatPrivilegesRevoked'),
@@ -454,8 +459,9 @@ describe('POST /chat', () => {
});
it('errors when slur is typed in mixed case', async () => {
let substrLength = Math.floor(testSlurMessage1.length / 2);
let chatMessage = testSlurMessage1.substring(0, substrLength).toLowerCase() + testSlurMessage1.substring(substrLength).toUpperCase();
const substrLength = Math.floor(testSlurMessage1.length / 2);
const chatMessage = testSlurMessage1.substring(0, substrLength).toLowerCase()
+ testSlurMessage1.substring(substrLength).toUpperCase();
await expect(user.post('/groups/habitrpg/chat', { message: chatMessage }))
.to.eventually.be.rejected.and.eql({
code: 400,
@@ -466,7 +472,7 @@ describe('POST /chat', () => {
});
it('creates a chat', async () => {
const newMessage = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const newMessage = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
const groupMessages = await user.get(`/groups/${groupWithChat._id}/chat`);
expect(newMessage.message.id).to.exist;
@@ -479,7 +485,7 @@ describe('POST /chat', () => {
THIS PART WON'T BE IN THE MESSAGE (over 3000)
`;
const newMessage = await user.post(`/groups/${groupWithChat._id}/chat`, { message: veryLongMessage});
const newMessage = await user.post(`/groups/${groupWithChat._id}/chat`, { message: veryLongMessage });
const groupMessages = await user.get(`/groups/${groupWithChat._id}/chat`);
expect(newMessage.message.id).to.exist;
@@ -501,7 +507,7 @@ describe('POST /chat', () => {
});
await userWithStyle.sync();
const message = await userWithStyle.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const message = await userWithStyle.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
expect(message.message.id).to.exist;
expect(message.message.userStyles.items.currentMount).to.eql(userWithStyle.items.currentMount);
@@ -511,7 +517,8 @@ describe('POST /chat', () => {
expect(message.message.userStyles.preferences.skin).to.eql(userWithStyle.preferences.skin);
expect(message.message.userStyles.preferences.shirt).to.eql(userWithStyle.preferences.shirt);
expect(message.message.userStyles.preferences.chair).to.eql(userWithStyle.preferences.chair);
expect(message.message.userStyles.preferences.background).to.eql(userWithStyle.preferences.background);
expect(message.message.userStyles.preferences.background)
.to.eql(userWithStyle.preferences.background);
});
it('adds backer info to chat', async () => {
@@ -524,7 +531,7 @@ describe('POST /chat', () => {
backer: backerInfo,
});
const message = await backer.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage});
const message = await backer.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
const messageBackerInfo = message.message.backer;
expect(messageBackerInfo.npc).to.equal(backerInfo.npc);
@@ -533,8 +540,8 @@ describe('POST /chat', () => {
});
it('sends group chat received webhooks', async () => {
let userUuid = generateUUID();
let memberUuid = generateUUID();
const userUuid = generateUUID();
const memberUuid = generateUUID();
await server.start();
await user.post('/user/webhook', {
@@ -554,16 +561,16 @@ describe('POST /chat', () => {
},
});
let message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
await sleep();
await server.close();
let userBody = server.getWebhookData(userUuid);
let memberBody = server.getWebhookData(memberUuid);
const userBody = server.getWebhookData(userUuid);
const memberBody = server.getWebhookData(memberUuid);
[userBody, memberBody].forEach((body) => {
[userBody, memberBody].forEach(body => {
expect(body.group.id).to.eql(groupWithChat._id);
expect(body.group.name).to.eql(groupWithChat.name);
expect(body.chat).to.eql(message.message);
@@ -572,22 +579,20 @@ describe('POST /chat', () => {
context('chat notifications', () => {
beforeEach(() => {
member.update({newMessages: {}, notifications: []});
member.update({ newMessages: {}, notifications: [] });
});
it('notifies other users of new messages for a guild', async () => {
let message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
let memberWithNotification = await member.get('/user');
const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
const memberWithNotification = await member.get('/user');
expect(message.message.id).to.exist;
expect(memberWithNotification.newMessages[`${groupWithChat._id}`]).to.exist;
expect(memberWithNotification.notifications.find(n => {
return n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupWithChat._id;
})).to.exist;
expect(memberWithNotification.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupWithChat._id)).to.exist;
});
it('notifies other users of new messages for a party', async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
name: 'Test Party',
type: 'party',
@@ -596,36 +601,32 @@ describe('POST /chat', () => {
members: 1,
});
let message = await groupLeader.post(`/groups/${group._id}/chat`, { message: testMessage });
let memberWithNotification = await members[0].get('/user');
const message = await groupLeader.post(`/groups/${group._id}/chat`, { message: testMessage });
const memberWithNotification = await members[0].get('/user');
expect(message.message.id).to.exist;
expect(memberWithNotification.newMessages[`${group._id}`]).to.exist;
expect(memberWithNotification.notifications.find(n => {
return n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === group._id;
})).to.exist;
expect(memberWithNotification.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === group._id)).to.exist;
});
it('does not notify other users of a new message that is already hidden from shadow-muting', async () => {
await user.update({'flags.chatShadowMuted': true});
let message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
let memberWithNotification = await member.get('/user');
await user.update({ 'flags.chatShadowMuted': true });
const message = await user.post(`/groups/${groupWithChat._id}/chat`, { message: testMessage });
const memberWithNotification = await member.get('/user');
await user.update({'flags.chatShadowMuted': false});
await user.update({ 'flags.chatShadowMuted': false });
expect(message.message.id).to.exist;
expect(memberWithNotification.newMessages[`${groupWithChat._id}`]).to.not.exist;
expect(memberWithNotification.notifications.find(n => {
return n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupWithChat._id;
})).to.not.exist;
expect(memberWithNotification.notifications.find(n => n.type === 'NEW_CHAT_MESSAGE' && n.data.group.id === groupWithChat._id)).to.not.exist;
});
});
context('Spam prevention', () => {
it('Returns an error when the user has been posting too many messages', async () => {
// Post as many messages are needed to reach the spam limit
for (let i = 0; i < SPAM_MESSAGE_LIMIT; i++) {
let result = await additionalMember.post(`/groups/${TAVERN_ID}/chat`, { message: testMessage }); // eslint-disable-line no-await-in-loop
for (let i = 0; i < SPAM_MESSAGE_LIMIT; i += 1) {
const result = await additionalMember.post(`/groups/${TAVERN_ID}/chat`, { message: testMessage }); // eslint-disable-line no-await-in-loop
expect(result.message.id).to.exist;
}
@@ -637,11 +638,11 @@ describe('POST /chat', () => {
});
it('contributor should not receive spam alert', async () => {
let userSocialite = await member.update({'contributor.level': SPAM_MIN_EXEMPT_CONTRIB_LEVEL});
const userSocialite = await member.update({ 'contributor.level': SPAM_MIN_EXEMPT_CONTRIB_LEVEL });
// Post 1 more message than the spam limit to ensure they do not reach the limit
for (let i = 0; i < SPAM_MESSAGE_LIMIT + 1; i++) {
let result = await userSocialite.post(`/groups/${TAVERN_ID}/chat`, { message: testMessage }); // eslint-disable-line no-await-in-loop
for (let i = 0; i < SPAM_MESSAGE_LIMIT + 1; i += 1) {
const result = await userSocialite.post(`/groups/${TAVERN_ID}/chat`, { message: testMessage }); // eslint-disable-line no-await-in-loop
expect(result.message.id).to.exist;
}
});

18
test/api/v3/integration/chat/POST-chat_seen.test.js
View File

@@ -5,10 +5,11 @@ import {
describe('POST /groups/:id/chat/seen', () => {
context('Guild', () => {
let guild, guildLeader, guildMember, guildMessage;
let guild; let guildLeader; let guildMember; let
guildMessage;
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
type: 'guild',
privacy: 'public',
@@ -18,7 +19,7 @@ describe('POST /groups/:id/chat/seen', () => {
guild = group;
guildLeader = groupLeader;
guildMember = members[0];
guildMember = members[0]; // eslint-disable-line prefer-destructuring
guildMessage = await guildLeader.post(`/groups/${guild._id}/chat`, { message: 'Some guild message' });
guildMessage = guildMessage.message;
@@ -32,7 +33,7 @@ describe('POST /groups/:id/chat/seen', () => {
await sleep(1);
let guildThatHasSeenChat = await guildMember.get('/user');
const guildThatHasSeenChat = await guildMember.get('/user');
expect(guildThatHasSeenChat.notifications.length).to.equal(initialNotifications - 1);
expect(guildThatHasSeenChat.newMessages).to.be.empty;
@@ -40,10 +41,11 @@ describe('POST /groups/:id/chat/seen', () => {
});
context('Party', () => {
let party, partyLeader, partyMember, partyMessage;
let party; let partyLeader; let partyMember; let
partyMessage;
before(async () => {
let { group, groupLeader, members } = await createAndPopulateGroup({
const { group, groupLeader, members } = await createAndPopulateGroup({
groupDetails: {
type: 'party',
privacy: 'private',
@@ -53,7 +55,7 @@ describe('POST /groups/:id/chat/seen', () => {
party = group;
partyLeader = groupLeader;
partyMember = members[0];
partyMember = members[0]; // eslint-disable-line prefer-destructuring
partyMessage = await partyLeader.post(`/groups/${party._id}/chat`, { message: 'Some party message' });
partyMessage = partyMessage.message;
@@ -67,7 +69,7 @@ describe('POST /groups/:id/chat/seen', () => {
await sleep(1);
let partyMemberThatHasSeenChat = await partyMember.get('/user');
const partyMemberThatHasSeenChat = await partyMember.get('/user');
expect(partyMemberThatHasSeenChat.notifications.length).to.equal(initialNotifications - 1);
expect(partyMemberThatHasSeenChat.newMessages).to.be.empty;

54
test/api/v3/integration/chat/POST-groups_id_chat_id_clear_flags.test.js
View File

@@ -1,18 +1,19 @@
import moment from 'moment';
import { v4 as generateUUID } from 'uuid';
import {
createAndPopulateGroup,
generateUser,
translate as t,
} from '../../../../helpers/api-integration/v3';
import config from '../../../../../config.json';
import moment from 'moment';
import { v4 as generateUUID } from 'uuid';
describe('POST /groups/:id/chat/:id/clearflags', () => {
const USER_AGE_FOR_FLAGGING = 3;
let groupWithChat, message, author, nonAdmin, admin;
let groupWithChat; let message; let author; let nonAdmin; let
admin;
before(async () => {
let { group, groupLeader } = await createAndPopulateGroup({
const { group, groupLeader } = await createAndPopulateGroup({
groupDetails: {
type: 'guild',
privacy: 'public',
@@ -21,8 +22,8 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
groupWithChat = group;
author = groupLeader;
nonAdmin = await generateUser({'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate()});
admin = await generateUser({'contributor.admin': true});
nonAdmin = await generateUser({ 'auth.timestamps.created': moment().subtract(USER_AGE_FOR_FLAGGING + 1, 'days').toDate() });
admin = await generateUser({ 'contributor.admin': true });
message = await author.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message' });
message = message.message;
@@ -30,17 +31,15 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
});
context('Single Message', () => {
it('returns error when non-admin attempts to clear flags', async () => {
return expect(nonAdmin.post(`/groups/${groupWithChat._id}/chat/${message.id}/clearflags`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('messageGroupChatAdminClearFlagCount'),
});
});
it('returns error when non-admin attempts to clear flags', async () => expect(nonAdmin.post(`/groups/${groupWithChat._id}/chat/${message.id}/clearflags`))
.to.eventually.be.rejected.and.eql({
code: 401,
error: 'NotAuthorized',
message: t('messageGroupChatAdminClearFlagCount'),
}));
it('returns error if message does not exist', async () => {
let fakeMessageID = generateUUID();
const fakeMessageID = generateUUID();
await expect(admin.post(`/groups/${groupWithChat._id}/chat/${fakeMessageID}/clearflags`))
.to.eventually.be.rejected.and.eql({
@@ -52,13 +51,13 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
it('clears flags and leaves old flags on the flag object', async () => {
await admin.post(`/groups/${groupWithChat._id}/chat/${message.id}/clearflags`);
let messages = await admin.get(`/groups/${groupWithChat._id}/chat`);
const messages = await admin.get(`/groups/${groupWithChat._id}/chat`);
expect(messages[0].flagCount).to.eql(0);
expect(messages[0].flags).to.have.property(admin._id, true);
});
it('clears flags in a private group', async () => {
let { group, members } = await createAndPopulateGroup({
const { group, members } = await createAndPopulateGroup({
groupDetails: {
type: 'party',
privacy: 'private',
@@ -82,7 +81,7 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
});
it('can\'t flag a system message', async () => {
let { group, members } = await createAndPopulateGroup({
const { group, members } = await createAndPopulateGroup({
groupDetails: {
type: 'party',
privacy: 'private',
@@ -90,7 +89,7 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
members: 1,
});
let member = members[0];
const member = members[0];
// make member that can use skills
await member.update({
@@ -101,12 +100,12 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
await member.post('/user/class/cast/mpheal');
let [skillMsg] = await member.get(`/groups/${group.id}/chat`);
const [skillMsg] = await member.get(`/groups/${group.id}/chat`);
await expect(member.post(`/groups/${group._id}/chat/${skillMsg.id}/flag`))
.to.eventually.be.rejected.and.eql({
code: 400,
error: 'BadRequest',
message: t('messageCannotFlagSystemMessages', {communityManagerEmail: config.EMAILS_COMMUNITY_MANAGER_EMAIL}),
message: t('messageCannotFlagSystemMessages', { communityManagerEmail: config.EMAILS_COMMUNITY_MANAGER_EMAIL }),
});
// let messages = await members[0].get(`/groups/${group._id}/chat`);
// expect(messages[0].id).to.eql(skillMsg.id);
@@ -115,7 +114,8 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
});
context('admin user, group with multiple messages', () => {
let message2, message3, message4;
let message2; let message3; let
message4;
before(async () => {
message2 = await author.post(`/groups/${groupWithChat._id}/chat`, { message: 'Some message 2' });
@@ -133,14 +133,14 @@ describe('POST /groups/:id/chat/:id/clearflags', () => {
it('changes only the message that is flagged', async () => {
await admin.post(`/groups/${groupWithChat._id}/chat/${message.id}/clearflags`);
let messages = await admin.get(`/groups/${groupWithChat._id}/chat`);
const messages = await admin.get(`/groups/${groupWithChat._id}/chat`);
expect(messages).to.have.lengthOf(4);
let messageThatWasUnflagged = messages[3];
let messageWith1Flag = messages[2];
let messageWith2Flag = messages[1];
let messageWithoutFlags = messages[0];
const messageThatWasUnflagged = messages[3];
const messageWith1Flag = messages[2];
const messageWith2Flag = messages[1];
const messageWithoutFlags = messages[0];
expect(messageThatWasUnflagged.flagCount).to.eql(0);
expect(messageThatWasUnflagged.flags).to.have.property(admin._id, true);