Move chat tests to new infrastructure

common/locales/en/messages.json

@@ -49,6 +49,12 @@
   "messageGroupOnlyLeaderCanUpdate": "Only the group leader can update the group!",
   "messageGroupRequiresInvite": "Can't join a group you're not invited to.",
   "messageGroupCannotRemoveSelf": "You cannot remove yourself!",
+  "messageGroupChatBlankMessage": "You cannot send a blank message",
+  "messageGroupChatLikeOwnMessage": "Can't like your own message. Don't be that person.",
+  "messageGroupChatFlagOwnMessage": "Can't report your own message.",
+  "messageGroupChatFlagAlreadyReported": "You have already reported this message",
+  "messageGroupChatNotFound": "Message not found!",
+  "messageGroupChatAdminClearFlagCount": "Only an admin can clear the flag count!",
 
   "messageUserOperationProtected": "path `<%= operation %>` was not saved, as it's a protected path.",
   "messageUserOperationNotFound": "<%= operation %> operation not found"

test/api-legacy/chat.coffee

@@ -26,78 +26,6 @@ describe "Chat", ->
     ], done
 
   chat = undefined
-  it "posts a message to party chat", (done) ->
-    msg = "TestMsg"
-    request.post(baseURL + "/groups/" + group._id + "/chat?message=" + msg).end (err, res) ->
-      expectCode res, 200
-      chat = res.body.message
-      expect(chat.id).to.be.ok
-      expect(chat.text).to.equal msg
-      expect(chat.timestamp).to.be.exist
-      expect(chat.likes).to.be.empty
-      expect(chat.flags).to.be.empty
-      expect(chat.flagCount).to.equal 0
-      expect(chat.uuid).to.be.exist
-      expect(chat.contributor).to.be.empty
-      expect(chat.backer).to.be.empty
-      expect(chat.uuid).to.equal user._id
-      expect(chat.user).to.equal user.profile.name
-      done()
-
-  it "does not post an empty message", (done) ->
-    msg = ""
-    request.post(baseURL + "/groups/" + group._id + "/chat?message=" + msg).send(
-    ).end (err, res) ->
-      expectCode res, 400
-      expect(res.body.err).to.equal 'You cannot send a blank message'
-      done()
-
-  it "can not like own chat message", (done) ->
-    request.post(baseURL + "/groups/" + group._id + "/chat/" + chat.id + "/like").send(
-    ).end (err, res) ->
-      expectCode res, 401
-      body = res.body
-      expect(body.err).to.equal "Can't like your own message. Don't be that person."
-      done()
-
-  it "can not flag own message", (done) ->
-    request.post(baseURL + "/groups/" + group._id + "/chat/" + chat.id + "/flag").send(
-    ).end (err, res) ->
-      expectCode res, 401
-      body = res.body
-      expect(body.err).to.equal "Can't report your own message."
-      done()
-
-  it "gets chat messages from party chat", (done) ->
-    request.get(baseURL + "/groups/" + group._id + "/chat").send(
-    ).end (err, res) ->
-      expectCode res, 200
-      message = res.body[0]
-      expect(message.id).to.equal chat.id
-      expect(message.timestamp).to.equal chat.timestamp
-      expect(message.likes).to.deep.equal chat.likes
-      expect(message.flags).to.deep.equal chat.flags
-      expect(message.flagCount).to.equal chat.flagCount
-      expect(message.uuid).to.equal chat.uuid
-      expect(message.contributor).to.deep.equal chat.contributor
-      expect(message.backer).to.deep.equal chat.backer
-      expect(message.user).to.equal chat.user
-      done()
-
-  it "deletes a chat messages from party chat", (done) ->
-    request.del(baseURL + "/groups/" + group._id + "/chat/" + chat.id).send(
-    ).end (err, res) ->
-      expectCode res, 204
-      expect(res.body).to.be.empty
-      done()
-
-  it "can not delete already deleted message", (done) ->
-    request.del(baseURL + "/groups/" + group._id + "/chat/" + chat.id).send(
-    ).end (err, res) ->
-      expectCode res, 404
-      body = res.body
-      expect(body.err).to.equal "Message not found!"
-      done()
 
   it "removes a user's chat notifications when user is kicked", (done) ->
     userToRemove = null

test/api/groups/chat/DELETE-groups_id_chat.test.js

