Mizah/mizzkey
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge remote-tracking branch 'misskey-dev/develop' into io

Browse source
This commit is contained in:
まっちゃとーにゅ 2024-03-15 13:08:54 +09:00
commit acab2bfc72
No known key found for this signature in database
GPG key ID: 6AFBBF529601C1DB
83 changed files with 1149 additions and 173 deletions
Download patch file Download diff file Expand all files Collapse all files

4
packages/backend/test/unit/AnnouncementService.ts
View file

@ -178,7 +178,7 @@ describe('AnnouncementService', () => {
expect(globalEventService.publishBroadcastStream).toHaveBeenCalled();
expect(globalEventService.publishBroadcastStream.mock.lastCall![0]).toBe('announcementCreated');
expect((globalEventService.publishBroadcastStream.mock.lastCall![1] as any).announcement).toBe(result.packed);
expect((globalEventService.publishBroadcastStream.mock.lastCall![1] as FIXME).announcement).toBe(result.packed);
expect(moderationLogService.log).toHaveBeenCalled();
});
@ -198,7 +198,7 @@ describe('AnnouncementService', () => {
expect(globalEventService.publishMainStream).toHaveBeenCalled();
expect(globalEventService.publishMainStream.mock.lastCall![0]).toBe(user.id);
expect(globalEventService.publishMainStream.mock.lastCall![1]).toBe('announcementCreated');
expect((globalEventService.publishMainStream.mock.lastCall![2] as any).announcement).toBe(result.packed);
expect((globalEventService.publishMainStream.mock.lastCall![2] as FIXME).announcement).toBe(result.packed);
expect(moderationLogService.log).toHaveBeenCalled();
});
});

9
packages/backend/test/unit/ApMfmService.ts
View file

