Skip to content

Node.js based forum software built for the modern web

test: activitypub third-party blocklists

Julian Lam30774a842416
diff --git a/.gitignore b/.gitignore
index 42a1b3c705..f9c0818254 100644
--- a/.gitignore
+++ b/.gitignore
@@ -72,4 +72,5 @@ link-plugins.sh
test.sh
.docker/**
-!**/.gitkeep
\ No newline at end of file
+!**/.gitkeep
+.aider*
diff --git a/src/activitypub/blocklists.js b/src/activitypub/blocklists.js
index 86424d7856..042ce2cfc5 100644
--- a/src/activitypub/blocklists.js
+++ b/src/activitypub/blocklists.js
@@ -6,9 +6,9 @@ const db = require('../database');
const request = require('../request');
const activitypub = module.parent.exports;
-const Blocklists = module.exports;
+const blocklists = module.exports;
-Blocklists.list = async () => {
+blocklists.list = async () => {
const blocklists = await db.getSortedSetMembers('blocklists');
const counts = await db.sortedSetsCard(blocklists.map(blocklist => `blocklist:${blocklist}`));
@@ -17,7 +17,7 @@ Blocklists.list = async () => {
});
};
-Blocklists.get = async (url) => {
+blocklists.get = async (url) => {
const domains = await db.getSortedSetMembers(`blocklist:${url}`);
return {
@@ -26,23 +26,23 @@ Blocklists.get = async (url) => {
};
};
-Blocklists.add = async (url) => {
+blocklists.add = async (url) => {
const now = Date.now();
await Promise.all([
db.sortedSetAdd('blocklists', now, url),
- Blocklists.refresh(url),
+ blocklists.refresh(url),
]);
};
-Blocklists.remove = async (url) => {
+blocklists.remove = async (url) => {
await Promise.all([
db.sortedSetRemove('blocklists', url),
db.delete(`blocklist:${url}`),
]);
};
-Blocklists.refresh = async (url) => {
+blocklists.refresh = async (url) => {
activitypub.helpers.log(`[blocklists/refresh] Processing ${url}`);
const { body: csv } = await request.get(url);
@@ -69,10 +69,10 @@ Blocklists.refresh = async (url) => {
return records.length;
};
-Blocklists.check = async (domain) => {
- const blocklists = await Blocklists.list();
+blocklists.check = async (domain) => {
+ const blocklists = await blocklists.list();
let present = await db.isMemberOfSortedSets(blocklists.map(({ url }) => `blocklist:${url}`), domain);
present = present.reduce((memo, present) => memo || present, false);
return !present;
-};
\ No newline at end of file
+};
diff --git a/test/activitypub/blocklists.js b/test/activitypub/blocklists.js
new file mode 100644
index 0000000000..33408df8c7
--- /dev/null
+++ b/test/activitypub/blocklists.js
@@ -0,0 +1,303 @@
+'use strict';
+
+const assert = require('assert');
+const nconf = require('nconf');
+const path = require('path');
+
+const db = require('../mocks/databasemock');
+const request = require('../../src/request');
+const activitypub = require('../../src/activitypub');
+
+describe('ActivityPub blocklists', () => {
+ before(async () => {
+ meta.config.activitypubEnabled = 1;
+ meta.config.activitypubAllowLoopback = 1;
+ await install.giveWorldPrivileges();
+ });
+
+ after(() => {
+ delete meta.config.activitypubEnabled;
+ });
+
+ describe('blocklists.list()', () => {
+ it('should return an empty list when no blocklists exist', async () => {
+ const result = await activitypub.blocklists.list();
+ assert(Array.isArray(result));
+ assert.strictEqual(result.length, 0);
+ });
+
+ it('should return blocklists with their counts', async () => {
+ const url1 = 'https://example.com/blocklist1.csv';
+ const url2 = 'https://example.com/blocklist2.csv';
+
+ await activitypub.blocklists.add(url1);
+ await activitypub.blocklists.add(url2);
+
+ const result = await activitypub.blocklists.list();
+
+ assert.strictEqual(result.length, 2);
+ assert(result.some(r => r.url === url1));
+ assert(result.some(r => r.url === url2));
+ });
+
+ it('should return blocklists sorted by timestamp', async () => {
+ const url1 = 'https://example.com/blocklist1.csv';
+ const url2 = 'https://example.com/blocklist2.csv';
+
+ await activitypub.blocklists.add(url1);
+ await new Promise(resolve => setTimeout(resolve, 10));
+ await activitypub.blocklists.add(url2);
+
+ const result = await activitypub.blocklists.list();
+
+ assert.strictEqual(result[0].url, url1);
+ assert.strictEqual(result[1].url, url2);
+ });
+ });
+
+ describe('blocklists.get()', () => {
+ it('should return empty domains when blocklist does not exist', async () => {
+ const result = await activitypub.blocklists.get('https://nonexistent.com/blocklist.csv');
+ assert.strictEqual(result.domains.length, 0);
+ assert.strictEqual(result.count, 0);
+ });
+
+ it('should return domains from an existing blocklist', async () => {
+ const url = 'https://example.com/blocklist.csv';
+ await activitypub.blocklists.add(url);
+
+ const result = await activitypub.blocklists.get(url);
+
+ assert.strictEqual(result.count, 0);
+ assert.strictEqual(result.domains.length, 0);
+ });
+
+ it('should return domains after refresh', async () => {
+ const url = 'https://example.com/blocklist.csv';
+ await activitypub.blocklists.add(url);
+
+ // Mock the CSV data
+ const csvData = '#domain,#severity\nexample.com,1\nexample.org,1';
+ const mockResponse = { body: csvData };
+ request.get = () => mockResponse;
+
+ await activitypub.blocklists.refresh(url);
+
+ const result = await activitypub.blocklists.get(url);
+
+ assert.strictEqual(result.count, 2);
+ assert(result.domains.includes('example.com'));
+ assert(result.domains.includes('example.org'));
+ });
+ });
+
+ describe('blocklists.add()', () => {
+ it('should add a new blocklist', async () => {
+ const url = 'https://example.com/blocklist.csv';
+ await activitypub.blocklists.add(url);
+
+ const result = await activitypub.blocklists.list();
+ assert(result.some(r => r.url === url));
+ });
+
+ it('should refresh the blocklist after adding', async () => {
+ const url = 'https://example.com/blocklist.csv';
+ await activitypub.blocklists.add(url);
+
+ // Verify the blocklist was added and refreshed
+ const result = await activitypub.blocklists.get(url);
+ assert.strictEqual(result.count, 0); // Empty initially
+ });
+ });
+
+ describe('blocklists.remove()', () => {
+ it('should remove a blocklist', async () => {
+ const url = 'https://example.com/blocklist.csv';
+ await activitypub.blocklists.add(url);
+
+ await activitypub.blocklists.remove(url);
+
+ const result = await activitypub.blocklists.list();
+ assert(!result.some(r => r.url === url));
+ });
+
+ it('should delete the blocklist data', async () => {
+ const url = 'https://example.com/blocklist.csv';
+ await activitypub.blocklists.add(url);
+ await activitypub.blocklists.refresh(url);
+
+ await activitypub.blocklists.remove(url);
+
+ const result = await activitypub.blocklists.get(url);
+ assert.strictEqual(result.count, 0);
+ });
+ });
+
+ describe('blocklists.refresh()', () => {
+ it('should process a valid CSV', async () => {
+ const url = 'https://example.com/blocklist.csv';
+ await activitypub.blocklists.add(url);
+
+ const csvData = '#domain,#severity\nexample.com,1\nexample.org,2\nsilence.example.com,2';
+ const mockResponse = { body: csvData };
+ request.get = () => mockResponse;
+
+ const result = await activitypub.blocklists.refresh(url);
+
+ assert.strictEqual(result, 3);
+ });
+
+ it('should return 0 for empty CSV', async () => {
+ const url = 'https://example.com/blocklist.csv';
+ await activitypub.blocklists.add(url);
+
+ const csvData = '';
+ const mockResponse = { body: csvData };
+ request.get = () => mockResponse;
+
+ const result = await activitypub.blocklists.refresh(url);
+
+ assert.strictEqual(result, 0);
+ });
+
+ it('should return 0 on parse error', async () => {
+ const url = 'https://example.com/blocklist.csv';
+ await activitypub.blocklists.add(url);
+
+ const csvData = 'invalid,csv,data';
+ const mockResponse = { body: csvData };
+ request.get = () => mockResponse;
+
+ const result = await activitypub.blocklists.refresh(url);
+
+ assert.strictEqual(result, 0);
+ });
+
+ it('should handle severity levels correctly', async () => {
+ const url = 'https://example.com/blocklist.csv';
+ await activitypub.blocklists.add(url);
+
+ const csvData = '#domain,#severity\nexample.com,1\nsilence.example.com,2';
+ const mockResponse = { body: csvData };
+ request.get = () => mockResponse;
+
+ await activitypub.blocklists.refresh(url);
+
+ const result = await activitypub.blocklists.get(url);
+
+ assert.strictEqual(result.count, 2);
+ });
+ });
+
+ describe('blocklists.check()', () => {
+ it('should return true when domain is not blocked', async () => {
+ const url = 'https://example.com/blocklist.csv';
+ await activitypub.blocklists.add(url);
+
+ const result = await activitypub.blocklists.check('example.com');
+
+ assert.strictEqual(result, true);
+ });
+
+ it('should return false when domain is blocked', async () => {
+ const url = 'https://example.com/blocklist.csv';
+ await activitypub.blocklists.add(url);
+
+ const csvData = '#domain,#severity\nexample.com,1';
+ const mockResponse = { body: csvData };
+ request.get = () => mockResponse;
+
+ await activitypub.blocklists.refresh(url);
+
+ const result = await activitypub.blocklists.check('example.com');
+
+ assert.strictEqual(result, false);
+ });
+
+ it('should return true when domain is not in any blocklist', async () => {
+ const url1 = 'https://example.com/blocklist1.csv';
+ const url2 = 'https://example.com/blocklist2.csv';
+
+ await activitypub.blocklists.add(url1);
+ await activitypub.blocklists.add(url2);
+
+ const csvData1 = '#domain,#severity\nblocked.com,1';
+ const csvData2 = '#domain,#severity\nblocked.org,1';
+
+ const mockResponse1 = { body: csvData1 };
+ const mockResponse2 = { body: csvData2 };
+ request.get = () => mockResponse1;
+
+ await activitypub.blocklists.refresh(url1);
+
+ request.get = () => mockResponse2;
+ await activitypub.blocklists.refresh(url2);
+
+ const result = await activitypub.blocklists.check('example.com');
+
+ assert.strictEqual(result, true);
+ });
+
+ it('should return false when domain is in any blocklist', async () => {
+ const url1 = 'https://example.com/blocklist1.csv';
+ const url2 = 'https://example.com/blocklist2.csv';
+
+ await activitypub.blocklists.add(url1);
+ await activitypub.blocklists.add(url2);
+
+ const csvData1 = '#domain,#severity\nexample.com,1';
+ const csvData2 = '#domain,#severity\nblocked.org,1';
+
+ const mockResponse1 = { body: csvData1 };
+ const mockResponse2 = { body: csvData2 };
+ request.get = () => mockResponse1;
+
+ await activitypub.blocklists.refresh(url1);
+
+ request.get = () => mockResponse2;
+ await activitypub.blocklists.refresh(url2);
+
+ const result = await activitypub.blocklists.check('example.com');
+
+ assert.strictEqual(result, false);
+ });
+ });
+
+ describe('Integration tests', () => {
+ let url;
+
+ before(async () => {
+ url = 'https://example.com/blocklist.csv';
+ await activitypub.blocklists.add(url);
+ });
+
+ after(async () => {
+ await activitypub.blocklists.remove(url);
+ });
+
+ it('should handle full lifecycle of a blocklist', async () => {
+ // Add
+ await activitypub.blocklists.add(url);
+ const list = await activitypub.blocklists.list();
+ assert(list.some(r => r.url === url));
+
+ // Refresh with data
+ const csvData = '#domain,#severity\nblocked.com,1\nblocked.org,1';
+ const mockResponse = { body: csvData };
+ request.get = () => mockResponse;
+
+ await activitypub.blocklists.refresh(url);
+
+ // Check
+ assert.strictEqual(await activitypub.blocklists.check('blocked.com'), false);
+ assert.strictEqual(await activitypub.blocklists.check('allowed.com'), true);
+
+ // Remove
+ await activitypub.blocklists.remove(url);
+
+ // Verify removed
+ const listAfter = await activitypub.blocklists.list();
+ assert(!listAfter.some(r => r.url === url));
+ });
+ });
+});