2021-07-10 09:14:57 -05:00
|
|
|
process.env.NODE_ENV = 'test';
|
|
|
|
|
|
|
|
import * as assert from 'assert';
|
2023-02-19 00:27:14 -06:00
|
|
|
import { Test } from '@nestjs/testing';
|
|
|
|
import { jest } from '@jest/globals';
|
|
|
|
|
|
|
|
import { ApNoteService } from '@/core/activitypub/models/ApNoteService.js';
|
|
|
|
import { ApPersonService } from '@/core/activitypub/models/ApPersonService.js';
|
2023-03-11 21:11:37 -06:00
|
|
|
import { ApRendererService } from '@/core/activitypub/ApRendererService.js';
|
2023-02-19 00:27:14 -06:00
|
|
|
import { GlobalModule } from '@/GlobalModule.js';
|
|
|
|
import { CoreModule } from '@/core/CoreModule.js';
|
|
|
|
import { FederatedInstanceService } from '@/core/FederatedInstanceService.js';
|
|
|
|
import { LoggerService } from '@/core/LoggerService.js';
|
2023-07-04 20:38:59 -05:00
|
|
|
import type { IActor, ICreate, IObject, IOrderedCollection, IOrderedCollectionPage, IPost } from '@/core/activitypub/type.js';
|
2023-03-11 21:11:37 -06:00
|
|
|
import { Note } from '@/models/index.js';
|
2023-06-24 21:04:33 -05:00
|
|
|
import { secureRndstr } from '@/misc/secure-rndstr.js';
|
|
|
|
import { MockResolver } from '../misc/mock-resolver.js';
|
2021-07-10 09:14:57 -05:00
|
|
|
|
2023-02-19 02:49:18 -06:00
|
|
|
const host = 'https://host1.test';
|
|
|
|
|
2023-07-08 18:59:44 -05:00
|
|
|
type NonTransientIActor = IActor & { id: string };
|
|
|
|
type NonTransientIPost = IPost & { id: string };
|
|
|
|
|
|
|
|
function createRandomActor({ actorHost = host } = {}): NonTransientIActor {
|
2023-06-24 21:04:33 -05:00
|
|
|
const preferredUsername = secureRndstr(8);
|
2023-07-08 18:59:44 -05:00
|
|
|
const actorId = `${actorHost}/users/${preferredUsername.toLowerCase()}`;
|
2023-02-19 02:49:18 -06:00
|
|
|
|
|
|
|
return {
|
|
|
|
'@context': 'https://www.w3.org/ns/activitystreams',
|
|
|
|
id: actorId,
|
|
|
|
type: 'Person',
|
|
|
|
preferredUsername,
|
|
|
|
inbox: `${actorId}/inbox`,
|
|
|
|
outbox: `${actorId}/outbox`,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2023-07-08 18:59:44 -05:00
|
|
|
function createRandomNote(actor: NonTransientIActor): NonTransientIPost {
|
|
|
|
const id = secureRndstr(8);
|
|
|
|
const noteId = `${new URL(actor.id).origin}/notes/${id}`;
|
|
|
|
|
|
|
|
return {
|
|
|
|
id: noteId,
|
|
|
|
type: 'Note',
|
|
|
|
attributedTo: actor.id,
|
|
|
|
content: 'test test foo',
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
function createRandomNotes(actor: NonTransientIActor, length: number): NonTransientIPost[] {
|
|
|
|
return new Array(length).fill(null).map(() => createRandomNote(actor));
|
|
|
|
}
|
|
|
|
|
|
|
|
function createRandomFeaturedCollection(actor: NonTransientIActor, length: number): ICollection {
|
|
|
|
const items = createRandomNotes(actor, length);
|
|
|
|
|
|
|
|
return {
|
|
|
|
'@context': 'https://www.w3.org/ns/activitystreams',
|
|
|
|
type: 'Collection',
|
|
|
|
id: actor.outbox as string,
|
|
|
|
totalItems: items.length,
|
|
|
|
items,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2023-07-09 08:04:12 -05:00
|
|
|
function createRandomCreateActivity(actor: NonTransientIActor, length: number): ICreate[] {
|
2023-07-04 20:38:59 -05:00
|
|
|
return new Array(length).fill(null).map((): ICreate => {
|
2023-07-09 08:04:12 -05:00
|
|
|
const note = reateRandomNote(actor);
|
2023-07-04 20:38:59 -05:00
|
|
|
|
|
|
|
return {
|
|
|
|
type: 'Create',
|
2023-07-09 08:04:12 -05:00
|
|
|
id: `${note.id}/activity`,
|
2023-07-04 20:38:59 -05:00
|
|
|
actor,
|
2023-07-09 08:04:12 -05:00
|
|
|
object: note,
|
2023-07-04 20:38:59 -05:00
|
|
|
};
|
|
|
|
});
|
|
|
|
}
|
|
|
|
|
2023-07-09 08:04:12 -05:00
|
|
|
function createRandomNonPagedOutbox(actor: NonTransientIActor, length: number): IOrderedCollection {
|
2023-07-04 20:38:59 -05:00
|
|
|
const orderedItems = createRandomCreateActivity(actor, length);
|
|
|
|
|
|
|
|
return {
|
|
|
|
'@context': 'https://www.w3.org/ns/activitystreams',
|
|
|
|
type: 'OrderedCollection',
|
|
|
|
id: actor.outbox as string,
|
|
|
|
totalItems: orderedItems.length,
|
|
|
|
orderedItems,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2023-07-09 08:04:12 -05:00
|
|
|
function createRandomOutboxPage(actor: NonTransientIActor, id: string, length: number): IOrderedCollectionPage {
|
2023-07-04 20:38:59 -05:00
|
|
|
const orderedItems = createRandomCreateActivity(actor, length);
|
|
|
|
|
|
|
|
return {
|
|
|
|
'@context': 'https://www.w3.org/ns/activitystreams',
|
|
|
|
type: 'OrderedCollectionPage',
|
|
|
|
id,
|
|
|
|
totalItems: orderedItems.length,
|
|
|
|
orderedItems,
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2023-07-09 08:04:12 -05:00
|
|
|
function createRandomPagedOutbox(actor: NonTransientIActor): IOrderedCollection {
|
2023-07-04 20:38:59 -05:00
|
|
|
return {
|
|
|
|
'@context': 'https://www.w3.org/ns/activitystreams',
|
|
|
|
type: 'OrderedCollection',
|
|
|
|
id: actor.outbox as string,
|
|
|
|
totalItems: 10,
|
|
|
|
first: `${actor.outbox}?first`,
|
2023-07-09 08:04:12 -05:00
|
|
|
};
|
2023-07-04 20:38:59 -05:00
|
|
|
}
|
|
|
|
|
2021-07-10 09:14:57 -05:00
|
|
|
describe('ActivityPub', () => {
|
2023-02-19 00:27:14 -06:00
|
|
|
let noteService: ApNoteService;
|
|
|
|
let personService: ApPersonService;
|
2023-03-11 21:11:37 -06:00
|
|
|
let rendererService: ApRendererService;
|
2023-02-19 00:27:14 -06:00
|
|
|
let resolver: MockResolver;
|
|
|
|
|
2023-07-08 08:40:48 -05:00
|
|
|
beforeAll(async () => {
|
2023-02-19 00:27:14 -06:00
|
|
|
const app = await Test.createTestingModule({
|
|
|
|
imports: [GlobalModule, CoreModule],
|
|
|
|
}).compile();
|
|
|
|
|
|
|
|
await app.init();
|
|
|
|
app.enableShutdownHooks();
|
|
|
|
|
|
|
|
noteService = app.get<ApNoteService>(ApNoteService);
|
|
|
|
personService = app.get<ApPersonService>(ApPersonService);
|
2023-03-11 21:11:37 -06:00
|
|
|
rendererService = app.get<ApRendererService>(ApRendererService);
|
2023-02-19 00:27:14 -06:00
|
|
|
resolver = new MockResolver(await app.resolve<LoggerService>(LoggerService));
|
|
|
|
|
|
|
|
// Prevent ApPersonService from fetching instance, as it causes Jest import-after-test error
|
|
|
|
const federatedInstanceService = app.get<FederatedInstanceService>(FederatedInstanceService);
|
2023-07-04 20:38:59 -05:00
|
|
|
jest.spyOn(federatedInstanceService, 'fetch').mockImplementation(() => new Promise(() => { }));
|
2023-02-19 00:27:14 -06:00
|
|
|
});
|
|
|
|
|
2023-07-08 08:40:48 -05:00
|
|
|
beforeEach(() => {
|
|
|
|
resolver.clear();
|
|
|
|
});
|
|
|
|
|
2021-07-10 09:14:57 -05:00
|
|
|
describe('Parse minimum object', () => {
|
2023-02-19 02:49:18 -06:00
|
|
|
const actor = createRandomActor();
|
2021-07-10 09:14:57 -05:00
|
|
|
|
|
|
|
const post = {
|
|
|
|
'@context': 'https://www.w3.org/ns/activitystreams',
|
2023-06-24 21:04:33 -05:00
|
|
|
id: `${host}/users/${secureRndstr(8)}`,
|
2021-07-10 09:14:57 -05:00
|
|
|
type: 'Note',
|
|
|
|
attributedTo: actor.id,
|
|
|
|
to: 'https://www.w3.org/ns/activitystreams#Public',
|
|
|
|
content: 'あ',
|
|
|
|
};
|
|
|
|
|
2023-02-02 03:18:25 -06:00
|
|
|
test('Minimum Actor', async () => {
|
2023-07-08 18:59:44 -05:00
|
|
|
resolver.register(actor.id, actor);
|
2021-07-10 09:14:57 -05:00
|
|
|
|
2023-02-19 00:27:14 -06:00
|
|
|
const user = await personService.createPerson(actor.id, resolver);
|
2021-07-10 09:14:57 -05:00
|
|
|
|
|
|
|
assert.deepStrictEqual(user.uri, actor.id);
|
|
|
|
assert.deepStrictEqual(user.username, actor.preferredUsername);
|
|
|
|
assert.deepStrictEqual(user.inbox, actor.inbox);
|
|
|
|
});
|
|
|
|
|
2023-02-02 03:18:25 -06:00
|
|
|
test('Minimum Note', async () => {
|
2023-07-08 18:59:44 -05:00
|
|
|
resolver.register(actor.id, actor);
|
|
|
|
resolver.register(post.id, post);
|
2021-07-10 09:14:57 -05:00
|
|
|
|
2023-02-19 00:27:14 -06:00
|
|
|
const note = await noteService.createNote(post.id, resolver, true);
|
2021-07-10 09:14:57 -05:00
|
|
|
|
|
|
|
assert.deepStrictEqual(note?.uri, post.id);
|
2022-05-21 08:21:41 -05:00
|
|
|
assert.deepStrictEqual(note.visibility, 'public');
|
|
|
|
assert.deepStrictEqual(note.text, post.content);
|
2021-07-10 09:14:57 -05:00
|
|
|
});
|
|
|
|
});
|
2021-08-17 03:25:19 -05:00
|
|
|
|
2023-02-19 02:49:18 -06:00
|
|
|
describe('Name field', () => {
|
|
|
|
test('Truncate long name', async () => {
|
|
|
|
const actor = {
|
|
|
|
...createRandomActor(),
|
2023-06-24 21:04:33 -05:00
|
|
|
name: secureRndstr(129),
|
2023-02-19 02:49:18 -06:00
|
|
|
};
|
2021-08-17 03:25:19 -05:00
|
|
|
|
2023-07-08 18:59:44 -05:00
|
|
|
resolver.register(actor.id, actor);
|
2021-08-17 03:25:19 -05:00
|
|
|
|
2023-02-19 02:49:18 -06:00
|
|
|
const user = await personService.createPerson(actor.id, resolver);
|
|
|
|
|
|
|
|
assert.deepStrictEqual(user.name, actor.name.slice(0, 128));
|
|
|
|
});
|
|
|
|
|
|
|
|
test('Normalize empty name', async () => {
|
|
|
|
const actor = {
|
|
|
|
...createRandomActor(),
|
|
|
|
name: '',
|
|
|
|
};
|
2021-08-17 03:25:19 -05:00
|
|
|
|
2023-07-08 18:59:44 -05:00
|
|
|
resolver.register(actor.id, actor);
|
2021-08-17 03:25:19 -05:00
|
|
|
|
2023-02-19 00:27:14 -06:00
|
|
|
const user = await personService.createPerson(actor.id, resolver);
|
2021-08-17 03:25:19 -05:00
|
|
|
|
2023-02-19 02:49:18 -06:00
|
|
|
assert.strictEqual(user.name, null);
|
2021-08-17 03:25:19 -05:00
|
|
|
});
|
|
|
|
});
|
2023-03-11 21:11:37 -06:00
|
|
|
|
|
|
|
describe('Renderer', () => {
|
|
|
|
test('Render an announce with visibility: followers', () => {
|
|
|
|
rendererService.renderAnnounce(null, {
|
|
|
|
createdAt: new Date(0),
|
|
|
|
visibility: 'followers',
|
|
|
|
} as Note);
|
|
|
|
});
|
|
|
|
});
|
2023-07-04 20:38:59 -05:00
|
|
|
|
2023-07-08 18:59:44 -05:00
|
|
|
describe('Featured', () => {
|
|
|
|
test('Fetch featured notes from IActor', async () => {
|
|
|
|
const actor = createRandomActor();
|
|
|
|
actor.featured = `${actor.id}/collections/featured`;
|
|
|
|
|
|
|
|
const featured = createRandomFeaturedCollection(actor, 5);
|
|
|
|
|
|
|
|
resolver.register(actor.id, actor);
|
|
|
|
resolver.register(actor.featured, featured);
|
|
|
|
|
|
|
|
await personService.createPerson(actor.id, resolver);
|
|
|
|
|
|
|
|
// All notes in `featured` are same-origin, no need to fetch notes again
|
|
|
|
assert.deepStrictEqual(resolver.remoteGetTrials(), [actor.id, actor.featured]);
|
|
|
|
|
|
|
|
// Created notes without resolving anything
|
|
|
|
for (const item of featured.items as IPost[]) {
|
|
|
|
const note = await noteService.fetchNote(item);
|
|
|
|
assert.ok(note);
|
|
|
|
assert.strictEqual(note.text, 'test test foo');
|
|
|
|
assert.strictEqual(note.uri, item.id);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
test('Fetch featured notes from IActor pointing to another remote server', async () => {
|
|
|
|
const actor1 = createRandomActor();
|
|
|
|
actor1.featured = `${actor1.id}/collections/featured`;
|
|
|
|
const actor2 = createRandomActor({ actorHost: 'https://host2.test' });
|
|
|
|
|
|
|
|
const actor2Note = createRandomNote(actor2);
|
|
|
|
const featured = createRandomFeaturedCollection(actor1, 0);
|
|
|
|
(featured.items as IPost[]).push({
|
|
|
|
...actor2Note,
|
|
|
|
content: 'test test bar', // fraud!
|
|
|
|
});
|
|
|
|
|
|
|
|
resolver.register(actor1.id, actor1);
|
|
|
|
resolver.register(actor1.featured, featured);
|
|
|
|
resolver.register(actor2.id, actor2);
|
|
|
|
resolver.register(actor2Note.id, actor2Note);
|
|
|
|
|
|
|
|
await personService.createPerson(actor1.id, resolver);
|
|
|
|
|
|
|
|
// actor2Note is from a different server and needs to be fetched again
|
|
|
|
assert.deepStrictEqual(
|
|
|
|
resolver.remoteGetTrials(),
|
|
|
|
[actor1.id, actor1.featured, actor2Note.id, actor2.id],
|
|
|
|
);
|
|
|
|
|
|
|
|
const note = await noteService.fetchNote(actor2Note.id);
|
|
|
|
assert.ok(note);
|
|
|
|
|
|
|
|
// Reflects the original content instead of the fraud
|
|
|
|
assert.strictEqual(note.text, 'test test foo');
|
|
|
|
assert.strictEqual(note.uri, actor2Note.id);
|
|
|
|
});
|
2023-07-09 15:36:07 -05:00
|
|
|
});
|
2023-07-09 08:04:12 -05:00
|
|
|
|
2023-07-04 20:38:59 -05:00
|
|
|
describe('Outbox', () => {
|
|
|
|
test('Fetch non-paged outbox from IActor', async () => {
|
|
|
|
const actor = createRandomActor();
|
|
|
|
const outbox = createRandomNonPagedOutbox(actor, 10);
|
|
|
|
|
2023-07-09 08:04:12 -05:00
|
|
|
resolver.register(actor.id, actor);
|
|
|
|
resolver.register(actor.outbox as string, outbox);
|
2023-07-04 20:38:59 -05:00
|
|
|
|
|
|
|
await personService.createPerson(actor.id, resolver);
|
|
|
|
|
|
|
|
for (const item of outbox.orderedItems as ICreate[]) {
|
|
|
|
const note = await noteService.fetchNote(item.object);
|
|
|
|
assert.ok(note);
|
|
|
|
assert.strictEqual(note.text, 'test test foo');
|
|
|
|
assert.strictEqual(note.uri, (item.object as IObject).id);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
|
|
|
test('Fetch paged outbox from IActor', async () => {
|
|
|
|
const actor = createRandomActor();
|
|
|
|
const outbox = createRandomPagedOutbox(actor);
|
2023-07-09 15:36:27 -05:00
|
|
|
const page = createRandomOutboxPage(actor, outbox.id, 10);
|
2023-07-04 20:38:59 -05:00
|
|
|
|
2023-07-09 08:04:12 -05:00
|
|
|
resolver.register(actor.id, actor);
|
|
|
|
resolver.register(actor.outbox as string, outbox);
|
|
|
|
resolver.register(outbox.first as string, page);
|
2023-07-04 20:38:59 -05:00
|
|
|
|
|
|
|
await personService.createPerson(actor.id, resolver);
|
|
|
|
|
|
|
|
for (const item of page.orderedItems as ICreate[]) {
|
|
|
|
const note = await noteService.fetchNote(item.object);
|
|
|
|
assert.ok(note);
|
|
|
|
assert.strictEqual(note.text, 'test test foo');
|
|
|
|
assert.strictEqual(note.uri, (item.object as IObject).id);
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2023-07-09 08:04:12 -05:00
|
|
|
test('Fetch only the first 20 items', async () => {
|
2023-07-04 20:38:59 -05:00
|
|
|
const actor = createRandomActor();
|
|
|
|
const outbox = createRandomNonPagedOutbox(actor, 200);
|
|
|
|
|
2023-07-09 08:04:12 -05:00
|
|
|
resolver.register(actor.id, actor);
|
|
|
|
resolver.register(actor.outbox as string, outbox);
|
2023-07-04 20:38:59 -05:00
|
|
|
|
|
|
|
await personService.createPerson(actor.id, resolver);
|
|
|
|
|
|
|
|
const items = outbox.orderedItems as ICreate[];
|
2023-07-08 08:40:48 -05:00
|
|
|
assert.ok(await noteService.fetchNote(items[19].object));
|
|
|
|
assert.ok(!await noteService.fetchNote(items[20].object));
|
2023-07-09 15:36:07 -05:00
|
|
|
});
|
2023-07-04 20:38:59 -05:00
|
|
|
});
|
2021-07-10 09:14:57 -05:00
|
|
|
});
|