Node.js based forum software built for the modern web
'use strict';
const assert = require('assert');
const nconf = require('nconf');
const db = require('../mocks/databasemock');
const controllers = require('../../src/controllers');
const middleware = require('../../src/middleware');
const activitypub = require('../../src/activitypub');
const utils = require('../../src/utils');
const user = require('../../src/user');
const categories = require('../../src/categories');
const topics = require('../../src/topics');
const posts = require('../../src/posts');
const privileges = require('../../src/privileges');
describe('Outbox', () => {
let uid;
let cid;
let pid;
let resBody;
before(async () => {
nconf.set('runJobs', 1);
});
after(async () => {
nconf.set('runJobs', undefined);
});
beforeEach(async () => {
uid = await user.create({ username: utils.generateUUID().slice(0, 8) });
({ cid } = await categories.create({ name: utils.generateUUID().slice(0, 8) }));
const { postData } = await topics.post({
uid,
cid,
title: utils.generateUUID(),
content: utils.generateUUID(),
});
pid = postData.pid;
});
afterEach(async () => {
resBody = null;
});
const collectResponse = (body) => {
resBody = body;
return {
status: (code) => ({ json: (b) => collectResponse(b) }),
};
};
describe('getOutbox', () => {
it('should return something for an existing user with posts', async () => {
const req = { params: { uid }, query: {} };
const res = collectResponse();
await controllers.activitypub.getOutbox(req, res);
assert(resBody);
assert(resBody.orderedItems);
assert(resBody.orderedItems.length > 0);
});
it('should return in the expected ActivityPub format', async () => {
const req = { params: { uid }, query: {} };
const res = collectResponse();
await controllers.activitypub.getOutbox(req, res);
assert.strictEqual(resBody['@context'], 'https://www.w3.org/ns/activitystreams');
assert.strictEqual(resBody.type, 'OrderedCollection');
assert.strictEqual(resBody.id, `${nconf.get('url')}/uid/${uid}/outbox`);
assert.strictEqual(resBody.totalItems, 1);
assert(Array.isArray(resBody.orderedItems));
assert.strictEqual(resBody.orderedItems.length, 1);
const activity = resBody.orderedItems[0];
assert.strictEqual(activity.type, 'Create');
assert(['Note', 'Article'].includes(activity.object.type));
assert.strictEqual(activity.actor, `${nconf.get('url')}/uid/${uid}`);
assert.strictEqual(activity.object.url, `${nconf.get('url')}/post/${pid}`);
});
it('should not return anything for a non-existent user via middleware assertion', async () => {
const nonExistentUid = '999999999';
const userExists = await user.exists(nonExistentUid);
assert(!userExists, 'User should not exist');
const req = { params: { uid: nonExistentUid }, query: {} };
let capturedCode;
const res = {
locals: {},
req: { method: 'GET' },
status: (code) => {
capturedCode = code;
return {
json: () => res,
};
},
};
await middleware.assert.user(req, res, () => {});
assert.strictEqual(capturedCode, 404);
});
it('should return an empty collection for a user with no activities', async () => {
const emptyUid = await user.create({ username: utils.generateUUID().slice(0, 8) });
const req = { params: { uid: emptyUid }, query: {} };
const res = collectResponse();
await controllers.activitypub.getOutbox(req, res);
assert(resBody);
assert.strictEqual(resBody.type, 'OrderedCollection');
assert.strictEqual(resBody.totalItems, 0);
assert(Array.isArray(resBody.orderedItems));
assert.strictEqual(resBody.orderedItems.length, 0);
});
it('should include upvote and downvote activities when present', async () => {
// Create another user's post to upvote (can't upvote own post)
const otherUid = await user.create({ username: utils.generateUUID().slice(0, 8) });
const { postData: otherPost } = await topics.post({
uid: otherUid,
cid,
title: utils.generateUUID(),
content: utils.generateUUID(),
});
// Upvote the other user's post
await posts.upvote(otherPost.pid, uid);
// Downvote another post
const { postData: secondPost } = await topics.post({
uid: otherUid,
cid,
title: utils.generateUUID(),
content: utils.generateUUID(),
});
await posts.downvote(secondPost.pid, uid);
const req = { params: { uid }, query: {} };
const res = collectResponse();
await controllers.activitypub.getOutbox(req, res);
assert(resBody.orderedItems.length >= 3);
const types = resBody.orderedItems.map((a) => a.type);
assert(types.includes('Create'));
const upvoteActivities = resBody.orderedItems.filter(
(a) => a.type === 'Like' && typeof a.object === 'string'
);
assert(upvoteActivities.length >= 1);
const dislikeActivities = resBody.orderedItems.filter(
(a) => a.type === 'Dislike' && typeof a.object === 'string'
);
assert(dislikeActivities.length >= 1);
});
it('should paginate when there are more than 20 items', async () => {
// Create 25 posts
for (let i = 0; i < 25; i++) {
// eslint-disable-next-line no-await-in-loop
await topics.post({
uid,
cid,
title: utils.generateUUID(),
content: utils.generateUUID(),
});
}
const req = { params: { uid }, query: {} };
const res = collectResponse();
await controllers.activitypub.getOutbox(req, res);
assert.strictEqual(resBody.type, 'OrderedCollectionPage');
assert.strictEqual(resBody.totalItems, 26);
assert(resBody.orderedItems.length <= 20);
assert(resBody.first);
assert(resBody.last);
assert(resBody.partOf);
});
it('should not expose posts from private categories', async () => {
const privateMarker = 'PRIVATE-' + utils.generateUUID();
// Create a private category
const { cid: privateCid } = await categories.create({ name: utils.generateUUID() });
// Rescind read and topics:read from all public-facing groups
for (const group of ['guests', 'spiders', 'registered-users', 'fediverse']) {
// eslint-disable-next-line no-await-in-loop
await privileges.categories.rescind(['groups:read', 'groups:topics:read'], privateCid, group);
}
// Create a post in the private category with a unique marker
const { postData } = await topics.post({
uid,
cid: privateCid,
title: utils.generateUUID(),
content: privateMarker,
});
const privatePid = postData.pid;
// Confirm the safe post-set reader also filters this post
const summaries = await posts.getPostSummariesFromSet(`uid:${uid}:posts`, 0, 0, 100);
const visiblePids = summaries.posts.map(p => p.pid);
assert(!visiblePids.includes(privatePid), 'getPostSummariesFromSet should filter private posts');
// Call the outbox controller directly
const req = { params: { uid }, query: {} };
const res = collectResponse();
await controllers.activitypub.getOutbox(req, res);
// The private marker must not appear anywhere in the response
const responseStr = JSON.stringify(resBody);
assert(!responseStr.includes(privateMarker), 'Outbox must not contain private category post content');
// Verify the private post's pid is not referenced in any activity object
const privatePostUrl = `/post/${privatePid}`;
for (const activity of resBody.orderedItems) {
const activityStr = JSON.stringify(activity);
assert(!activityStr.includes(privatePostUrl), `Outbox must not reference private post ${privatePid}`);
}
});
});
});