memegoat/backend/src/common/services/purge.service.spec.ts

import { Logger } from "@nestjs/common";
import { Test, TestingModule } from "@nestjs/testing";
import { ContentsRepository } from "../../contents/repositories/contents.repository";
import { ReportsRepository } from "../../reports/repositories/reports.repository";
import { SessionsRepository } from "../../sessions/repositories/sessions.repository";
import { UsersRepository } from "../../users/repositories/users.repository";
import { PurgeService } from "./purge.service";

describe("PurgeService", () => {
	let service: PurgeService;

	const mockSessionsRepository = {
		purgeExpired: jest.fn().mockResolvedValue([]),
	};
	const mockReportsRepository = {
		purgeObsolete: jest.fn().mockResolvedValue([]),
	};
	const mockUsersRepository = { purgeDeleted: jest.fn().mockResolvedValue([]) };
	const mockContentsRepository = {
		purgeSoftDeleted: jest.fn().mockResolvedValue([]),
	};

	beforeEach(async () => {
		jest.clearAllMocks();
		jest.spyOn(Logger.prototype, "error").mockImplementation(() => {});
		jest.spyOn(Logger.prototype, "log").mockImplementation(() => {});

		const module: TestingModule = await Test.createTestingModule({
			providers: [
				PurgeService,
				{ provide: SessionsRepository, useValue: mockSessionsRepository },
				{ provide: ReportsRepository, useValue: mockReportsRepository },
				{ provide: UsersRepository, useValue: mockUsersRepository },
				{ provide: ContentsRepository, useValue: mockContentsRepository },
			],
		}).compile();

		service = module.get<PurgeService>(PurgeService);
	});

	it("should be defined", () => {
		expect(service).toBeDefined();
	});

	describe("purgeExpiredData", () => {
		it("should purge data using repositories", async () => {
			mockSessionsRepository.purgeExpired.mockResolvedValue([{ id: "s1" }]);
			mockReportsRepository.purgeObsolete.mockResolvedValue([{ id: "r1" }]);
			mockUsersRepository.purgeDeleted.mockResolvedValue([{ id: "u1" }]);
			mockContentsRepository.purgeSoftDeleted.mockResolvedValue([{ id: "c1" }]);

			await service.purgeExpiredData();

			expect(mockSessionsRepository.purgeExpired).toHaveBeenCalled();
			expect(mockReportsRepository.purgeObsolete).toHaveBeenCalled();
			expect(mockUsersRepository.purgeDeleted).toHaveBeenCalled();
			expect(mockContentsRepository.purgeSoftDeleted).toHaveBeenCalled();
		});

		it("should handle errors", async () => {
			mockSessionsRepository.purgeExpired.mockRejectedValue(new Error("Db error"));
			await expect(service.purgeExpiredData()).resolves.not.toThrow();
		});
	});
});