@ -1,3 +1,8 @@
/*
* SPDX-FileCopyrightText: syuilo and misskey-project
* SPDX-License-Identifier: AGPL-3.0-only
*/
import * as assert from 'assert';
import { Test } from '@nestjs/testing';
@ -21,7 +26,7 @@ describe('ApMfmService', () => {
const note: MiNote = {
text: 'テキスト #タグ @mention 🍊 :emoji: https://example.com',
mentionedRemoteUsers: '[]',
} as any;
} as FIXME;
const { content, noMisskeyContent } = apMfmService.getNoteHtml(note);
@ -33,7 +38,7 @@ describe('ApMfmService', () => {
const note: MiNote = {
text: '$[tada foo]',
mentionedRemoteUsers: '[]',
} as any;
} as FIXME;
const { content, noMisskeyContent } = apMfmService.getNoteHtml(note);

42
packages/backend/test/unit/FetchInstanceMetadataService.ts
View file

@ -7,7 +7,6 @@ process.env.NODE_ENV = 'test';
import { jest } from '@jest/globals';
import { Test } from '@nestjs/testing';
import { Redis } from 'ioredis';
import { GlobalModule } from '@/GlobalModule.js';
import { FetchInstanceMetadataService } from '@/core/FetchInstanceMetadataService.js';
import { FederatedInstanceService } from '@/core/FederatedInstanceService.js';
@ -18,15 +17,16 @@ import { IdService } from '@/core/IdService.js';
import { DI } from '@/di-symbols.js';
import type { TestingModule } from '@nestjs/testing';
function mockRedis() {
const hash = {} as any;
const set = jest.fn((key: string, value) => {
// このテストで呼び出すSETにはNXオプションが付いてる
if (hash[key]) return null;
hash[key] = value;
return 'OK';
function mockRedisSetNX() {
const hash = {} as FIXME;
// eslint-disable-next-line @typescript-eslint/no-unused-vars
return jest.fn((key: string, value, secondsToken: 'EX', seconds: number, nx: 'NX', callback?): Promise<'OK' | null> => {
return new Promise(resolve => {
if (hash[key]) return resolve(null);
hash[key] = value;
resolve('OK');
});
});
return set;
}
describe('FetchInstanceMetadataService', () => {
@ -34,7 +34,6 @@ describe('FetchInstanceMetadataService', () => {
let fetchInstanceMetadataService: jest.Mocked<FetchInstanceMetadataService>;
let federatedInstanceService: jest.Mocked<FederatedInstanceService>;
let httpRequestService: jest.Mocked<HttpRequestService>;
let redisClient: jest.Mocked<Redis>;
beforeEach(async () => {
app = await Test
@ -55,7 +54,7 @@ describe('FetchInstanceMetadataService', () => {
} else if (token === FederatedInstanceService) {
return { fetch: jest.fn() };
} else if (token === DI.redis) {
return mockRedis;
return { set: mockRedisSetNX() };
}
return null;
})
@ -65,7 +64,6 @@ describe('FetchInstanceMetadataService', () => {
fetchInstanceMetadataService = app.get<FetchInstanceMetadataService>(FetchInstanceMetadataService) as jest.Mocked<FetchInstanceMetadataService>;
federatedInstanceService = app.get<FederatedInstanceService>(FederatedInstanceService) as jest.Mocked<FederatedInstanceService>;
redisClient = app.get<Redis>(DI.redis) as jest.Mocked<Redis>;
httpRequestService = app.get<HttpRequestService>(HttpRequestService) as jest.Mocked<HttpRequestService>;
});
@ -74,14 +72,13 @@ describe('FetchInstanceMetadataService', () => {
});
test('Lock and update', async () => {
redisClient.set = mockRedis();
const now = Date.now();
federatedInstanceService.fetch.mockResolvedValue({ infoUpdatedAt: { getTime: () => { return now - 10 * 1000 * 60 * 60 * 24; } } } as any);
federatedInstanceService.fetch.mockResolvedValue({ infoUpdatedAt: { getTime: () => { return now - 10 * 1000 * 60 * 60 * 24; } } } as FIXME);
httpRequestService.getJson.mockImplementation(() => { throw Error(); });
const tryLockSpy = jest.spyOn(fetchInstanceMetadataService, 'tryLock');
const unlockSpy = jest.spyOn(fetchInstanceMetadataService, 'unlock');
await fetchInstanceMetadataService.fetchInstanceMetadata({ host: 'example.com' } as any);
await fetchInstanceMetadataService.fetchInstanceMetadata({ host: 'example.com' } as FIXME);
expect(tryLockSpy).toHaveBeenCalledTimes(1);
expect(unlockSpy).toHaveBeenCalledTimes(1);
expect(federatedInstanceService.fetch).toHaveBeenCalledTimes(1);
@ -89,14 +86,13 @@ describe('FetchInstanceMetadataService', () => {
});
test('Lock and don\'t update', async () => {
redisClient.set = mockRedis();
const now = Date.now();
federatedInstanceService.fetch.mockResolvedValue({ infoUpdatedAt: { getTime: () => now } } as any);
federatedInstanceService.fetch.mockResolvedValue({ infoUpdatedAt: { getTime: () => now } } as FIXME);
httpRequestService.getJson.mockImplementation(() => { throw Error(); });
const tryLockSpy = jest.spyOn(fetchInstanceMetadataService, 'tryLock');
const unlockSpy = jest.spyOn(fetchInstanceMetadataService, 'unlock');
await fetchInstanceMetadataService.fetchInstanceMetadata({ host: 'example.com' } as any);
await fetchInstanceMetadataService.fetchInstanceMetadata({ host: 'example.com' } as FIXME);
expect(tryLockSpy).toHaveBeenCalledTimes(1);
expect(unlockSpy).toHaveBeenCalledTimes(1);
expect(federatedInstanceService.fetch).toHaveBeenCalledTimes(1);
@ -104,15 +100,14 @@ describe('FetchInstanceMetadataService', () => {
});
test('Do nothing when lock not acquired', async () => {
redisClient.set = mockRedis();
const now = Date.now();
federatedInstanceService.fetch.mockResolvedValue({ infoUpdatedAt: { getTime: () => now - 10 * 1000 * 60 * 60 * 24 } } as any);
federatedInstanceService.fetch.mockResolvedValue({ infoUpdatedAt: { getTime: () => now - 10 * 1000 * 60 * 60 * 24 } } as FIXME);
httpRequestService.getJson.mockImplementation(() => { throw Error(); });
await fetchInstanceMetadataService.tryLock('example.com');
const tryLockSpy = jest.spyOn(fetchInstanceMetadataService, 'tryLock');
const unlockSpy = jest.spyOn(fetchInstanceMetadataService, 'unlock');
await fetchInstanceMetadataService.fetchInstanceMetadata({ host: 'example.com' } as any);
await fetchInstanceMetadataService.fetchInstanceMetadata({ host: 'example.com' } as FIXME);
expect(tryLockSpy).toHaveBeenCalledTimes(1);
expect(unlockSpy).toHaveBeenCalledTimes(0);
expect(federatedInstanceService.fetch).toHaveBeenCalledTimes(0);
@ -120,15 +115,14 @@ describe('FetchInstanceMetadataService', () => {
});
test('Do when lock not acquired but forced', async () => {
redisClient.set = mockRedis();
const now = Date.now();
federatedInstanceService.fetch.mockResolvedValue({ infoUpdatedAt: { getTime: () => now - 10 * 1000 * 60 * 60 * 24 } } as any);
federatedInstanceService.fetch.mockResolvedValue({ infoUpdatedAt: { getTime: () => now - 10 * 1000 * 60 * 60 * 24 } } as FIXME);
httpRequestService.getJson.mockImplementation(() => { throw Error(); });
await fetchInstanceMetadataService.tryLock('example.com');
const tryLockSpy = jest.spyOn(fetchInstanceMetadataService, 'tryLock');
const unlockSpy = jest.spyOn(fetchInstanceMetadataService, 'unlock');
await fetchInstanceMetadataService.fetchInstanceMetadata({ host: 'example.com' } as any, true);
await fetchInstanceMetadataService.fetchInstanceMetadata({ host: 'example.com' } as FIXME, true);
expect(tryLockSpy).toHaveBeenCalledTimes(1);
expect(unlockSpy).toHaveBeenCalledTimes(1);
expect(federatedInstanceService.fetch).toHaveBeenCalledTimes(0);

28
packages/backend/test/unit/FileInfoService.ts
View file

@ -63,7 +63,7 @@ describe('FileInfoService', () => {
test('Empty file', async () => {
const path = `${resources}/emptyfile`;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as any;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as FIXME;
delete info.warnings;
delete info.blurhash;
delete info.sensitive;
@ -84,7 +84,7 @@ describe('FileInfoService', () => {
describe('IMAGE', () => {
test('Generic JPEG', async () => {
const path = `${resources}/Lenna.jpg`;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as any;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as FIXME;
delete info.warnings;
delete info.blurhash;
delete info.sensitive;
@ -104,7 +104,7 @@ describe('FileInfoService', () => {
test('Generic APNG', async () => {
const path = `${resources}/anime.png`;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as any;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as FIXME;
delete info.warnings;
delete info.blurhash;
delete info.sensitive;
@ -124,7 +124,7 @@ describe('FileInfoService', () => {
test('Generic AGIF', async () => {
const path = `${resources}/anime.gif`;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as any;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as FIXME;
delete info.warnings;
delete info.blurhash;
delete info.sensitive;
@ -144,7 +144,7 @@ describe('FileInfoService', () => {
test('PNG with alpha', async () => {
const path = `${resources}/with-alpha.png`;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as any;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as FIXME;
delete info.warnings;
delete info.blurhash;
delete info.sensitive;
@ -164,7 +164,7 @@ describe('FileInfoService', () => {
test('Generic SVG', async () => {
const path = `${resources}/image.svg`;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as any;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as FIXME;
delete info.warnings;
delete info.blurhash;
delete info.sensitive;
@ -185,7 +185,7 @@ describe('FileInfoService', () => {
test('SVG with XML definition', async () => {
// https://github.com/misskey-dev/misskey/issues/4413
const path = `${resources}/with-xml-def.svg`;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as any;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as FIXME;
delete info.warnings;
delete info.blurhash;
delete info.sensitive;
@ -205,7 +205,7 @@ describe('FileInfoService', () => {
test('Dimension limit', async () => {
const path = `${resources}/25000x25000.png`;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as any;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as FIXME;
delete info.warnings;
delete info.blurhash;
delete info.sensitive;
@ -225,7 +225,7 @@ describe('FileInfoService', () => {
test('Rotate JPEG', async () => {
const path = `${resources}/rotate.jpg`;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as any;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as FIXME;
delete info.warnings;
delete info.blurhash;
delete info.sensitive;
@ -247,7 +247,7 @@ describe('FileInfoService', () => {
describe('AUDIO', () => {
test('MP3', async () => {
const path = `${resources}/kick_gaba7.mp3`;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as any;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as FIXME;
delete info.warnings;
delete info.blurhash;
delete info.sensitive;
@ -267,7 +267,7 @@ describe('FileInfoService', () => {
test('WAV', async () => {
const path = `${resources}/kick_gaba7.wav`;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as any;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as FIXME;
delete info.warnings;
delete info.blurhash;
delete info.sensitive;
@ -287,7 +287,7 @@ describe('FileInfoService', () => {
test('AAC', async () => {
const path = `${resources}/kick_gaba7.aac`;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as any;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as FIXME;
delete info.warnings;
delete info.blurhash;
delete info.sensitive;
@ -307,7 +307,7 @@ describe('FileInfoService', () => {
test('FLAC', async () => {
const path = `${resources}/kick_gaba7.flac`;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as any;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as FIXME;
delete info.warnings;
delete info.blurhash;
delete info.sensitive;
@ -329,7 +329,7 @@ describe('FileInfoService', () => {
* video/webmとして検出されてしまう
test('WEBM AUDIO', async () => {
const path = `${resources}/kick_gaba7.webm`;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as any;
const info = await fileInfoService.getFileInfo(path, { skipSensitiveDetection: true }) as FIXME;
delete info.warnings;
delete info.blurhash;
delete info.sensitive;

3
packages/backend/test/unit/RelayService.ts
View file

@ -90,7 +90,8 @@ describe('RelayService', () => {
expect(queueService.deliver).toHaveBeenCalled();
expect(queueService.deliver.mock.lastCall![1]?.type).toBe('Undo');
expect(queueService.deliver.mock.lastCall![1]?.object.type).toBe('Follow');
expect(typeof queueService.deliver.mock.lastCall![1]?.object).toBe('object');
expect((queueService.deliver.mock.lastCall![1]?.object as FIXME).type).toBe('Follow');
expect(queueService.deliver.mock.lastCall![2]).toBe('https://example.com');
//expect(queueService.deliver.mock.lastCall![0].username).toBe('relay.actor');

12
packages/backend/test/unit/RoleService.ts
View file

@ -130,7 +130,7 @@ describe('RoleService', () => {
policies: {
canManageCustomEmojis: false,
},
} as any);
} as FIXME);
const result = await roleService.getUserPolicies(user.id);
@ -143,7 +143,7 @@ describe('RoleService', () => {
policies: {
canManageCustomEmojis: true,
},
} as any);
} as FIXME);
const result = await roleService.getUserPolicies(user.id);
@ -167,7 +167,7 @@ describe('RoleService', () => {
policies: {
canManageCustomEmojis: false,
},
} as any);
} as FIXME);
const result = await roleService.getUserPolicies(user.id);
@ -202,7 +202,7 @@ describe('RoleService', () => {
policies: {
driveCapacityMb: 50,
},
} as any);
} as FIXME);
const result = await roleService.getUserPolicies(user.id);
@ -246,7 +246,7 @@ describe('RoleService', () => {
policies: {
canManageCustomEmojis: false,
},
} as any);
} as FIXME);
const user1Policies = await roleService.getUserPolicies(user1.id);
const user2Policies = await roleService.getUserPolicies(user2.id);
@ -299,7 +299,7 @@ describe('RoleService', () => {
policies: {
canManageCustomEmojis: false,
},
} as any);
} as FIXME);
const result = await roleService.getUserPolicies(user.id);
expect(result.canManageCustomEmojis).toBe(true);

528
packages/backend/test/unit/entities/UserEntityService.ts Normal file
View file

@ -0,0 +1,528 @@
/*
* SPDX-FileCopyrightText: syuilo and misskey-project
* SPDX-License-Identifier: AGPL-3.0-only
*/
import { Test, TestingModule } from '@nestjs/testing';
import { UserEntityService } from '@/core/entities/UserEntityService.js';
import { GlobalModule } from '@/GlobalModule.js';
import { CoreModule } from '@/core/CoreModule.js';
import type { MiUser } from '@/models/User.js';
import { secureRndstr } from '@/misc/secure-rndstr.js';
import { genAidx } from '@/misc/id/aidx.js';
import {
BlockingsRepository,
FollowingsRepository, FollowRequestsRepository,
MiUserProfile, MutingsRepository, RenoteMutingsRepository,
UserMemoRepository,
UserProfilesRepository,
UsersRepository,
} from '@/models/_.js';
import { DI } from '@/di-symbols.js';
import { AvatarDecorationService } from '@/core/AvatarDecorationService.js';
import { ApPersonService } from '@/core/activitypub/models/ApPersonService.js';
import { NoteEntityService } from '@/core/entities/NoteEntityService.js';
import { PageEntityService } from '@/core/entities/PageEntityService.js';
import { CustomEmojiService } from '@/core/CustomEmojiService.js';
import { AnnouncementService } from '@/core/AnnouncementService.js';
import { RoleService } from '@/core/RoleService.js';
import { FederatedInstanceService } from '@/core/FederatedInstanceService.js';
import { IdService } from '@/core/IdService.js';
import { UtilityService } from '@/core/UtilityService.js';
import { EmojiEntityService } from '@/core/entities/EmojiEntityService.js';
import { ModerationLogService } from '@/core/ModerationLogService.js';
import { GlobalEventService } from '@/core/GlobalEventService.js';
import { DriveFileEntityService } from '@/core/entities/DriveFileEntityService.js';
import { MetaService } from '@/core/MetaService.js';
import { FetchInstanceMetadataService } from '@/core/FetchInstanceMetadataService.js';
import { CacheService } from '@/core/CacheService.js';
import { ApResolverService } from '@/core/activitypub/ApResolverService.js';
import { ApNoteService } from '@/core/activitypub/models/ApNoteService.js';
import { ApImageService } from '@/core/activitypub/models/ApImageService.js';
import { ApMfmService } from '@/core/activitypub/ApMfmService.js';
import { MfmService } from '@/core/MfmService.js';
import { HashtagService } from '@/core/HashtagService.js';
import UsersChart from '@/core/chart/charts/users.js';
import { ChartLoggerService } from '@/core/chart/ChartLoggerService.js';
import InstanceChart from '@/core/chart/charts/instance.js';
import { ApLoggerService } from '@/core/activitypub/ApLoggerService.js';
import { AccountMoveService } from '@/core/AccountMoveService.js';
import { ReactionService } from '@/core/ReactionService.js';
import { NotificationService } from '@/core/NotificationService.js';
process.env.NODE_ENV = 'test';
describe('UserEntityService', () => {
describe('pack/packMany', () => {
let app: TestingModule;
let service: UserEntityService;
let usersRepository: UsersRepository;
let userProfileRepository: UserProfilesRepository;
let userMemosRepository: UserMemoRepository;
let followingRepository: FollowingsRepository;
let followingRequestRepository: FollowRequestsRepository;
let blockingRepository: BlockingsRepository;
let mutingRepository: MutingsRepository;
let renoteMutingsRepository: RenoteMutingsRepository;
async function createUser(userData: Partial<MiUser> = {}, profileData: Partial<MiUserProfile> = {}) {
const un = secureRndstr(16);
const user = await usersRepository
.insert({
...userData,
id: genAidx(Date.now()),
username: un,
usernameLower: un,
})
.then(x => usersRepository.findOneByOrFail(x.identifiers[0]));
await userProfileRepository.insert({
...profileData,
userId: user.id,
});
return user;
}
async function memo(writer: MiUser, target: MiUser, memo: string) {
await userMemosRepository.insert({
id: genAidx(Date.now()),
userId: writer.id,
targetUserId: target.id,
memo,
});
}
async function follow(follower: MiUser, followee: MiUser) {
await followingRepository.insert({
id: genAidx(Date.now()),
followerId: follower.id,
followeeId: followee.id,
});
}
async function requestFollow(requester: MiUser, requestee: MiUser) {
await followingRequestRepository.insert({
id: genAidx(Date.now()),
followerId: requester.id,
followeeId: requestee.id,
});
}
async function block(blocker: MiUser, blockee: MiUser) {
await blockingRepository.insert({
id: genAidx(Date.now()),
blockerId: blocker.id,
blockeeId: blockee.id,
});
}
async function mute(mutant: MiUser, mutee: MiUser) {
await mutingRepository.insert({
id: genAidx(Date.now()),
muterId: mutant.id,
muteeId: mutee.id,
});
}
async function muteRenote(mutant: MiUser, mutee: MiUser) {
await renoteMutingsRepository.insert({
id: genAidx(Date.now()),
muterId: mutant.id,
muteeId: mutee.id,
});
}
function randomIntRange(weight = 10) {
return [...Array(Math.floor(Math.random() * weight))].map((it, idx) => idx);
}
beforeAll(async () => {
const services = [
UserEntityService,
ApPersonService,
NoteEntityService,
PageEntityService,
CustomEmojiService,
AnnouncementService,
RoleService,
FederatedInstanceService,
IdService,
AvatarDecorationService,
UtilityService,
EmojiEntityService,
ModerationLogService,
GlobalEventService,
DriveFileEntityService,
MetaService,
FetchInstanceMetadataService,
CacheService,
ApResolverService,
ApNoteService,
ApImageService,
ApMfmService,
MfmService,
HashtagService,
UsersChart,
ChartLoggerService,
InstanceChart,
ApLoggerService,
AccountMoveService,
ReactionService,
NotificationService,
];
app = await Test.createTestingModule({
imports: [GlobalModule, CoreModule],
providers: [
...services,
...services.map(x => ({ provide: x.name, useExisting: x })),
],
}).compile();
await app.init();
app.enableShutdownHooks();
service = app.get<UserEntityService>(UserEntityService);
usersRepository = app.get<UsersRepository>(DI.usersRepository);
userProfileRepository = app.get<UserProfilesRepository>(DI.userProfilesRepository);
userMemosRepository = app.get<UserMemoRepository>(DI.userMemosRepository);
followingRepository = app.get<FollowingsRepository>(DI.followingsRepository);
followingRequestRepository = app.get<FollowRequestsRepository>(DI.followRequestsRepository);
blockingRepository = app.get<BlockingsRepository>(DI.blockingsRepository);
mutingRepository = app.get<MutingsRepository>(DI.mutingsRepository);
renoteMutingsRepository = app.get<RenoteMutingsRepository>(DI.renoteMutingsRepository);
});
afterAll(async () => {
await app.close();
});
test('UserLite', async() => {
const me = await createUser();
const who = await createUser();
await memo(me, who, 'memo');
const actual = await service.pack(who, me, { schema: 'UserLite' }) as FIXME;
// no detail
expect(actual.memo).toBeUndefined();
// no detail and me
expect(actual.birthday).toBeUndefined();
// no detail and me
expect(actual.achievements).toBeUndefined();
});
test('UserDetailedNotMe', async() => {
const me = await createUser();
const who = await createUser({}, { birthday: '2000-01-01' });
await memo(me, who, 'memo');
const actual = await service.pack(who, me, { schema: 'UserDetailedNotMe' }) as FIXME;
// is detail
expect(actual.memo).toBe('memo');
// is detail
expect(actual.birthday).toBe('2000-01-01');
// no detail and me
expect(actual.achievements).toBeUndefined();
});
test('MeDetailed', async() => {
const achievements = [{ name: 'achievement', unlockedAt: new Date().getTime() }];
const me = await createUser({}, {
birthday: '2000-01-01',
achievements: achievements,
});
await memo(me, me, 'memo');
const actual = await service.pack(me, me, { schema: 'MeDetailed' }) as FIXME;
// is detail
expect(actual.memo).toBe('memo');
// is detail
expect(actual.birthday).toBe('2000-01-01');
// is detail and me
expect(actual.achievements).toEqual(achievements);
});
describe('packManyによるpreloadがある時、preloadが無い時とpackの結果が同じになるか見たい', () => {
test('no-preload', async() => {
const me = await createUser();
// meがフォローしてる人たち
const followeeMe = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of followeeMe) {
await follow(me, who);
const actual = await service.pack(who, me, { schema: 'UserDetailed' }) as FIXME;
expect(actual.isFollowing).toBe(true);
expect(actual.isFollowed).toBe(false);
expect(actual.hasPendingFollowRequestFromYou).toBe(false);
expect(actual.hasPendingFollowRequestToYou).toBe(false);
expect(actual.isBlocking).toBe(false);
expect(actual.isBlocked).toBe(false);
expect(actual.isMuted).toBe(false);
expect(actual.isRenoteMuted).toBe(false);
}
// meをフォローしてる人たち
const followerMe = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of followerMe) {
await follow(who, me);
const actual = await service.pack(who, me, { schema: 'UserDetailed' }) as FIXME;
expect(actual.isFollowing).toBe(false);
expect(actual.isFollowed).toBe(true);
expect(actual.hasPendingFollowRequestFromYou).toBe(false);
expect(actual.hasPendingFollowRequestToYou).toBe(false);
expect(actual.isBlocking).toBe(false);
expect(actual.isBlocked).toBe(false);
expect(actual.isMuted).toBe(false);
expect(actual.isRenoteMuted).toBe(false);
}
// meがフォローリクエストを送った人たち
const requestsFromYou = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of requestsFromYou) {
await requestFollow(me, who);
const actual = await service.pack(who, me, { schema: 'UserDetailed' }) as FIXME;
expect(actual.isFollowing).toBe(false);
expect(actual.isFollowed).toBe(false);
expect(actual.hasPendingFollowRequestFromYou).toBe(true);
expect(actual.hasPendingFollowRequestToYou).toBe(false);
expect(actual.isBlocking).toBe(false);
expect(actual.isBlocked).toBe(false);
expect(actual.isMuted).toBe(false);
expect(actual.isRenoteMuted).toBe(false);
}
// meにフォローリクエストを送った人たち
const requestsToYou = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of requestsToYou) {
await requestFollow(who, me);
const actual = await service.pack(who, me, { schema: 'UserDetailed' }) as FIXME;
expect(actual.isFollowing).toBe(false);
expect(actual.isFollowed).toBe(false);
expect(actual.hasPendingFollowRequestFromYou).toBe(false);
expect(actual.hasPendingFollowRequestToYou).toBe(true);
expect(actual.isBlocking).toBe(false);
expect(actual.isBlocked).toBe(false);
expect(actual.isMuted).toBe(false);
expect(actual.isRenoteMuted).toBe(false);
}
// meがブロックしてる人たち
const blockingYou = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of blockingYou) {
await block(me, who);
const actual = await service.pack(who, me, { schema: 'UserDetailed' }) as FIXME;
expect(actual.isFollowing).toBe(false);
expect(actual.isFollowed).toBe(false);
expect(actual.hasPendingFollowRequestFromYou).toBe(false);
expect(actual.hasPendingFollowRequestToYou).toBe(false);
expect(actual.isBlocking).toBe(true);
expect(actual.isBlocked).toBe(false);
expect(actual.isMuted).toBe(false);
expect(actual.isRenoteMuted).toBe(false);
}
// meをブロックしてる人たち
const blockingMe = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of blockingMe) {
await block(who, me);
const actual = await service.pack(who, me, { schema: 'UserDetailed' }) as FIXME;
expect(actual.isFollowing).toBe(false);
expect(actual.isFollowed).toBe(false);
expect(actual.hasPendingFollowRequestFromYou).toBe(false);
expect(actual.hasPendingFollowRequestToYou).toBe(false);
expect(actual.isBlocking).toBe(false);
expect(actual.isBlocked).toBe(true);
expect(actual.isMuted).toBe(false);
expect(actual.isRenoteMuted).toBe(false);
}
// meがミュートしてる人たち
const muters = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of muters) {
await mute(me, who);
const actual = await service.pack(who, me, { schema: 'UserDetailed' }) as FIXME;
expect(actual.isFollowing).toBe(false);
expect(actual.isFollowed).toBe(false);
expect(actual.hasPendingFollowRequestFromYou).toBe(false);
expect(actual.hasPendingFollowRequestToYou).toBe(false);
expect(actual.isBlocking).toBe(false);
expect(actual.isBlocked).toBe(false);
expect(actual.isMuted).toBe(true);
expect(actual.isRenoteMuted).toBe(false);
}
// meがリノートミュートしてる人たち
const renoteMuters = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of renoteMuters) {
await muteRenote(me, who);
const actual = await service.pack(who, me, { schema: 'UserDetailed' }) as FIXME;
expect(actual.isFollowing).toBe(false);
expect(actual.isFollowed).toBe(false);
expect(actual.hasPendingFollowRequestFromYou).toBe(false);
expect(actual.hasPendingFollowRequestToYou).toBe(false);
expect(actual.isBlocking).toBe(false);
expect(actual.isBlocked).toBe(false);
expect(actual.isMuted).toBe(false);
expect(actual.isRenoteMuted).toBe(true);
}
});
test('preload', async() => {
const me = await createUser();
{
// meがフォローしてる人たち
const followeeMe = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of followeeMe) {
await follow(me, who);
}
const actualList = await service.packMany(followeeMe, me, { schema: 'UserDetailed' }) as FIXME;
for (const actual of actualList) {
expect(actual.isFollowing).toBe(true);
expect(actual.isFollowed).toBe(false);
expect(actual.hasPendingFollowRequestFromYou).toBe(false);
expect(actual.hasPendingFollowRequestToYou).toBe(false);
expect(actual.isBlocking).toBe(false);
expect(actual.isBlocked).toBe(false);
expect(actual.isMuted).toBe(false);
expect(actual.isRenoteMuted).toBe(false);
}
}
{
// meをフォローしてる人たち
const followerMe = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of followerMe) {
await follow(who, me);
}
const actualList = await service.packMany(followerMe, me, { schema: 'UserDetailed' }) as FIXME;
for (const actual of actualList) {
expect(actual.isFollowing).toBe(false);
expect(actual.isFollowed).toBe(true);
expect(actual.hasPendingFollowRequestFromYou).toBe(false);
expect(actual.hasPendingFollowRequestToYou).toBe(false);
expect(actual.isBlocking).toBe(false);
expect(actual.isBlocked).toBe(false);
expect(actual.isMuted).toBe(false);
expect(actual.isRenoteMuted).toBe(false);
}
}
{
// meがフォローリクエストを送った人たち
const requestsFromYou = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of requestsFromYou) {
await requestFollow(me, who);
}
const actualList = await service.packMany(requestsFromYou, me, { schema: 'UserDetailed' }) as FIXME;
for (const actual of actualList) {
expect(actual.isFollowing).toBe(false);
expect(actual.isFollowed).toBe(false);
expect(actual.hasPendingFollowRequestFromYou).toBe(true);
expect(actual.hasPendingFollowRequestToYou).toBe(false);
expect(actual.isBlocking).toBe(false);
expect(actual.isBlocked).toBe(false);
expect(actual.isMuted).toBe(false);
expect(actual.isRenoteMuted).toBe(false);
}
}
{
// meにフォローリクエストを送った人たち
const requestsToYou = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of requestsToYou) {
await requestFollow(who, me);
}
const actualList = await service.packMany(requestsToYou, me, { schema: 'UserDetailed' }) as FIXME;
for (const actual of actualList) {
expect(actual.isFollowing).toBe(false);
expect(actual.isFollowed).toBe(false);
expect(actual.hasPendingFollowRequestFromYou).toBe(false);
expect(actual.hasPendingFollowRequestToYou).toBe(true);
expect(actual.isBlocking).toBe(false);
expect(actual.isBlocked).toBe(false);
expect(actual.isMuted).toBe(false);
expect(actual.isRenoteMuted).toBe(false);
}
}
{
// meがブロックしてる人たち
const blockingYou = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of blockingYou) {
await block(me, who);
}
const actualList = await service.packMany(blockingYou, me, { schema: 'UserDetailed' }) as FIXME;
for (const actual of actualList) {
expect(actual.isFollowing).toBe(false);
expect(actual.isFollowed).toBe(false);
expect(actual.hasPendingFollowRequestFromYou).toBe(false);
expect(actual.hasPendingFollowRequestToYou).toBe(false);
expect(actual.isBlocking).toBe(true);
expect(actual.isBlocked).toBe(false);
expect(actual.isMuted).toBe(false);
expect(actual.isRenoteMuted).toBe(false);
}
}
{
// meをブロックしてる人たち
const blockingMe = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of blockingMe) {
await block(who, me);
}
const actualList = await service.packMany(blockingMe, me, { schema: 'UserDetailed' }) as FIXME;
for (const actual of actualList) {
expect(actual.isFollowing).toBe(false);
expect(actual.isFollowed).toBe(false);
expect(actual.hasPendingFollowRequestFromYou).toBe(false);
expect(actual.hasPendingFollowRequestToYou).toBe(false);
expect(actual.isBlocking).toBe(false);
expect(actual.isBlocked).toBe(true);
expect(actual.isMuted).toBe(false);
expect(actual.isRenoteMuted).toBe(false);
}
}
{
// meがミュートしてる人たち
const muters = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of muters) {
await mute(me, who);
}
const actualList = await service.packMany(muters, me, { schema: 'UserDetailed' }) as FIXME;
for (const actual of actualList) {
expect(actual.isFollowing).toBe(false);
expect(actual.isFollowed).toBe(false);
expect(actual.hasPendingFollowRequestFromYou).toBe(false);
expect(actual.hasPendingFollowRequestToYou).toBe(false);
expect(actual.isBlocking).toBe(false);
expect(actual.isBlocked).toBe(false);
expect(actual.isMuted).toBe(true);
expect(actual.isRenoteMuted).toBe(false);
}
}
{
// meがリノートミュートしてる人たち
const renoteMuters = await Promise.all(randomIntRange().map(() => createUser()));
for (const who of renoteMuters) {
await muteRenote(me, who);
}
const actualList = await service.packMany(renoteMuters, me, { schema: 'UserDetailed' }) as FIXME;
for (const actual of actualList) {
expect(actual.isFollowing).toBe(false);
expect(actual.isFollowed).toBe(false);
expect(actual.hasPendingFollowRequestFromYou).toBe(false);
expect(actual.hasPendingFollowRequestToYou).toBe(false);
expect(actual.isBlocking).toBe(false);
expect(actual.isBlocked).toBe(false);
expect(actual.isMuted).toBe(false);
expect(actual.isRenoteMuted).toBe(true);
}
}
});
});
});
});

5
packages/backend/test/unit/misc/loader.ts
View file

@ -1,3 +1,8 @@
/*
* SPDX-FileCopyrightText: syuilo and misskey-project
* SPDX-License-Identifier: AGPL-3.0-only
*/
import { DebounceLoader } from '@/misc/loader.js';
class Mock {