Ghost/ghost/core/test/e2e-api/members-comments/comments.test.js
Fabien "egg" O'Carroll e6317e9da3 Fixed the count endpoint for the Members Comments API
refs https://github.com/TryGhost/Team/issues/1695

When a post does not have any comments we were not returning any data
from the API, which would cause issues with the comment counts helper
frontend script. This updates the endpoint to always include the count
when explicitly requesting the count for specific posts.

We've also pulled the logic out into a stats service so that the endpoint
can just refer to the controller.
2022-08-03 11:52:08 +01:00

620 lines
22 KiB
JavaScript

const assert = require('assert');
const {agentProvider, mockManager, fixtureManager, matchers} = require('../../utils/e2e-framework');
const {anyEtag, anyObjectId, anyLocationFor, anyISODateTime, anyUuid, anyNumber, anyBoolean} = matchers;
const should = require('should');
const models = require('../../../core/server/models');
const moment = require('moment-timezone');
const settingsCache = require('../../../core/shared/settings-cache');
const sinon = require('sinon');
let membersAgent, membersAgent2, member, postId, postTitle, commentId;
const commentMatcherNoMember = {
id: anyObjectId,
created_at: anyISODateTime
};
const commentMatcher = {
id: anyObjectId,
created_at: anyISODateTime,
member: {
id: anyObjectId,
uuid: anyUuid
},
likes_count: anyNumber,
liked: anyBoolean
};
const commentMatcherWithReply = {
id: anyObjectId,
created_at: anyISODateTime,
member: {
id: anyObjectId,
uuid: anyUuid
},
likes_count: anyNumber,
liked: anyBoolean,
replies: [commentMatcher]
};
async function sleep(ms) {
return new Promise((resolve) => {
setTimeout(resolve, ms);
});
}
function escapeRegExp(string) {
return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
}
describe('Comments API', function () {
before(async function () {
membersAgent = await agentProvider.getMembersAPIAgent();
membersAgent2 = await agentProvider.getMembersAPIAgent();
await fixtureManager.init('posts', 'members', 'comments');
postId = fixtureManager.get('posts', 0).id;
postTitle = fixtureManager.get('posts', 0).title;
});
beforeEach(function () {
mockManager.mockMail();
});
afterEach(function () {
mockManager.restore();
});
describe('when not authenticated but enabled', function () {
beforeEach(function () {
const getStub = sinon.stub(settingsCache, 'get');
getStub.callsFake((key, options) => {
if (key === 'comments_enabled') {
return 'all';
}
return getStub.wrappedMethod.call(settingsCache, key, options);
});
});
after(async function () {
sinon.restore();
});
it('Can browse all comments of a post', async function () {
const {body} = await membersAgent
.get(`/api/comments/?filter=post_id:${postId}`)
.expectStatus(200)
.matchHeaderSnapshot({
etag: anyEtag
})
.matchBodySnapshot({
comments: [commentMatcherWithReply]
});
});
it('cannot report a comment', async function () {
commentId = fixtureManager.get('comments', 0).id;
// Create a temporary comment
await membersAgent
.post(`/api/comments/${commentId}/report/`)
.expectStatus(401)
.matchHeaderSnapshot({
etag: anyEtag
})
.matchBodySnapshot({
errors: [{
id: anyUuid
}]
});
});
});
describe('when not enabled', function () {
beforeEach(async function () {
await membersAgent.loginAs('member@example.com');
const getStub = sinon.stub(settingsCache, 'get');
getStub.callsFake((key, options) => {
if (key === 'comments_enabled') {
return 'off';
}
return getStub.wrappedMethod.call(settingsCache, key, options);
});
});
afterEach(async function () {
sinon.restore();
});
it('Can comment on a post', async function () {
const {body} = await membersAgent
.post(`/api/comments/`)
.body({comments: [{
post_id: postId,
html: '<p>This is a <strong>message</strong></p><p>New line</p>'
}]})
.expectStatus(405);
});
});
describe('when authenticated', function () {
before(async function () {
await membersAgent.loginAs('member@example.com');
member = await models.Member.findOne({email: 'member@example.com'}, {require: true});
await membersAgent2.loginAs('member2@example.com');
});
beforeEach(function () {
const getStub = sinon.stub(settingsCache, 'get');
getStub.callsFake((key, options) => {
if (key === 'comments_enabled') {
return 'all';
}
return getStub.wrappedMethod.call(settingsCache, key, options);
});
});
afterEach(async function () {
sinon.restore();
});
it('Can comment on a post', async function () {
await models.Member.edit({last_seen_at: null, last_commented_at: null}, {id: member.get('id')});
const {body} = await membersAgent
.post(`/api/comments/`)
.body({comments: [{
post_id: postId,
html: '<div></div><p></p><p>This is a <strong>message</strong></p><p></p><p></p><p>New line</p><p></p>'
}]})
.expectStatus(201)
.matchHeaderSnapshot({
etag: anyEtag,
location: anyLocationFor('comments')
})
.matchBodySnapshot({
comments: [commentMatcherNoMember]
});
// Save for other tests
commentId = body.comments[0].id;
// Check if author got an email
mockManager.assert.sentEmailCount(1);
mockManager.assert.sentEmail({
subject: '💬 New comment on your post: ' + postTitle,
to: fixtureManager.get('users', 0).email,
// Note that the <strong> tag is removed by the sanitizer
html: new RegExp(escapeRegExp('<p>This is a message</p><p></p><p>New line</p>'))
});
// Wait for the dispatched events (because this happens async)
await sleep(200);
// Check last_updated_at changed?
member = await models.Member.findOne({id: member.id});
should.notEqual(member.get('last_seen_at'), null, 'The member should have a `last_seen_at` property after posting a comment.');
// Check last_commented_at changed?
should.notEqual(member.get('last_commented_at'), null, 'The member should have a `last_commented_at` property after posting a comment.');
});
it('Can browse all comments of a post', async function () {
const {body} = await membersAgent
.get(`/api/comments/?filter=post_id:${postId}`)
.expectStatus(200)
.matchHeaderSnapshot({
etag: anyEtag
})
.matchBodySnapshot({
comments: [commentMatcherWithReply, commentMatcher]
});
});
it('Can reply to your own comment', async function () {
// Should not update last_seen_at or last_commented_at when both are already set to a value on the same day
const timezone = settingsCache.get('timezone');
const date = moment.utc(new Date()).tz(timezone).startOf('day').toDate();
await models.Member.edit({last_seen_at: date, last_commented_at: date}, {id: member.get('id')});
const {body} = await membersAgent
.post(`/api/comments/`)
.body({comments: [{
post_id: postId,
parent_id: commentId,
html: 'This is a reply'
}]})
.expectStatus(201)
.matchHeaderSnapshot({
etag: anyEtag,
location: anyLocationFor('comments')
})
.matchBodySnapshot({
comments: [commentMatcherNoMember]
});
// Check only the author got an email (because we are the author of this parent comment)
mockManager.assert.sentEmailCount(1);
mockManager.assert.sentEmail({
subject: '💬 New comment on your post: ' + postTitle,
to: fixtureManager.get('users', 0).email
});
// Wait for the dispatched events (because this happens async)
await sleep(200);
// Check last updated_at is not changed?
member = await models.Member.findOne({id: member.id});
should.equal(member.get('last_seen_at').getTime(), date.getTime(), 'The member should not update `last_seen_at` if last seen at is same day');
// Check last_commented_at changed?
should.equal(member.get('last_commented_at').getTime(), date.getTime(), 'The member should not update `last_commented_at` f last seen at is same day');
});
it('Can reply to a comment', async function () {
const date = new Date(0);
await models.Member.edit({last_seen_at: date, last_commented_at: date}, {id: member.get('id')});
const {body} = await membersAgent
.post(`/api/comments/`)
.body({comments: [{
post_id: postId,
parent_id: fixtureManager.get('comments', 0).id,
html: 'This is a reply'
}]})
.expectStatus(201)
.matchHeaderSnapshot({
etag: anyEtag,
location: anyLocationFor('comments')
})
.matchBodySnapshot({
comments: [commentMatcherNoMember]
});
mockManager.assert.sentEmailCount(2);
mockManager.assert.sentEmail({
subject: '💬 New comment on your post: ' + postTitle,
to: fixtureManager.get('users', 0).email
});
mockManager.assert.sentEmail({
subject: '↪️ New reply to your comment on Ghost',
to: fixtureManager.get('members', 0).email
});
// Wait for the dispatched events (because this happens async)
await sleep(250);
// Check last_updated_at changed?
member = await models.Member.findOne({id: member.id});
should.notEqual(member.get('last_seen_at').getTime(), date.getTime(), 'Should update `last_seen_at` property after posting a comment.');
// Check last_commented_at changed?
should.notEqual(member.get('last_commented_at').getTime(), date.getTime(), 'Should update `last_commented_at` property after posting a comment.');
});
it('Can like a comment', async function () {
// Check not liked
await membersAgent
.get(`/api/comments/${commentId}/`)
.expectStatus(200)
.matchHeaderSnapshot({
etag: anyEtag
})
.matchBodySnapshot({
comments: new Array(1).fill(commentMatcherWithReply)
})
.expect(({body}) => {
body.comments[0].liked.should.eql(false);
});
// Create a temporary comment
await membersAgent
.post(`/api/comments/${commentId}/like/`)
.expectStatus(204)
.matchHeaderSnapshot({
etag: anyEtag
})
.expectEmptyBody();
// Check liked
await membersAgent
.get(`/api/comments/${commentId}/`)
.expectStatus(200)
.matchHeaderSnapshot({
etag: anyEtag
})
.matchBodySnapshot({
comments: new Array(1).fill(commentMatcherWithReply)
})
.expect(({body}) => {
body.comments[0].liked.should.eql(true);
});
});
it('Cannot like a comment multiple times', async function () {
// Create a temporary comment
await membersAgent
.post(`/api/comments/${commentId}/like/`)
.expectStatus(400)
.matchHeaderSnapshot({
etag: anyEtag
})
.matchBodySnapshot({
errors: [{
id: anyUuid
}]
});
});
it('Can remove a like', async function () {
// Create a temporary comment
await membersAgent
.delete(`/api/comments/${commentId}/like/`)
.expectStatus(204)
.matchHeaderSnapshot({
etag: anyEtag
})
.expectEmptyBody();
// Check liked
await membersAgent
.get(`/api/comments/${commentId}/`)
.expectStatus(200)
.matchHeaderSnapshot({
etag: anyEtag
})
.matchBodySnapshot({
comments: new Array(1).fill(commentMatcherWithReply)
})
.expect(({body}) => {
body.comments[0].liked.should.eql(false);
});
});
it('Can report a comment', async function () {
// Create a temporary comment
await membersAgent
.post(`/api/comments/${commentId}/report/`)
.expectStatus(204)
.matchHeaderSnapshot({
etag: anyEtag
})
.expectEmptyBody();
// Check report
const reports = await models.CommentReport.findAll({filter: 'comment_id:' + commentId});
reports.models.length.should.eql(1);
const report = reports.models[0];
report.get('member_id').should.eql(member.id);
mockManager.assert.sentEmail({
subject: '🚩 A comment has been reported on your post',
to: fixtureManager.get('users', 0).email,
html: new RegExp(escapeRegExp('<p>This is a message</p><p></p><p>New line</p>')),
text: new RegExp(escapeRegExp('This is a message\n\nNew line'))
});
});
it('Cannot report a comment twice', async function () {
// Create a temporary comment
await membersAgent
.post(`/api/comments/${commentId}/report/`)
.expectStatus(204)
.matchHeaderSnapshot({
etag: anyEtag
})
.expectEmptyBody();
// Check report should be the same (no extra created)
const reports = await models.CommentReport.findAll({filter: 'comment_id:' + commentId});
reports.models.length.should.eql(1);
const report = reports.models[0];
report.get('member_id').should.eql(member.id);
mockManager.assert.sentEmailCount(0);
});
it('Can edit a comment on a post', async function () {
const {body} = await await membersAgent
.put(`/api/comments/${commentId}`)
.body({comments: [{
html: 'Updated comment'
}]})
.expectStatus(200)
.matchHeaderSnapshot({
etag: anyEtag
})
.matchBodySnapshot({
comments: [{
...commentMatcherWithReply,
edited_at: anyISODateTime
}]
});
assert(body.comments[0].edited_at, 'The edited_at field should be populated');
});
it('Can not edit a comment post_id', async function () {
const anotherPostId = fixtureManager.get('posts', 1).id;
await membersAgent
.put(`/api/comments/${commentId}`)
.body({comments: [{
post_id: anotherPostId
}]});
const {body} = await membersAgent
.get(`/api/comments/?filter=post_id:${anotherPostId}`);
assert(!body.comments.find(comment => comment.id === commentId), 'The comment should not have moved post');
});
it('Can not edit a comment which does not belong to you', async function () {
await membersAgent2
.put(`/api/comments/${commentId}`)
.body({comments: [{
html: 'Illegal comment update'
}]})
.expectStatus(403)
.matchHeaderSnapshot({
etag: anyEtag
})
.matchBodySnapshot({
errors: [{
type: 'NoPermissionError',
id: anyUuid
}]
});
});
it('Can not edit a comment as a member who is not you', async function () {
const memberId = fixtureManager.get('members', 1).id;
await membersAgent
.put(`/api/comments/${commentId}`)
.body({comments: [{
html: 'Illegal comment update',
member_id: memberId
}]});
const {
body: {
comments: [
comment
]
}
} = await membersAgent.get(`/api/comments/${commentId}`)
.expectStatus(200)
.matchHeaderSnapshot({
etag: anyEtag
})
.matchBodySnapshot({
comments: [{
...commentMatcherWithReply,
edited_at: anyISODateTime
}]
});
assert(comment.member.id !== memberId);
});
it('Can not reply to a reply', async function () {
const {
body: {
comments: [{
id: parentId
}]
}
} = await membersAgent
.post(`/api/comments/`)
.body({comments: [{
post_id: postId,
html: 'Parent'
}]});
const {
body: {
comments: [{
id: replyId
}]
}
} = await membersAgent
.post(`/api/comments/`)
.body({comments: [{
post_id: postId,
parent_id: parentId,
html: 'Reply'
}]});
await membersAgent
.post(`/api/comments/`)
.body({comments: [{
post_id: postId,
parent_id: replyId,
html: 'Reply to a reply!'
}]})
.expectStatus(400)
.matchHeaderSnapshot({
etag: anyEtag
})
.matchBodySnapshot({
errors: [{
type: 'BadRequestError',
id: anyUuid
}]
});
});
it('Can not edit a replies parent', async function () {
const {
body: {
comments: [{
id: parentId
}]
}
} = await membersAgent
.post(`/api/comments/`)
.body({comments: [{
post_id: postId,
html: 'Parent'
}]});
const {
body: {
comments: [{
id: newParentId
}]
}
} = await membersAgent
.post(`/api/comments/`)
.body({comments: [{
post_id: postId,
html: 'New Parent'
}]});
const {
body: {
comments: [{
id: replyId
}]
}
} = await membersAgent
.post(`/api/comments/`)
.body({comments: [{
post_id: postId,
parent_id: parentId,
html: 'Reply'
}]});
// Attempt to edit the parent
await membersAgent
.put(`/api/comments/${replyId}/`)
.body({comments: [{
parent_id: newParentId,
html: 'Changed parent'
}]});
const {body: {comments: [comment]}} = await membersAgent.get(`api/comments/${newParentId}`);
assert(comment.replies.length === 0, 'The parent comment should not have changed');
});
it('Can fetch counts', async function () {
await membersAgent
.post(`api/comments/counts`)
.body({
ids: [
postId = fixtureManager.get('posts', 0).id,
postId = fixtureManager.get('posts', 1).id,
postId = fixtureManager.get('posts', 2).id
]
})
.expectStatus(200)
.matchHeaderSnapshot({
etag: anyEtag
})
.matchBodySnapshot();
});
});
});