add unittest
This commit is contained in:
おさむのひと
parent
3613409eed
commit
86b92381e3
|
|
@ -0,0 +1,369 @@
|
|||
/*
|
||||
* SPDX-FileCopyrightText: syuilo and misskey-project
|
||||
* SPDX-License-Identifier: AGPL-3.0-only
|
||||
*/
|
||||
|
||||
import { describe, jest, expect, beforeAll, beforeEach, afterEach, afterAll, test } from '@jest/globals';
|
||||
import { Test, TestingModule } from '@nestjs/testing';
|
||||
import { randomString } from '../utils.js';
|
||||
import { NoteMutingService } from '@/core/note/NoteMutingService.js';
|
||||
import {
|
||||
MiNoteMuting,
|
||||
MiNote,
|
||||
MiUser,
|
||||
NoteMutingsRepository,
|
||||
NotesRepository,
|
||||
UsersRepository,
|
||||
} from '@/models/_.js';
|
||||
import { DI } from '@/di-symbols.js';
|
||||
import { GlobalModule } from '@/GlobalModule.js';
|
||||
import { CoreModule } from '@/core/CoreModule.js';
|
||||
import { IdService } from '@/core/IdService.js';
|
||||
import { GlobalEventService } from '@/core/GlobalEventService.js';
|
||||
import { QueryService } from '@/core/QueryService.js';
|
||||
|
||||
process.env.NODE_ENV = 'test';
|
||||
|
||||
describe('NoteMutingService', () => {
|
||||
let app: TestingModule;
|
||||
let service: NoteMutingService;
|
||||
|
||||
// --------------------------------------------------------------------------------------
|
||||
|
||||
let notesRepository: NotesRepository;
|
||||
let noteMutingsRepository: NoteMutingsRepository;
|
||||
let usersRepository: UsersRepository;
|
||||
let idService: IdService;
|
||||
let globalEventService: GlobalEventService;
|
||||
let queryService: QueryService;
|
||||
|
||||
// --------------------------------------------------------------------------------------
|
||||
|
||||
// Helper function to create a user
|
||||
async function createUser(data: Partial<MiUser> = {}): Promise<MiUser> {
|
||||
const user = {
|
||||
id: idService.gen(),
|
||||
username: randomString(),
|
||||
usernameLower: randomString().toLowerCase(),
|
||||
host: null,
|
||||
...data,
|
||||
};
|
||||
|
||||
return await usersRepository.insert(user)
|
||||
.then(x => usersRepository.findOneByOrFail(x.identifiers[0]));
|
||||
}
|
||||
|
||||
// Helper function to create a note
|
||||
async function createNote(data: Partial<MiNote> = {}): Promise<MiNote> {
|
||||
return await notesRepository.insert({
|
||||
id: idService.gen(),
|
||||
userId: data.userId ?? (await createUser()).id,
|
||||
text: randomString(),
|
||||
visibility: 'public',
|
||||
...data,
|
||||
})
|
||||
.then(x => notesRepository.findOneByOrFail(x.identifiers[0]));
|
||||
}
|
||||
|
||||
// Helper function to create a note muting
|
||||
async function createNoteMuting(data: Partial<MiNoteMuting> = {}): Promise<MiNoteMuting> {
|
||||
const id = idService.gen();
|
||||
const noteMuting = {
|
||||
id,
|
||||
userId: data.userId || (await createUser()).id,
|
||||
noteId: data.noteId || (await createNote()).id,
|
||||
expiresAt: null,
|
||||
...data,
|
||||
};
|
||||
|
||||
return await noteMutingsRepository.insert(noteMuting)
|
||||
.then(x => noteMutingsRepository.findOneByOrFail(x.identifiers[0]));
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------------------
|
||||
|
||||
beforeAll(async () => {
|
||||
app = await Test
|
||||
.createTestingModule({
|
||||
imports: [
|
||||
GlobalModule,
|
||||
CoreModule,
|
||||
],
|
||||
})
|
||||
.compile();
|
||||
|
||||
service = app.get(NoteMutingService);
|
||||
idService = app.get(IdService);
|
||||
queryService = app.get(QueryService);
|
||||
globalEventService = app.get(GlobalEventService);
|
||||
notesRepository = app.get(DI.notesRepository);
|
||||
noteMutingsRepository = app.get(DI.noteMutingsRepository);
|
||||
usersRepository = app.get(DI.usersRepository);
|
||||
|
||||
app.enableShutdownHooks();
|
||||
});
|
||||
|
||||
beforeEach(async () => {
|
||||
// Clean database before each test
|
||||
await noteMutingsRepository.delete({});
|
||||
await notesRepository.delete({});
|
||||
await usersRepository.delete({});
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
// Clean database after each test
|
||||
await noteMutingsRepository.delete({});
|
||||
await notesRepository.delete({});
|
||||
await usersRepository.delete({});
|
||||
});
|
||||
|
||||
afterAll(async () => {
|
||||
await app.close();
|
||||
});
|
||||
|
||||
// --------------------------------------------------------------------------------------
|
||||
|
||||
describe('create', () => {
|
||||
test('should create a note muting', async () => {
|
||||
// Create a user and a note
|
||||
const user = await createUser();
|
||||
const note = await createNote();
|
||||
|
||||
// Create a note muting
|
||||
await service.create({
|
||||
userId: user.id,
|
||||
noteId: note.id,
|
||||
expiresAt: null,
|
||||
});
|
||||
|
||||
// Verify the note muting was created
|
||||
const noteMuting = await noteMutingsRepository.findOneBy({
|
||||
userId: user.id,
|
||||
noteId: note.id,
|
||||
});
|
||||
|
||||
expect(noteMuting).not.toBeNull();
|
||||
expect(noteMuting?.userId).toBe(user.id);
|
||||
expect(noteMuting?.noteId).toBe(note.id);
|
||||
});
|
||||
|
||||
test('should throw NoSuchNoteError if note does not exist', async () => {
|
||||
// Create a user
|
||||
const user = await createUser();
|
||||
const nonexistentNoteId = idService.gen();
|
||||
|
||||
// Attempt to create a note muting with a non-existent note
|
||||
await expect(service.create({
|
||||
userId: user.id,
|
||||
noteId: nonexistentNoteId,
|
||||
expiresAt: null,
|
||||
})).rejects.toThrow(NoteMutingService.NoSuchNoteError);
|
||||
|
||||
// Verify no note muting was created
|
||||
const noteMuting = await noteMutingsRepository.findOneBy({
|
||||
userId: user.id,
|
||||
noteId: nonexistentNoteId,
|
||||
});
|
||||
|
||||
expect(noteMuting).toBeNull();
|
||||
});
|
||||
});
|
||||
|
||||
describe('delete', () => {
|
||||
test('should delete a note muting', async () => {
|
||||
// Create a user, note, and note muting
|
||||
const user = await createUser();
|
||||
const note = await createNote();
|
||||
const noteMuting = await createNoteMuting({
|
||||
userId: user.id,
|
||||
noteId: note.id,
|
||||
});
|
||||
|
||||
// Verify the note muting exists
|
||||
const beforeDelete = await noteMutingsRepository.findOneBy({
|
||||
userId: user.id,
|
||||
noteId: note.id,
|
||||
});
|
||||
expect(beforeDelete).not.toBeNull();
|
||||
|
||||
// Delete the note muting
|
||||
await service.delete(user.id, note.id);
|
||||
|
||||
// Verify the note muting was deleted
|
||||
const afterDelete = await noteMutingsRepository.findOneBy({
|
||||
userId: user.id,
|
||||
noteId: note.id,
|
||||
});
|
||||
expect(afterDelete).toBeNull();
|
||||
});
|
||||
|
||||
test('should throw NotMutedError if muting does not exist', async () => {
|
||||
// Create a user and note
|
||||
const user = await createUser();
|
||||
const note = await createNote();
|
||||
|
||||
// Attempt to delete a non-existent note muting
|
||||
await expect(service.delete(user.id, note.id)).rejects.toThrow(NoteMutingService.NotMutedError);
|
||||
});
|
||||
});
|
||||
|
||||
describe('isMuting', () => {
|
||||
test('should return true if user is muting the note', async () => {
|
||||
// Create a user, note, and note muting
|
||||
const user = await createUser();
|
||||
const note = await createNote();
|
||||
await createNoteMuting({
|
||||
userId: user.id,
|
||||
noteId: note.id,
|
||||
});
|
||||
|
||||
// Check if the user is muting the note
|
||||
const result = await service.isMuting(user.id, note.id);
|
||||
|
||||
expect(result).toBe(true);
|
||||
});
|
||||
|
||||
test('should return false if user is not muting the note', async () => {
|
||||
// Create a user and note, but no muting
|
||||
const user = await createUser();
|
||||
const note = await createNote();
|
||||
|
||||
// Check if the user is muting the note
|
||||
const result = await service.isMuting(user.id, note.id);
|
||||
|
||||
expect(result).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('getMutingNoteIdsSet', () => {
|
||||
test('should return a set of muted note IDs', async () => {
|
||||
// Create a user and multiple notes
|
||||
const user = await createUser();
|
||||
const note1 = await createNote();
|
||||
const note2 = await createNote();
|
||||
const note3 = await createNote();
|
||||
|
||||
// Create note mutings for two of the notes
|
||||
await createNoteMuting({
|
||||
userId: user.id,
|
||||
noteId: note1.id,
|
||||
});
|
||||
await createNoteMuting({
|
||||
userId: user.id,
|
||||
noteId: note2.id,
|
||||
});
|
||||
|
||||
// Get the set of muted note IDs
|
||||
const result = await service.getMutingNoteIdsSet(user.id);
|
||||
|
||||
// Verify the result is a Set containing the muted note IDs
|
||||
expect(result).toBeInstanceOf(Set);
|
||||
expect(result.has(note1.id)).toBe(true);
|
||||
expect(result.has(note2.id)).toBe(true);
|
||||
expect(result.has(note3.id)).toBe(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe('listByUserId', () => {
|
||||
test('should return a list of note mutings for a user', async () => {
|
||||
// Create a user and multiple notes
|
||||
const user = await createUser();
|
||||
const note1 = await createNote();
|
||||
const note2 = await createNote();
|
||||
|
||||
// Create note mutings
|
||||
const muting1 = await createNoteMuting({
|
||||
userId: user.id,
|
||||
noteId: note1.id,
|
||||
});
|
||||
const muting2 = await createNoteMuting({
|
||||
userId: user.id,
|
||||
noteId: note2.id,
|
||||
});
|
||||
|
||||
// Get the list of note mutings
|
||||
const result = await service.listByUserId({ userId: user.id });
|
||||
|
||||
// Verify the result contains the expected mutings
|
||||
expect(result).toHaveLength(2);
|
||||
expect(result.map(m => m.id).sort()).toEqual([muting1.id, muting2.id].sort());
|
||||
expect(result.map(m => m.noteId).sort()).toEqual([note1.id, note2.id].sort());
|
||||
});
|
||||
});
|
||||
|
||||
describe('cleanupExpiredMutes', () => {
|
||||
test('should delete expired mutes', async () => {
|
||||
// Create users and notes
|
||||
const user1 = await createUser();
|
||||
const user2 = await createUser();
|
||||
const note1 = await createNote();
|
||||
const note2 = await createNote();
|
||||
const note3 = await createNote();
|
||||
|
||||
// Set the expiration date to 1 hour ago
|
||||
const expiredDate = new Date();
|
||||
expiredDate.setHours(expiredDate.getHours() - 1);
|
||||
|
||||
// Set the expiration date to 1 hour in the future
|
||||
const futureDate = new Date();
|
||||
futureDate.setHours(futureDate.getHours() + 1);
|
||||
|
||||
// Create expired note mutings
|
||||
const expiredMuting1 = await createNoteMuting({
|
||||
userId: user1.id,
|
||||
noteId: note1.id,
|
||||
expiresAt: expiredDate,
|
||||
});
|
||||
|
||||
const expiredMuting2 = await createNoteMuting({
|
||||
userId: user1.id,
|
||||
noteId: note2.id,
|
||||
expiresAt: expiredDate,
|
||||
});
|
||||
|
||||
const expiredMuting3 = await createNoteMuting({
|
||||
userId: user2.id,
|
||||
noteId: note3.id,
|
||||
expiresAt: expiredDate,
|
||||
});
|
||||
|
||||
// Create non-expired note muting
|
||||
const activeMuting = await createNoteMuting({
|
||||
userId: user2.id,
|
||||
noteId: note1.id,
|
||||
expiresAt: futureDate,
|
||||
});
|
||||
|
||||
// Create permanent note muting (no expiration)
|
||||
const permanentMuting = await createNoteMuting({
|
||||
userId: user2.id,
|
||||
noteId: note2.id,
|
||||
expiresAt: null,
|
||||
});
|
||||
|
||||
// Verify all mutings exist before cleanup
|
||||
expect(await noteMutingsRepository.findOneBy({ id: expiredMuting1.id })).not.toBeNull();
|
||||
expect(await noteMutingsRepository.findOneBy({ id: expiredMuting2.id })).not.toBeNull();
|
||||
expect(await noteMutingsRepository.findOneBy({ id: expiredMuting3.id })).not.toBeNull();
|
||||
expect(await noteMutingsRepository.findOneBy({ id: activeMuting.id })).not.toBeNull();
|
||||
expect(await noteMutingsRepository.findOneBy({ id: permanentMuting.id })).not.toBeNull();
|
||||
|
||||
// Run cleanup
|
||||
await service.cleanupExpiredMutes();
|
||||
|
||||
// Verify expired mutings are deleted and others remain
|
||||
expect(await noteMutingsRepository.findOneBy({ id: expiredMuting1.id })).toBeNull();
|
||||
expect(await noteMutingsRepository.findOneBy({ id: expiredMuting2.id })).toBeNull();
|
||||
expect(await noteMutingsRepository.findOneBy({ id: expiredMuting3.id })).toBeNull();
|
||||
expect(await noteMutingsRepository.findOneBy({ id: activeMuting.id })).not.toBeNull();
|
||||
expect(await noteMutingsRepository.findOneBy({ id: permanentMuting.id })).not.toBeNull();
|
||||
|
||||
// Verify cache is updated by checking isMuting
|
||||
expect(await service.isMuting(user1.id, note1.id)).toBe(false);
|
||||
expect(await service.isMuting(user1.id, note2.id)).toBe(false);
|
||||
expect(await service.isMuting(user2.id, note3.id)).toBe(false);
|
||||
expect(await service.isMuting(user2.id, note1.id)).toBe(true);
|
||||
expect(await service.isMuting(user2.id, note2.id)).toBe(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
Loading…
Reference in New Issue