@@ -0,0 +1,42 @@
+import {
+  createAndPopulateGroup,
+  generateUser,
+  requester,
+  translate as t,
+} from '../../../helpers/api.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'),
+    });
+  });
+});

test/api/groups/chat/GET-groups_id_chat.test.js

@@ -0,0 +1,48 @@
+import {
+  createAndPopulateGroup,
+  generateUser,
+  requester,
+  translate as t,
+} from '../../../helpers/api.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;
+      });
+    });
+  });
+});

test/api/groups/chat/POST-groups_id_chat.test.js

@@ -0,0 +1,46 @@
+import {
+  createAndPopulateGroup,
+  generateUser,
+  requester,
+  translate as t,
+} from '../../../helpers/api.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'),
+    });
+  });
+});

test/api/groups/chat/POST-groups_id_chat_id_flag.test.js

@@ -0,0 +1,102 @@
+import {
+  createAndPopulateGroup,
+  generateUser,
+  requester,
+  translate as t,
+} from '../../../helpers/api.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.flags[user._id]).to.eql(true);
+      });
+    });
+  });
+
+  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'),
+        });
+    });
+  });
+});

test/api/groups/chat/POST-groups_id_chat_id_like.test.js

@@ -0,0 +1,111 @@
+import {
+  createAndPopulateGroup,
+  generateUser,
+  requester,
+  translate as t,
+} from '../../../helpers/api.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'),
+        });
+    });
+  });
+});

website/src/controllers/groups.js

@@ -281,7 +281,7 @@ api.getChat = function(req, res, next) {
  */
 api.postChat = function(req, res, next) {
   if(!req.query.message) {
-    return res.json(400,{err:'You cannot send a blank message'});
+    return res.json(400,{err: shared.i18n.t('messageGroupChatBlankMessage')});
   } else {
     var user = res.locals.user
     var group = res.locals.group;
@@ -329,15 +329,15 @@ api.flagChatMessage = function(req, res, next){
   var group = res.locals.group;
   var message = _.find(group.chat, {id: req.params.mid});
 
-  if(!message) return res.json(404, {err: "Message not found!"});
-  if(message.uuid == user._id) return res.json(401, {err: "Can't report your own message."});
+  if(!message) return res.json(404, {err: shared.i18n.t('messageGroupChatNotFound')});
+  if(message.uuid == user._id) return res.json(401, {err: shared.i18n.t('messageGroupChatFlagOwnMessage')});
 
   User.findOne({_id: message.uuid}, {auth: 1}, function(err, author){
     if(err) return next(err);
 
     // Log user ids that have flagged the message
     if(!message.flags) message.flags = {};
-    if(message.flags[user._id] && !user.contributor.admin) return res.json(401, {err: "You have already reported this message"});
+    if(message.flags[user._id] && !user.contributor.admin) return res.json(401, {err: shared.i18n.t('messageGroupChatFlagAlreadyReported')});
     message.flags[user._id] = true;
 
     // Log total number of flags (publicly viewable)
@@ -394,7 +394,7 @@ api.clearFlagCount = function(req, res, next){
   var group = res.locals.group;
   var message = _.find(group.chat, {id: req.params.mid});
 
-  if(!message) return res.json(404, {err: "Message not found!"});
+  if(!message) return res.json(404, {err: shared.i18n.t('messageGroupChatNotFound')});
 
   if(user.contributor.admin){
     message.flagCount = 0;
@@ -405,7 +405,7 @@ api.clearFlagCount = function(req, res, next){
       return res.send(204);
     });
   }else{
-    return res.json(401, {err: "Only an admin can clear the flag count!"})
+    return res.json(401, {err: shared.i18n.t('messageGroupChatAdminClearFlagCount')})
   }
 
 }
@@ -425,8 +425,8 @@ api.likeChatMessage = function(req, res, next) {
   var user = res.locals.user;
   var group = res.locals.group;
   var message = _.find(group.chat, {id: req.params.mid});
-  if (!message) return res.json(404, {err: "Message not found!"});
-  if (message.uuid == user._id) return res.json(401, {err: "Can't like your own message. Don't be that person."});
+  if (!message) return res.json(404, {err: shared.i18n.t('messageGroupChatNotFound')});
+  if (message.uuid == user._id) return res.json(401, {err: shared.i18n.t('messageGroupChatLikeOwnMessage')});
   if (!message.likes) message.likes = {};
   if (message.likes[user._id]) {
     delete message.likes[user._id];