Merge branch 'develop' into upstream/2025.5.0

packages/backend/test/misc/mock-resolver.ts

@@ -19,6 +19,7 @@ import type {
 	PollsRepository,
 	UsersRepository,
 } from '@/models/_.js';
+import type { CacheService } from '@/core/CacheService.js';
 import { ApLogService } from '@/core/ApLogService.js';
 import { ApUtilityService } from '@/core/activitypub/ApUtilityService.js';
 import { fromTuple } from '@/misc/from-tuple.js';
@@ -53,6 +54,7 @@ export class MockResolver extends Resolver {
 			loggerService,
 			{} as ApLogService,
 			{} as ApUtilityService,
+			{} as CacheService,
 		);
 	}
 

packages/backend/test/unit/AbuseReportNotificationService.ts

@@ -11,6 +11,7 @@ import {
 	AbuseReportNotificationRecipientRepository,
 	MiAbuseReportNotificationRecipient,
 	MiAbuseUserReport,
+	MiMeta,
 	MiSystemWebhook,
 	MiUser,
 	SystemWebhooksRepository,
@@ -56,6 +57,15 @@ describe('AbuseReportNotificationService', () => {
 
 	// --------------------------------------------------------------------------------------
 
+	const meta = {} as MiMeta;
+
+	function updateMeta(newMeta: Partial<MiMeta>): void {
+		for (const key in meta) {
+			delete (meta as any)[key];
+		}
+		Object.assign(meta, newMeta);
+	}
+
 	async function createUser(data: Partial<MiUser> = {}) {
 		const user = await usersRepository
 			.insert({
@@ -66,6 +76,8 @@ describe('AbuseReportNotificationService', () => {
 
 		await userProfilesRepository.insert({
 			userId: user.id,
+			email: user.username + '@example.com',
+			emailVerified: true,
 		});
 
 		return user;
@@ -130,6 +142,9 @@ describe('AbuseReportNotificationService', () => {
 					{
 						provide: GlobalEventService, useFactory: () => ({ publishAdminStream: jest.fn() }),
 					},
+					{
+						provide: DI.meta, useFactory: () => meta,
+					},
 				],
 			})
 			.compile();
@@ -156,6 +171,8 @@ describe('AbuseReportNotificationService', () => {
 		systemWebhook2 = await createWebhook();
 
 		roleService.getModeratorIds.mockResolvedValue([root.id, alice.id, bob.id]);
+
+		updateMeta({} as MiMeta);
 	});
 
 	afterEach(async () => {
@@ -392,4 +409,59 @@ describe('AbuseReportNotificationService', () => {
 			expect(webhookService.enqueueSystemWebhook.mock.calls[0][2]).toEqual({ excludes: [systemWebhook2.id] });
 		});
 	});
+
+	describe('collection of recipient-mails', () => {
+		async function create() {
+			const recipient = await createRecipient({
+				method: 'email',
+				userId: alice.id,
+			});
+
+			return recipient;
+		}
+
+		test('with nothing set', async () => {
+			const mails = await service.getRecipientEMailAddresses();
+			expect(mails).toEqual([]);
+		});
+
+		test('with maintainer mail set', async () => {
+			updateMeta({ maintainerEmail: 'maintainer_mail' });
+			const mails = await service.getRecipientEMailAddresses();
+			expect(mails).toEqual(['maintainer_mail']);
+		});
+
+		test('with smtp mail set', async () => {
+			updateMeta({ email: 'smtp_mail' });
+			const mails = await service.getRecipientEMailAddresses();
+			expect(mails).toEqual(['smtp_mail']);
+		});
+
+		test('with maintainer mail and smtp mail set', async () => {
+			updateMeta({ email: 'smtp_mail', maintainerEmail: 'maintainer_mail' });
+			const mails = await service.getRecipientEMailAddresses();
+			expect(mails).toEqual(['smtp_mail', 'maintainer_mail']);
+		});
+
+		test('with recipients', async () => {
+			await create();
+
+			const mails = await service.getRecipientEMailAddresses();
+			expect(mails).toEqual([
+				'alice@example.com',
+			]);
+		});
+
+		test('with recipients and maintainer mail set and smtp mail set', async () => {
+			await create();
+			updateMeta({ maintainerEmail: 'maintainer_mail', email: 'smtp_mail' });
+
+			const mails = await service.getRecipientEMailAddresses();
+			expect(mails).toEqual([
+				'alice@example.com',
+				'smtp_mail',
+				'maintainer_mail',
+			]);
+		});
+	});
 });

packages/backend/test/unit/activitypub.ts

@@ -674,59 +674,6 @@ describe('ActivityPub', () => {
 			});
 		});
 
-		describe('renderUpnote', () => {
-			describe('summary', () => {
-				// I actually don't know why it does this, but the logic was already there so I've preserved it.
-				it('should be zero-width space when CW is empty string', async () => {
-					note.cw = '';
-
-					const result = await rendererService.renderUpNote(note, author, false);
-
-					expect(result.summary).toBe(String.fromCharCode(0x200B));
-				});
-
-				it('should be undefined when CW is null', async () => {
-					const result = await rendererService.renderUpNote(note, author, false);
-
-					expect(result.summary).toBeUndefined();
-				});
-
-				it('should be CW when present without mandatoryCW', async () => {
-					note.cw = 'original';
-
-					const result = await rendererService.renderUpNote(note, author, false);
-
-					expect(result.summary).toBe('original');
-				});
-
-				it('should be mandatoryCW when present without CW', async () => {
-					author.mandatoryCW = 'mandatory';
-
-					const result = await rendererService.renderUpNote(note, author, false);
-
-					expect(result.summary).toBe('mandatory');
-				});
-
-				it('should be merged when CW and mandatoryCW are both present', async () => {
-					note.cw = 'original';
-					author.mandatoryCW = 'mandatory';
-
-					const result = await rendererService.renderUpNote(note, author, false);
-
-					expect(result.summary).toBe('original, mandatory');
-				});
-
-				it('should be CW when CW includes mandatoryCW', async () => {
-					note.cw = 'original and mandatory';
-					author.mandatoryCW = 'mandatory';
-
-					const result = await rendererService.renderUpNote(note, author, false);
-
-					expect(result.summary).toBe('original and mandatory');
-				});
-			});
-		});
-
 		describe('renderPersonRedacted', () => {
 			it('should include minimal properties', async () => {
 				const result = await rendererService.renderPersonRedacted(author);

packages/backend/test/unit/core/activitypub/misc/extract-media-from-html.ts

@@ -0,0 +1,297 @@
+/*
+ * SPDX-FileCopyrightText: hazelnoot and other Sharkey contributors
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { extractMediaFromHtml } from '@/core/activitypub/misc/extract-media-from-html.js';
+
+describe(extractMediaFromHtml, () => {
+	it('should return empty for invalid input', () => {
+		const result = extractMediaFromHtml('<broken html');
+		expect(result).toEqual([]);
+	});
+
+	it('should return empty for empty input', () => {
+		const result = extractMediaFromHtml('');
+		expect(result).toEqual([]);
+	});
+
+	it('should return empty for input without attachments', () => {
+		const result = extractMediaFromHtml('<div>No media here!</div>');
+		expect(result).toEqual([]);
+	});
+
+	it('should extract img tags', () => {
+		const result = extractMediaFromHtml('<img src="https://example.com/img.png" alt=""/>');
+		expect(result).toEqual([{
+			type: 'Image',
+			url: 'https://example.com/img.png',
+			name: null,
+		}]);
+	});
+
+	it('should ignore img tags without src', () => {
+		const result = extractMediaFromHtml('<img alt=""/>');
+		expect(result).toEqual([]);
+	});
+
+	it('should extract picture tags with img', () => {
+		const result = extractMediaFromHtml('<picture><img src="https://example.com/picture.png" alt=""/></picture>');
+		expect(result).toEqual([{
+			type: 'Image',
+			url: 'https://example.com/picture.png',
+			name: null,
+		}]);
+	});
+
+	it('should ignore picture tags without img', () => {
+		const result = extractMediaFromHtml('<picture><source src="https://example.com/picture.png"/></picture>');
+		expect(result).toEqual([]);
+	});
+
+	it('should ignore picture tags without src', () => {
+		const result = extractMediaFromHtml('<picture><source/><img alt=""/></picture>');
+		expect(result).toEqual([]);
+	});
+
+	it('should extract object tags', () => {
+		const result = extractMediaFromHtml('<object data="https://example.com/object.dat"></object>');
+		expect(result).toEqual([{
+			type: 'Document',
+			url: 'https://example.com/object.dat',
+			name: null,
+		}]);
+	});
+
+	it('should ignore object tags without data', () => {
+		const result = extractMediaFromHtml('<object></object>');
+		expect(result).toEqual([]);
+	});
+
+	it('should extract object tags with img fallback', () => {
+		const result = extractMediaFromHtml('<object><img src="https://example.com/object.png" alt=""/></object>');
+		expect(result).toEqual([{
+			type: 'Image',
+			url: 'https://example.com/object.png',
+			name: null,
+		}]);
+	});
+
+	it('should ignore object tags with empty img fallback', () => {
+		const result = extractMediaFromHtml('<object><img alt=""/></object>');
+		expect(result).toEqual([]);
+	});
+
+	it('should extract embed tags', () => {
+		const result = extractMediaFromHtml('<embed src="https://example.com/embed.dat"/>');
+		expect(result).toEqual([{
+			type: 'Document',
+			url: 'https://example.com/embed.dat',
+			name: null,
+		}]);
+	});
+
+	it('should ignore embed tags without src', () => {
+		const result = extractMediaFromHtml('<embed/>');
+		expect(result).toEqual([]);
+	});
+
+	it('should extract audio tags', () => {
+		const result = extractMediaFromHtml('<audio src="https://example.com/audio.mp3"></audio>');
+		expect(result).toEqual([{
+			type: 'Audio',
+			url: 'https://example.com/audio.mp3',
+			name: null,
+		}]);
+	});
+
+	it('should ignore audio tags without src', () => {
+		const result = extractMediaFromHtml('<audio></audio>');
+		expect(result).toEqual([]);
+	});
+
+	it('should extract video tags', () => {
+		const result = extractMediaFromHtml('<video src="https://example.com/video.mp4"></video>');
+		expect(result).toEqual([{
+			type: 'Video',
+			url: 'https://example.com/video.mp4',
+			name: null,
+		}]);
+	});
+
+	it('should ignore video tags without src', () => {
+		const result = extractMediaFromHtml('<video></video>');
+		expect(result).toEqual([]);
+	});
+
+	it('should extract alt text from alt property', () => {
+		const result = extractMediaFromHtml(`
+			<img src="https://example.com/img.png" alt="img tag" title="wrong"/>
+			<picture><img src="https://example.com/picture.png" alt="picture tag" title="wrong"/></picture>
+			<object data="https://example.com/object-1.dat" alt="object tag" title="wrong"></object>
+			<object><img src="https://example.com/object-2.png" alt="object tag" title="wrong"/></object>
+			<embed src="https://example.com/embed.dat" alt="embed tag" title="wrong"/>
+			<audio src="https://example.com/audio.mp3" alt="audio tag" title="wrong"/>
+			<video src="https://example.com/video.mp4" alt="video tag" title="wrong"/>
+		`);
+
+		expect(result).toEqual([
+			{
+				type: 'Image',
+				url: 'https://example.com/img.png',
+				name: 'img tag',
+			},
+			{
+				type: 'Image',
+				url: 'https://example.com/picture.png',
+				name: 'picture tag',
+			},
+			{
+				type: 'Image',
+				url: 'https://example.com/object-2.png',
+				name: 'object tag',
+			},
+			{
+				type: 'Document',
+				url: 'https://example.com/object-1.dat',
+				name: 'object tag',
+			},
+			{
+				type: 'Document',
+				url: 'https://example.com/embed.dat',
+				name: 'embed tag',
+			},
+			{
+				type: 'Audio',
+				url: 'https://example.com/audio.mp3',
+				name: 'audio tag',
+			},
+			{
+				type: 'Video',
+				url: 'https://example.com/video.mp4',
+				name: 'video tag',
+			},
+		]);
+	});
+
+	it('should extract alt text from title property', () => {
+		const result = extractMediaFromHtml(`
+			<img src="https://example.com/img.png" title="img tag"/>
+			<picture><img src="https://example.com/picture.png" title="picture tag"/></picture>
+			<object data="https://example.com/object-1.dat" title="object tag"></object>
+			<object><img src="https://example.com/object-2.png" title="object tag"/></object>
+			<embed src="https://example.com/embed.dat" title="embed tag"/>
+			<audio src="https://example.com/audio.mp3" title="audio tag"/>
+			<video src="https://example.com/video.mp4" title="video tag"/>
+		`);
+
+		expect(result).toEqual([
+			{
+				type: 'Image',
+				url: 'https://example.com/img.png',
+				name: 'img tag',
+			},
+			{
+				type: 'Image',
+				url: 'https://example.com/picture.png',
+				name: 'picture tag',
+			},
+			{
+				type: 'Image',
+				url: 'https://example.com/object-2.png',
+				name: 'object tag',
+			},
+			{
+				type: 'Document',
+				url: 'https://example.com/object-1.dat',
+				name: 'object tag',
+			},
+			{
+				type: 'Document',
+				url: 'https://example.com/embed.dat',
+				name: 'embed tag',
+			},
+			{
+				type: 'Audio',
+				url: 'https://example.com/audio.mp3',
+				name: 'audio tag',
+			},
+			{
+				type: 'Video',
+				url: 'https://example.com/video.mp4',
+				name: 'video tag',
+			},
+		]);
+	});
+
+	it('should ignore missing alt text', () => {
+		const result = extractMediaFromHtml(`
+			<img src="https://example.com/img.png"/>
+			<picture><img src="https://example.com/picture.png"/></picture>
+			<object data="https://example.com/object-1.dat"></object>
+			<object><img src="https://example.com/object-2.png"/></object>
+			<embed src="https://example.com/embed.dat"/>
+			<audio src="https://example.com/audio.mp3"/>
+			<video src="https://example.com/video.mp4"/>
+		`);
+
+		expect(result).toEqual([
+			{
+				type: 'Image',
+				url: 'https://example.com/img.png',
+				name: null,
+			},
+			{
+				type: 'Image',
+				url: 'https://example.com/picture.png',
+				name: null,
+			},
+			{
+				type: 'Image',
+				url: 'https://example.com/object-2.png',
+				name: null,
+			},
+			{
+				type: 'Document',
+				url: 'https://example.com/object-1.dat',
+				name: null,
+			},
+			{
+				type: 'Document',
+				url: 'https://example.com/embed.dat',
+				name: null,
+			},
+			{
+				type: 'Audio',
+				url: 'https://example.com/audio.mp3',
+				name: null,
+			},
+			{
+				type: 'Video',
+				url: 'https://example.com/video.mp4',
+				name: null,
+			},
+		]);
+	});
+
+	it('should de-duplicate attachments', () => {
+		const result = extractMediaFromHtml(`
+			<img src="https://example.com/1.png" alt="img 1"/>
+			<img src="https://example.com/2.png" alt="img 2"/>
+			<embed src="https://example.com/1.png" alt="embed 1"/>
+		`);
+
+		expect(result).toEqual([
+			{
+				type: 'Document',
+				url: 'https://example.com/1.png',
+				name: 'embed 1',
+			},
+			{
+				type: 'Image',
+				url: 'https://example.com/2.png',
+				name: 'img 2',
+			},
+		]);
+	});
+});

packages/backend/test/unit/core/activitypub/misc/extract-media-from-mfm.ts

@@ -0,0 +1,92 @@
+/*
+ * SPDX-FileCopyrightText: hazelnoot and other Sharkey contributors
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { extractMediaFromMfm } from '@/core/activitypub/misc/extract-media-from-mfm.js';
+
+describe(extractMediaFromMfm, () => {
+	it('should return empty for empty input', () => {
+		const result = extractMediaFromMfm('');
+		expect(result).toEqual([]);
+	});
+
+	it('should return empty for invalid input', () => {
+		const result = extractMediaFromMfm('*broken markdown\0');
+		expect(result).toEqual([]);
+	});
+
+	it('should extract all image links', () => {
+		const result = extractMediaFromMfm(`
+			![1](https://example.com/images/1.png)
+			![](https://example.com/images/2.png)
+			**![3](https://example.com/images/3.png)**
+		`);
+
+		expect(result).toEqual([
+			{
+				type: 'Image',
+				url: 'https://example.com/images/1.png',
+				name: '1',
+			},
+			{
+				type: 'Image',
+				url: 'https://example.com/images/2.png',
+				name: null,
+			},
+			{
+				type: 'Image',
+				url: 'https://example.com/images/3.png',
+				name: '3',
+			},
+		]);
+	});
+
+	it('should ignore regular links', () => {
+		const result = extractMediaFromMfm(`
+			[1](https://example.com/images/1.png)
+			[](https://example.com/images/2.png)
+			**[3](https://example.com/images/3.png)**
+		`);
+
+		expect(result).toEqual([]);
+	});
+
+	it('should ignore silent links', () => {
+		const result = extractMediaFromMfm(`
+			?[1](https://example.com/images/1.png)
+			?[](https://example.com/images/2.png)
+			**?[3](https://example.com/images/3.png)**
+		`);
+
+		expect(result).toEqual([]);
+	});
+
+	it('should extract complex text', () => {
+		const result = extractMediaFromMfm('![this is an **image** with *complex* text! :owo: 💙](https://example.com/image.png)');
+
+		expect(result).toEqual([
+			{
+				type: 'Image',
+				url: 'https://example.com/image.png',
+				name: 'this is an image with complex text! :owo: 💙',
+			},
+		]);
+	});
+
+	it('should de-duplicate images', () => {
+		const result = extractMediaFromMfm(`
+			![1](https://example.com/images/1.png)
+			![](https://example.com/images/1.png)
+			**![3](https://example.com/images/1.png)**
+		`);
+
+		expect(result).toEqual([
+			{
+				type: 'Image',
+				url: 'https://example.com/images/1.png',
+				name: '3',
+			},
+		]);
+	});
+});

packages/backend/test/unit/core/activitypub/misc/get-content-by-type.ts

@@ -0,0 +1,167 @@
+/*
+ * SPDX-FileCopyrightText: hazelnoot and other Sharkey contributors
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import { getContentByType } from '@/core/activitypub/misc/get-content-by-type.js';
+
+describe(getContentByType, () => {
+	describe('when permissive', () => {
+		it('should return source.content when it matches', () => {
+			const obj = {
+				source: {
+					content: 'source content',
+				},
+				_misskey_content: 'misskey content',
+				content: 'native content',
+				mediaType: 'text/x.misskeYMarkdown, text/markdown',
+			};
+
+			const content = getContentByType(obj, 'text/x.misskeymarkdown', true);
+
+			expect(content).toBe('source content');
+		});
+
+		it('should return _misskey_content when it matches', () => {
+			const obj = {
+				source: {
+					content: 'source content',
+					mediaType: 'text/plain',
+				},
+				_misskey_content: 'misskey content',
+				content: 'native content',
+				mediaType: 'text/x.misskeYMarkdown, text/markdown',
+			};
+
+			const content = getContentByType(obj, 'text/x.misskeymarkdown', true);
+
+			expect(content).toBe('misskey content');
+		});
+
+		it('should return content when it matches', () => {
+			const obj = {
+				source: {
+					content: 'source content',
+					mediaType: 'text/plain',
+				},
+				_misskey_content: null,
+				content: 'native content',
+				mediaType: 'text/x.misskeYMarkdown, text/markdown',
+			};
+
+			const content = getContentByType(obj, 'text/x.misskeymarkdown', true);
+
+			expect(content).toBe('native content');
+		});
+
+		it('should return null when nothing matches', () => {
+			const obj = {
+				source: {
+					content: 'source content',
+					mediaType: 'text/plain',
+				},
+				_misskey_content: null,
+				content: 'native content',
+				mediaType: 'text/plain',
+			};
+
+			const content = getContentByType(obj, 'text/x.misskeymarkdown', true);
+
+			expect(content).toBe(null);
+		});
+
+		it('should return null for invalid inputs', () => {
+			const objects = [
+				{},
+				{ source: 'nope' },
+				{ content: null },
+				{ _misskey_content: 123 },
+			];
+
+			const results = objects.map(c => getContentByType(c, 'text/misskeymarkdown', true));
+
+			const expected = objects.map(() => null);
+			expect(results).toEqual(expected);
+		});
+	});
+
+	describe('when not permissive', () => {
+		it('should return source.content when it matches', () => {
+			const obj = {
+				source: {
+					content: 'source content',
+					mediaType: 'text/x.misskeymarkdown',
+				},
+				_misskey_content: 'misskey content',
+				content: 'native content',
+				mediaType: 'text/x.misskeymarkdown',
+			};
+
+			const content = getContentByType(obj, 'text/x.misskeymarkdown');
+
+			expect(content).toBe('source content');
+		});
+
+		it('should return _misskey_content when it matches', () => {
+			const obj = {
+				source: {
+					content: 'source content',
+					mediaType: 'text/plain',
+				},
+				_misskey_content: 'misskey content',
+				content: 'native content',
+				mediaType: 'text/x.misskeymarkdown',
+			};
+
+			const content = getContentByType(obj, 'text/x.misskeymarkdown');
+
+			expect(content).toBe('misskey content');
+		});
+
+		it('should return content when it matches', () => {
+			const obj = {
+				source: {
+					content: 'source content',
+					mediaType: 'text/plain',
+				},
+				_misskey_content: null,
+				content: 'native content',
+				mediaType: 'text/x.misskeymarkdown',
+			};
+
+			const content = getContentByType(obj, 'text/x.misskeymarkdown');
+
+			expect(content).toBe('native content');
+		});
+
+		it('should return null when nothing matches', () => {
+			const obj = {
+				source: {
+					content: 'source content',
+					mediaType: 'text/plain',
+				},
+				_misskey_content: null,
+				content: 'native content',
+				mediaType: 'text/plain',
+			};
+
+			const content = getContentByType(obj, 'text/x.misskeymarkdown');
+
+			expect(content).toBe(null);
+		});
+
+		it('should return null for invalid inputs', () => {
+			const objects = [
+				{},
+				{ source: 'nope' },
+				{ content: null },
+				{ _misskey_content: 123 },
+			];
+
+			const results = objects.map(c => getContentByType(c, 'text/misskeymarkdown'));
+
+			const expected = objects.map(() => null);
+			expect(results).toEqual(expected);
+		});
+	});
+});

packages/backend/test/utils.ts

@@ -652,7 +652,7 @@ export async function sendEnvResetRequest() {
 
 // 与えられた値を強制的にエラーとみなす。この関数は型安全性を破壊するため、異常系のアサーション以外で用いられるべきではない。
 // FIXME(misskey-js): misskey-jsがエラー情報を公開するようになったらこの関数を廃止する
-export function castAsError(obj: Record<string, unknown>): { error: ApiError } {
+export function castAsError(obj: object | null | undefined): { error: ApiError } {
 	return obj as { error: ApiError };
 }