Skip to content

Node.js based forum software built for the modern web

6.6 KB
Raw Blame
'use strict';

const assert = require('assert');

const db = require('../mocks/databasemock');
const User = require('../../src/user');
const socketUser = require('../../src/socket.io/user');
const utils = require('../../src/utils');

describe('user blocking methods', () => {
	let blockeeUid;
	let blockerUid;
	before(async () => {
		blockeeUid = String(await User.create({
			username: 'blockee',
			email: '[email protected]',
			fullname: 'Block me',
		}));
		blockerUid = String(await User.create({
			username: 'blocker',
			email: '[email protected]',
			fullname: 'Blocker',
		}));
	});

	describe('.toggle()', () => {
		it('should toggle block', async () => {
			await socketUser.toggleBlock({ uid: blockerUid }, { blockerUid, blockeeUid, action: 'block' });
			const blocked = await User.blocks.is(blockeeUid, blockerUid);
			assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${blockerUid}:blocked_uids`, 0, -1), [blockeeUid]);
			assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${blockeeUid}:blocker_uids`, 0, -1), [blockerUid]);
			assert(blocked);
		});


		it('should toggle block', async () => {
			await socketUser.toggleBlock({ uid: blockerUid }, { blockerUid, blockeeUid, action: 'unblock' });
			const blocked = await User.blocks.is(blockeeUid, blockerUid);
			assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${blockerUid}:blocked_uids`, 0, -1), []);
			assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${blockeeUid}:blocker_uids`, 0, -1), []);
			assert(!blocked);
		});
	});

	describe('.add()', () => {
		it('should block a uid', (done) => {
			User.blocks.add(blockeeUid, blockerUid, (err) => {
				assert.ifError(err);
				User.blocks.list(blockerUid, (err, blocked_uids) => {
					assert.ifError(err);
					assert.strictEqual(Array.isArray(blocked_uids), true);
					assert.strictEqual(blocked_uids.length, 1);
					assert.strictEqual(blocked_uids.includes(blockeeUid), true);
					done();
				});
			});
		});

		it('should automatically increment corresponding user field', (done) => {
			db.getObjectField(`user:${blockerUid}`, 'blocksCount', (err, count) => {
				assert.ifError(err);
				assert.strictEqual(parseInt(count, 10), 1);
				done();
			});
		});

		it('should error if you try to block the same uid again', (done) => {
			User.blocks.add(blockeeUid, blockerUid, (err) => {
				assert.equal(err.message, '[[error:already-blocked]]');
				done();
			});
		});
	});

	it('should clean up blocker/blocked sets when blocked user is deleted', async () => {
		const deleteUid = String(await User.create({ username: utils.generateUUID().slice(0, 6) }));
		const blockerUid = String(await User.create({ username: utils.generateUUID().slice(0, 6) }));
		await User.blocks.add(deleteUid, blockerUid);
		assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${blockerUid}:blocked_uids`, 0, -1), [deleteUid]);
		assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${deleteUid}:blocker_uids`, 0, -1), [blockerUid]);
		await User.deleteAccount(deleteUid);
		assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${blockerUid}:blocked_uids`, 0, -1), []);
		assert.deepStrictEqual(await db.getSortedSetRevRange(`uid:${deleteUid}:blocker_uids`, 0, -1), []);
	});

	describe('.remove()', () => {
		it('should unblock a uid', (done) => {
			User.blocks.remove(blockeeUid, blockerUid, (err) => {
				assert.ifError(err);
				User.blocks.list(blockerUid, (err, blocked_uids) => {
					assert.ifError(err);
					assert.strictEqual(Array.isArray(blocked_uids), true);
					assert.strictEqual(blocked_uids.length, 0);
					done();
				});
			});
		});

		it('should automatically decrement corresponding user field', (done) => {
			db.getObjectField(`user:${blockerUid}`, 'blocksCount', (err, count) => {
				assert.ifError(err);
				assert.strictEqual(parseInt(count, 10), 0);
				done();
			});
		});

		it('should error if you try to unblock the same uid again', (done) => {
			User.blocks.remove(blockeeUid, blockerUid, (err) => {
				assert.equal(err.message, '[[error:already-unblocked]]');
				done();
			});
		});
	});

	describe('.is()', () => {
		before((done) => {
			User.blocks.add(blockeeUid, blockerUid, done);
		});

		it('should return a Boolean with blocked status for the queried uid', (done) => {
			User.blocks.is(blockeeUid, blockerUid, (err, blocked) => {
				assert.ifError(err);
				assert.strictEqual(blocked, true);
				done();
			});
		});
	});

	describe('.list()', () => {
		it('should return a list of blocked uids', (done) => {
			User.blocks.list(blockerUid, (err, blocked_uids) => {
				assert.ifError(err);
				assert.strictEqual(Array.isArray(blocked_uids), true);
				assert.strictEqual(blocked_uids.length, 1);
				assert.strictEqual(blocked_uids.includes(blockeeUid), true);
				done();
			});
		});
	});

	describe('.filter()', () => {
		it('should remove entries by blocked uids and return filtered set', (done) => {
			User.blocks.filter(blockerUid, [{
				foo: 'foo',
				uid: blockeeUid,
			}, {
				foo: 'bar',
				uid: blockerUid,
			}, {
				foo: 'baz',
				uid: blockeeUid,
			}], (err, filtered) => {
				assert.ifError(err);
				assert.strictEqual(Array.isArray(filtered), true);
				assert.strictEqual(filtered.length, 1);
				assert.equal(filtered[0].uid, blockerUid);
				done();
			});
		});

		it('should allow property argument to be passed in to customise checked property', (done) => {
			User.blocks.filter(blockerUid, 'fromuid', [{
				foo: 'foo',
				fromuid: blockeeUid,
			}, {
				foo: 'bar',
				fromuid: blockerUid,
			}, {
				foo: 'baz',
				fromuid: blockeeUid,
			}], (err, filtered) => {
				assert.ifError(err);
				assert.strictEqual(Array.isArray(filtered), true);
				assert.strictEqual(filtered.length, 1);
				assert.equal(filtered[0].fromuid, blockerUid);
				done();
			});
		});

		it('should not process invalid sets', (done) => {
			User.blocks.filter(blockerUid, [{ foo: 'foo' }, { foo: 'bar' }, { foo: 'baz' }], (err, filtered) => {
				assert.ifError(err);
				assert.strictEqual(Array.isArray(filtered), true);
				assert.strictEqual(filtered.length, 3);
				filtered.forEach((obj) => {
					assert.strictEqual(obj.hasOwnProperty('foo'), true);
				});
				done();
			});
		});

		it('should process plain sets that just contain uids', (done) => {
			User.blocks.filter(blockerUid, [blockerUid, blockeeUid], (err, filtered) => {
				assert.ifError(err);
				assert.strictEqual(filtered.length, 1);
				assert.strictEqual(filtered[0], blockerUid);
				done();
			});
		});

		it('should filter uids that are blocking targetUid', (done) => {
			User.blocks.filterUids(blockeeUid, [blockerUid, blockeeUid], (err, filtered) => {
				assert.ifError(err);
				assert.deepEqual(filtered, [blockeeUid]);
				done();
			});
		});
	});
});