feat(topic-events): server-side tests for topic events

src/topics/events.js

@@ -60,9 +60,10 @@ Events.get = async (tid) => {
 		throw new Error('[[error:no-topic]]');
 	}
 
-	const eventIds = await db.getSortedSetRangeWithScores(`topic:${tid}:events`, 0, -1);
+	let eventIds = await db.getSortedSetRangeWithScores(`topic:${tid}:events`, 0, -1);
 	const keys = eventIds.map(obj => `topicEvent:${obj.value}`);
 	const timestamps = eventIds.map(obj => obj.score);
+	eventIds = eventIds.map(obj => obj.value);
 	let events = await db.getObjects(keys);
 	events = await modifyEvent({ eventIds, timestamps, events });
 
@@ -88,7 +89,7 @@ async function modifyEvent({ eventIds, timestamps, events }) {
 
 	// Add user & metadata
 	events.forEach((event, idx) => {
-		event.id = parseInt(eventIds[idx].value, 10);
+		event.id = parseInt(eventIds[idx], 10);
 		event.timestamp = timestamps[idx];
 		event.timestampISO = new Date(timestamps[idx]).toISOString();
 		if (event.hasOwnProperty('uid')) {
@@ -136,5 +137,5 @@ Events.purge = async (tid) => {
 	const eventIds = await db.getSortedSetRange(keys[0], 0, -1);
 	keys.push(...eventIds.map(id => `topicEvent:${id}`));
 
-	db.deleteAll(keys);
+	await db.deleteAll(keys);
 };

test/topicEvents.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const assert = require('assert');
+
+var db = require('./mocks/databasemock');
+
+const plugins = require('../src/plugins');
+const categories = require('../src/categories');
+const topics = require('../src/topics');
+const user = require('../src/user');
+
+describe('Topic Events', () => {
+	let fooUid;
+	let topic;
+	before(async () => {
+		fooUid = await user.create({ username: 'foo', password: '123456' });
+
+		const categoryObj = await categories.create({
+			name: 'Test Category',
+			description: 'Test category created by testing script',
+		});
+		topic = await topics.post({
+			title: 'topic events testing',
+			content: 'foobar one two three',
+			uid: fooUid,
+			cid: 1,
+		});
+	});
+
+	describe('.init()', () => {
+		it('should allow a plugin to expose new event types', async () => {
+			await plugins.hooks.register('core', {
+				hook: 'filter:topicEvents.init',
+				method: async ({ types }) => {
+					types.foo = {
+						icon: 'bar',
+						text: 'baz',
+						quux: 'quux',
+					};
+
+					return { types };
+				},
+			});
+
+			await topics.events.init();
+
+			assert(topics.events._types.foo);
+		});
+
+		it('should do nothing if called a second time', async () => {
+			await plugins.hooks.register('core', {
+				hook: 'filter:topicEvents.init',
+				method: async ({ types }) => {
+					types.bar = {
+						icon: 'bar',
+						text: 'baz',
+						quux: 'quux',
+					};
+
+					return { types };
+				},
+			});
+
+			await topics.events.init();
+			assert(!topics.events._types.bar);	// bar is explicitly not available
+		});
+	});
+
+	describe('.log()', () => {
+		it('should log and return a set of new events in the topic', async () => {
+			const events = await topics.events.log(topic.topicData.tid, {
+				type: 'foo',
+			});
+
+			assert(events);
+			assert(Array.isArray(events));
+			events.forEach((event) => {
+				assert(['id', 'icon', 'text', 'timestamp', 'timestampISO', 'type', 'quux'].every(key => event.hasOwnProperty(key)));
+			});
+		});
+	});
+
+	describe('.get()', () => {
+		it('should get a topic\'s events', async () => {
+			const events = await topics.events.get(topic.topicData.tid);
+
+			assert(events);
+			assert(Array.isArray(events));
+			assert.strictEqual(events.length, 1);
+			events.forEach((event) => {
+				assert(['id', 'icon', 'text', 'timestamp', 'timestampISO', 'type', 'quux'].every(key => event.hasOwnProperty(key)));
+			});
+		});
+	});
+
+	describe('.purge()', () => {
+		let eventIds;
+
+		before(async () => {
+			const events = await topics.events.get(topic.topicData.tid);
+			eventIds = events.map(event => event.id);
+		});
+
+		it('should purge topic\'s events from the database', async () => {
+			await topics.events.purge(topic.topicData.tid);
+
+			const keys = [`topic:${topic.topicData.tid}:events`];
+			keys.push(...eventIds.map(id => `topicEvent:${id}`));
+
+			const exists = await Promise.all(keys.map(key => db.exists(key)));
+			assert(exists.every(exists => !exists));
+		});
+	});
+});