484 lines
17 KiB
TypeScript
484 lines
17 KiB
TypeScript
/*
|
|
* SPDX-FileCopyrightText: syuilo and misskey-project
|
|
* SPDX-License-Identifier: AGPL-3.0-only
|
|
*/
|
|
|
|
import { afterAll, afterEach, beforeAll, describe, expect, test } from '@jest/globals';
|
|
import { Test, TestingModule } from '@nestjs/testing';
|
|
import type { Index, MeiliSearch } from 'meilisearch';
|
|
import { type Config, loadConfig } from '@/config.js';
|
|
import { GlobalModule } from '@/GlobalModule.js';
|
|
import { CoreModule } from '@/core/CoreModule.js';
|
|
import { SearchService } from '@/core/SearchService.js';
|
|
import { CacheService } from '@/core/CacheService.js';
|
|
import { IdService } from '@/core/IdService.js';
|
|
import { DI } from '@/di-symbols.js';
|
|
import {
|
|
type BlockingsRepository,
|
|
type ChannelsRepository,
|
|
type FollowingsRepository,
|
|
type MutingsRepository,
|
|
type NotesRepository,
|
|
type UserProfilesRepository,
|
|
type UsersRepository,
|
|
type MiChannel,
|
|
type MiNote,
|
|
type MiUser,
|
|
} from '@/models/_.js';
|
|
|
|
describe('SearchService', () => {
|
|
type TestContext = {
|
|
app: TestingModule;
|
|
service: SearchService;
|
|
cacheService: CacheService;
|
|
idService: IdService;
|
|
mutingsRepository: MutingsRepository;
|
|
blockingsRepository: BlockingsRepository;
|
|
usersRepository: UsersRepository;
|
|
userProfilesRepository: UserProfilesRepository;
|
|
notesRepository: NotesRepository;
|
|
channelsRepository: ChannelsRepository;
|
|
followingsRepository: FollowingsRepository;
|
|
indexer?: (note: MiNote) => Promise<void>;
|
|
};
|
|
|
|
const meilisearchSettings = {
|
|
searchableAttributes: [
|
|
'text',
|
|
'cw',
|
|
],
|
|
sortableAttributes: [
|
|
'createdAt',
|
|
],
|
|
filterableAttributes: [
|
|
'createdAt',
|
|
'userId',
|
|
'userHost',
|
|
'channelId',
|
|
'tags',
|
|
],
|
|
typoTolerance: {
|
|
enabled: false,
|
|
},
|
|
pagination: {
|
|
maxTotalHits: 10000,
|
|
},
|
|
};
|
|
|
|
async function buildContext(configOverride?: Config): Promise<TestContext> {
|
|
const builder = Test.createTestingModule({
|
|
imports: [
|
|
GlobalModule,
|
|
CoreModule,
|
|
],
|
|
});
|
|
|
|
if (configOverride) {
|
|
builder.overrideProvider(DI.config).useValue(configOverride);
|
|
}
|
|
|
|
const app = await builder.compile();
|
|
|
|
app.enableShutdownHooks();
|
|
|
|
return {
|
|
app,
|
|
service: app.get(SearchService),
|
|
cacheService: app.get(CacheService),
|
|
idService: app.get(IdService),
|
|
mutingsRepository: app.get(DI.mutingsRepository),
|
|
blockingsRepository: app.get(DI.blockingsRepository),
|
|
usersRepository: app.get(DI.usersRepository),
|
|
userProfilesRepository: app.get(DI.userProfilesRepository),
|
|
notesRepository: app.get(DI.notesRepository),
|
|
channelsRepository: app.get(DI.channelsRepository),
|
|
followingsRepository: app.get(DI.followingsRepository),
|
|
};
|
|
}
|
|
|
|
async function cleanupContext(ctx: TestContext) {
|
|
await ctx.notesRepository.createQueryBuilder().delete().execute();
|
|
await ctx.mutingsRepository.createQueryBuilder().delete().execute();
|
|
await ctx.blockingsRepository.createQueryBuilder().delete().execute();
|
|
await ctx.followingsRepository.createQueryBuilder().delete().execute();
|
|
await ctx.channelsRepository.createQueryBuilder().delete().execute();
|
|
await ctx.userProfilesRepository.createQueryBuilder().delete().execute();
|
|
await ctx.usersRepository.createQueryBuilder().delete().execute();
|
|
}
|
|
|
|
async function createUser(ctx: TestContext, data: Partial<MiUser> = {}) {
|
|
const id = ctx.idService.gen();
|
|
const username = data.username ?? `user_${id}`;
|
|
const usernameLower = data.usernameLower ?? username.toLowerCase();
|
|
|
|
const user = await ctx.usersRepository
|
|
.insert({
|
|
id,
|
|
username,
|
|
usernameLower,
|
|
...data,
|
|
})
|
|
.then(x => ctx.usersRepository.findOneByOrFail(x.identifiers[0]));
|
|
|
|
await ctx.userProfilesRepository.insert({
|
|
userId: id,
|
|
});
|
|
|
|
return user;
|
|
}
|
|
|
|
async function createChannel(ctx: TestContext, user: MiUser, data: Partial<MiChannel> = {}) {
|
|
const id = ctx.idService.gen();
|
|
const channel = await ctx.channelsRepository
|
|
.insert({
|
|
id,
|
|
userId: user.id,
|
|
name: data.name ?? `channel_${id}`,
|
|
...data,
|
|
})
|
|
.then(x => ctx.channelsRepository.findOneByOrFail(x.identifiers[0]));
|
|
|
|
return channel;
|
|
}
|
|
|
|
async function createNote(ctx: TestContext, user: MiUser, data: Partial<MiNote> = {}, time?: number) {
|
|
const id = time == null ? ctx.idService.gen() : ctx.idService.gen(time);
|
|
const note = await ctx.notesRepository
|
|
.insert({
|
|
id,
|
|
text: 'hello',
|
|
userId: user.id,
|
|
userHost: user.host,
|
|
visibility: 'public',
|
|
tags: [],
|
|
...data,
|
|
})
|
|
.then(x => ctx.notesRepository.findOneByOrFail(x.identifiers[0]));
|
|
|
|
if (ctx.indexer) {
|
|
await ctx.indexer(note);
|
|
}
|
|
|
|
return note;
|
|
}
|
|
|
|
async function createFollowing(ctx: TestContext, follower: MiUser, followee: MiUser) {
|
|
await ctx.followingsRepository.insert({
|
|
id: ctx.idService.gen(),
|
|
followerId: follower.id,
|
|
followeeId: followee.id,
|
|
followerHost: follower.host,
|
|
followeeHost: followee.host,
|
|
});
|
|
}
|
|
|
|
function clearUserCaches(ctx: TestContext, userId: MiUser['id']) {
|
|
ctx.cacheService.userMutingsCache.delete(userId);
|
|
ctx.cacheService.userBlockedCache.delete(userId);
|
|
ctx.cacheService.userBlockingCache.delete(userId);
|
|
}
|
|
|
|
async function createMuting(ctx: TestContext, muter: MiUser, mutee: MiUser) {
|
|
await ctx.mutingsRepository.insert({
|
|
id: ctx.idService.gen(),
|
|
muterId: muter.id,
|
|
muteeId: mutee.id,
|
|
});
|
|
clearUserCaches(ctx, muter.id);
|
|
}
|
|
|
|
async function createBlocking(ctx: TestContext, blocker: MiUser, blockee: MiUser) {
|
|
await ctx.blockingsRepository.insert({
|
|
id: ctx.idService.gen(),
|
|
blockerId: blocker.id,
|
|
blockeeId: blockee.id,
|
|
});
|
|
clearUserCaches(ctx, blocker.id);
|
|
clearUserCaches(ctx, blockee.id);
|
|
}
|
|
|
|
function defineSearchNoteTests(
|
|
getCtx: () => TestContext,
|
|
{
|
|
supportsFollowersVisibility,
|
|
sinceIdOrder,
|
|
}: {
|
|
supportsFollowersVisibility: boolean;
|
|
sinceIdOrder: 'asc' | 'desc';
|
|
},
|
|
) {
|
|
describe('searchNote', () => {
|
|
test('filters notes by visibility (followers only visible to followers)', async () => {
|
|
const ctx = getCtx();
|
|
const me = await createUser(ctx, { username: 'me', usernameLower: 'me', host: null });
|
|
const author = await createUser(ctx, { username: 'author', usernameLower: 'author', host: null });
|
|
|
|
const publicNote = await createNote(ctx, author, { text: 'hello public', visibility: 'public' });
|
|
const followersNote = await createNote(ctx, author, { text: 'hello followers', visibility: 'followers' });
|
|
|
|
const beforeFollow = await ctx.service.searchNote('hello', me, {}, { limit: 10 });
|
|
expect(beforeFollow.map(note => note.id)).toEqual([publicNote.id]);
|
|
|
|
await createFollowing(ctx, me, author);
|
|
|
|
const afterFollow = await ctx.service.searchNote('hello', me, {}, { limit: 10 });
|
|
const expectedIds = supportsFollowersVisibility
|
|
? [followersNote.id, publicNote.id]
|
|
: [publicNote.id];
|
|
expect(afterFollow.map(note => note.id).sort()).toEqual(expectedIds.sort());
|
|
});
|
|
|
|
test('filters out suspended users via base note filtering', async () => {
|
|
const ctx = getCtx();
|
|
const me = await createUser(ctx, { username: 'me', usernameLower: 'me', host: null });
|
|
const active = await createUser(ctx, { username: 'active', usernameLower: 'active', host: null });
|
|
const suspended = await createUser(ctx, { username: 'suspended', usernameLower: 'suspended', host: null, isSuspended: true });
|
|
|
|
const activeNote = await createNote(ctx, active, { text: 'hello active', visibility: 'public' });
|
|
await createNote(ctx, suspended, { text: 'hello suspended', visibility: 'public' });
|
|
|
|
const result = await ctx.service.searchNote('hello', me, {}, { limit: 10 });
|
|
expect(result.map(note => note.id)).toEqual([activeNote.id]);
|
|
});
|
|
|
|
test('filters by userId', async () => {
|
|
const ctx = getCtx();
|
|
const me = await createUser(ctx, { username: 'me', usernameLower: 'me', host: null });
|
|
const alice = await createUser(ctx, { username: 'alice', usernameLower: 'alice', host: null });
|
|
const bob = await createUser(ctx, { username: 'bob', usernameLower: 'bob', host: null });
|
|
|
|
const aliceNote = await createNote(ctx, alice, { text: 'hello alice', visibility: 'public' });
|
|
await createNote(ctx, bob, { text: 'hello bob', visibility: 'public' });
|
|
|
|
const result = await ctx.service.searchNote('hello', me, { userId: alice.id }, { limit: 10 });
|
|
expect(result.map(note => note.id)).toEqual([aliceNote.id]);
|
|
});
|
|
|
|
test('filters by channelId', async () => {
|
|
const ctx = getCtx();
|
|
const me = await createUser(ctx, { username: 'me', usernameLower: 'me', host: null });
|
|
const author = await createUser(ctx, { username: 'author', usernameLower: 'author', host: null });
|
|
const channelA = await createChannel(ctx, author, { name: 'channel-a' });
|
|
const channelB = await createChannel(ctx, author, { name: 'channel-b' });
|
|
|
|
const channelNote = await createNote(ctx, author, { text: 'hello channel', channelId: channelA.id, visibility: 'public' });
|
|
await createNote(ctx, author, { text: 'hello other', channelId: channelB.id, visibility: 'public' });
|
|
|
|
const result = await ctx.service.searchNote('hello', me, { channelId: channelA.id }, { limit: 10 });
|
|
expect(result.map(note => note.id)).toEqual([channelNote.id]);
|
|
});
|
|
|
|
test('filters by host', async () => {
|
|
const ctx = getCtx();
|
|
const me = await createUser(ctx, { username: 'me', usernameLower: 'me', host: null });
|
|
const local = await createUser(ctx, { username: 'local', usernameLower: 'local', host: null });
|
|
const remote = await createUser(ctx, { username: 'remote', usernameLower: 'remote', host: 'example.com' });
|
|
|
|
const localNote = await createNote(ctx, local, { text: 'hello local', visibility: 'public' });
|
|
const remoteNote = await createNote(ctx, remote, { text: 'hello remote', visibility: 'public', userHost: 'example.com' });
|
|
|
|
const localResult = await ctx.service.searchNote('hello', me, { host: '.' }, { limit: 10 });
|
|
expect(localResult.map(note => note.id)).toEqual([localNote.id]);
|
|
|
|
const remoteResult = await ctx.service.searchNote('hello', me, { host: 'example.com' }, { limit: 10 });
|
|
expect(remoteResult.map(note => note.id)).toEqual([remoteNote.id]);
|
|
});
|
|
|
|
describe('muting and blocking', () => {
|
|
test('filters out muted users', async () => {
|
|
const ctx = getCtx();
|
|
const me = await createUser(ctx, { username: 'me', usernameLower: 'me', host: null });
|
|
const muted = await createUser(ctx, { username: 'muted', usernameLower: 'muted', host: null });
|
|
const other = await createUser(ctx, { username: 'other', usernameLower: 'other', host: null });
|
|
|
|
await createNote(ctx, muted, { text: 'hello muted', visibility: 'public' });
|
|
const otherNote = await createNote(ctx, other, { text: 'hello other', visibility: 'public' });
|
|
|
|
await createMuting(ctx, me, muted);
|
|
|
|
const result = await ctx.service.searchNote('hello', me, {}, { limit: 10 });
|
|
|
|
expect(result.map(note => note.id)).toEqual([otherNote.id]);
|
|
});
|
|
|
|
test('filters out users who block me', async () => {
|
|
const ctx = getCtx();
|
|
const me = await createUser(ctx, { username: 'me', usernameLower: 'me', host: null });
|
|
const blocker = await createUser(ctx, { username: 'blocker', usernameLower: 'blocker', host: null });
|
|
const other = await createUser(ctx, { username: 'other', usernameLower: 'other', host: null });
|
|
|
|
await createNote(ctx, blocker, { text: 'hello blocker', visibility: 'public' });
|
|
const otherNote = await createNote(ctx, other, { text: 'hello other', visibility: 'public' });
|
|
|
|
await createBlocking(ctx, blocker, me);
|
|
|
|
const result = await ctx.service.searchNote('hello', me, {}, { limit: 10 });
|
|
|
|
expect(result.map(note => note.id)).toEqual([otherNote.id]);
|
|
});
|
|
|
|
test('filters no out users I block', async () => {
|
|
const ctx = getCtx();
|
|
const me = await createUser(ctx, { username: 'me', usernameLower: 'me', host: null });
|
|
const blocked = await createUser(ctx, { username: 'blocked', usernameLower: 'blocked', host: null });
|
|
const other = await createUser(ctx, { username: 'other', usernameLower: 'other', host: null });
|
|
|
|
const blockedNote = await createNote(ctx, blocked, { text: 'hello blocked', visibility: 'public' });
|
|
const otherNote = await createNote(ctx, other, { text: 'hello other', visibility: 'public' });
|
|
|
|
await createBlocking(ctx, me, blocked);
|
|
|
|
const result = await ctx.service.searchNote('hello', me, {}, { limit: 10 });
|
|
expect(result.map(note => note.id).sort()).toEqual([otherNote.id, blockedNote.id].sort());
|
|
});
|
|
});
|
|
|
|
describe('pagination', () => {
|
|
test('paginates with sinceId', async () => {
|
|
const ctx = getCtx();
|
|
const me = await createUser(ctx, { username: 'me', usernameLower: 'me', host: null });
|
|
const author = await createUser(ctx, { username: 'author', usernameLower: 'author', host: null });
|
|
|
|
const t1 = Date.now() - 3000;
|
|
const t2 = Date.now() - 2000;
|
|
const t3 = Date.now() - 1000;
|
|
|
|
const note1 = await createNote(ctx, author, { text: 'hello' }, t1);
|
|
const note2 = await createNote(ctx, author, { text: 'hello' }, t2);
|
|
const note3 = await createNote(ctx, author, { text: 'hello' }, t3);
|
|
|
|
const result = await ctx.service.searchNote('hello', me, {}, { limit: 10, sinceId: note1.id });
|
|
|
|
const expected = sinceIdOrder === 'asc'
|
|
? [note2.id, note3.id]
|
|
: [note3.id, note2.id];
|
|
expect(result.map(note => note.id)).toEqual(expected);
|
|
});
|
|
|
|
test('paginates with untilId', async () => {
|
|
const ctx = getCtx();
|
|
const me = await createUser(ctx, { username: 'me', usernameLower: 'me', host: null });
|
|
const author = await createUser(ctx, { username: 'author', usernameLower: 'author', host: null });
|
|
|
|
const t1 = Date.now() - 3000;
|
|
const t2 = Date.now() - 2000;
|
|
const t3 = Date.now() - 1000;
|
|
|
|
const note1 = await createNote(ctx, author, { text: 'hello' }, t1);
|
|
const note2 = await createNote(ctx, author, { text: 'hello' }, t2);
|
|
const note3 = await createNote(ctx, author, { text: 'hello' }, t3);
|
|
|
|
const result = await ctx.service.searchNote('hello', me, {}, { limit: 10, untilId: note3.id });
|
|
|
|
expect(result.map(note => note.id)).toEqual([note2.id, note1.id]);
|
|
});
|
|
|
|
test('paginates with sinceId and untilId together', async () => {
|
|
const ctx = getCtx();
|
|
const me = await createUser(ctx, { username: 'me', usernameLower: 'me', host: null });
|
|
const author = await createUser(ctx, { username: 'author', usernameLower: 'author', host: null });
|
|
|
|
const t1 = Date.now() - 4000;
|
|
const t2 = Date.now() - 3000;
|
|
const t3 = Date.now() - 2000;
|
|
const t4 = Date.now() - 1000;
|
|
|
|
const note1 = await createNote(ctx, author, { text: 'hello' }, t1);
|
|
const note2 = await createNote(ctx, author, { text: 'hello' }, t2);
|
|
const note3 = await createNote(ctx, author, { text: 'hello' }, t3);
|
|
const note4 = await createNote(ctx, author, { text: 'hello' }, t4);
|
|
|
|
const result = await ctx.service.searchNote('hello', me, {}, { limit: 10, sinceId: note1.id, untilId: note4.id });
|
|
|
|
expect(result.map(note => note.id)).toEqual([note3.id, note2.id]);
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
describe('sqlLike', () => {
|
|
let ctx: TestContext;
|
|
|
|
beforeAll(async () => {
|
|
ctx = await buildContext();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await ctx.app.close();
|
|
});
|
|
|
|
afterEach(async () => {
|
|
await cleanupContext(ctx);
|
|
});
|
|
|
|
defineSearchNoteTests(() => ctx, { supportsFollowersVisibility: true, sinceIdOrder: 'asc' });
|
|
});
|
|
|
|
describe('meilisearch', () => {
|
|
let ctx: TestContext;
|
|
let meilisearch: MeiliSearch;
|
|
let meilisearchIndex: Index;
|
|
let meiliConfig: Config;
|
|
|
|
beforeAll(async () => {
|
|
const baseConfig = loadConfig();
|
|
meiliConfig = {
|
|
...baseConfig,
|
|
fulltextSearch: {
|
|
provider: 'meilisearch',
|
|
},
|
|
meilisearch: {
|
|
host: '127.0.0.1',
|
|
port: '57712',
|
|
apiKey: '',
|
|
index: 'test-search-service',
|
|
scope: 'global',
|
|
ssl: false,
|
|
},
|
|
};
|
|
|
|
ctx = await buildContext(meiliConfig);
|
|
meilisearch = ctx.app.get(DI.meilisearch) as MeiliSearch;
|
|
meilisearchIndex = meilisearch.index(`${meiliConfig.meilisearch!.index}---notes`);
|
|
|
|
const settingsTask = await meilisearchIndex.updateSettings(meilisearchSettings);
|
|
await meilisearch.tasks.waitForTask(settingsTask.taskUid);
|
|
|
|
const clearTask = await meilisearchIndex.deleteAllDocuments();
|
|
await meilisearch.tasks.waitForTask(clearTask.taskUid);
|
|
|
|
ctx.indexer = async (note: MiNote) => {
|
|
if (note.text == null && note.cw == null) return;
|
|
if (!['home', 'public'].includes(note.visibility)) return;
|
|
if (meiliConfig.meilisearch?.scope === 'local' && note.userHost != null) return;
|
|
|
|
const task = await meilisearchIndex.addDocuments([{
|
|
id: note.id,
|
|
createdAt: ctx.idService.parse(note.id).date.getTime(),
|
|
userId: note.userId,
|
|
userHost: note.userHost,
|
|
channelId: note.channelId,
|
|
cw: note.cw,
|
|
text: note.text,
|
|
tags: note.tags,
|
|
}], {
|
|
primaryKey: 'id',
|
|
});
|
|
await meilisearch.tasks.waitForTask(task.taskUid);
|
|
};
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await ctx.app.close();
|
|
});
|
|
|
|
afterEach(async () => {
|
|
await cleanupContext(ctx);
|
|
const clearTask = await meilisearchIndex.deleteAllDocuments();
|
|
await meilisearch.tasks.waitForTask(clearTask.taskUid);
|
|
});
|
|
|
|
defineSearchNoteTests(() => ctx, { supportsFollowersVisibility: false, sinceIdOrder: 'desc' });
|
|
});
|
|
});
|