test: add unit tests for history service and controller with mocks

Author: LuizFNJ

server/history/history.controller.spec.ts

@@ -0,0 +1,55 @@
+import { Test } from "@nestjs/testing";
+import { HistoryController } from "./history.controller";
+import { HistoryService } from "./history.service";
+import { historyServiceMock, mockHistoryItem } from "../mocks/HistoryMock";
+
+describe("HistoryController (Unit)", () => {
+  let controller: HistoryController;
+  let historyService: typeof historyServiceMock;
+
+  beforeEach(async () => {
+    const testingModule = await Test.createTestingModule({
+      controllers: [HistoryController],
+      providers: [{ provide: HistoryService, useValue: historyServiceMock }],
+    }).compile();
+
+    controller = testingModule.get(HistoryController);
+    historyService = testingModule.get(HistoryService);
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("getHistory", () => {
+    it("should return history correctly (happy path)", async () => {
+      historyService.getHistoryForTarget.mockResolvedValue({
+        history: [mockHistoryItem],
+        totalChanges: 1,
+        totalPages: 1,
+        page: 1,
+        pageSize: 10,
+      });
+
+      const response = await controller.getHistory(
+        { targetId: "id", targetModel: "Claim" },
+        {}
+      );
+      expect(response.history.length).toBeGreaterThan(0);
+      expect(response.totalChanges).toBeGreaterThanOrEqual(1);
+    });
+
+    it("should throw error if targetId is empty", async () => {
+      await expect(
+        controller.getHistory({ targetId: "", targetModel: "Claim" }, {})
+      ).rejects.toThrow();
+    });
+
+    it("should throw error if service fails", async () => {
+      historyService.getHistoryForTarget.mockRejectedValue(new Error("fail"));
+      await expect(
+        controller.getHistory({ targetId: "id", targetModel: "Claim" }, {})
+      ).rejects.toThrow("fail");
+    });
+  });
+});

server/history/history.service.spec.ts

@@ -0,0 +1,158 @@
+import { getModelToken } from "@nestjs/mongoose";
+import { HistoryService } from "./history.service";
+import { Test, TestingModule } from "@nestjs/testing";
+import { Model } from "mongoose";
+import {
+  mockHistoryResponse,
+  mockAggregateMongoResult,
+  mockHistoryItem,
+  mockHistoryModel,
+} from "../mocks/HistoryMock";
+import { TargetModel, HistoryType } from "./schema/history.schema";
+import { HistoryDocument } from "./schema/history.schema";
+
+describe("HistoryService (Unit)", () => {
+  let service: HistoryService;
+  let testingModule: TestingModule;
+  let model: Model<HistoryDocument>;
+
+  beforeAll(async () => {
+    testingModule = await Test.createTestingModule({
+      providers: [
+        HistoryService,
+        { provide: getModelToken("History"), useValue: mockHistoryModel },
+      ],
+    }).compile();
+
+    model = testingModule.get(getModelToken("History"));
+    service = testingModule.get<HistoryService>(HistoryService);
+  });
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    jest.restoreAllMocks();
+  });
+
+  describe("HistoryService.createHistory", () => {
+    it("should create a new history document and call save", async () => {
+      const result = await service.createHistory(mockHistoryItem);
+
+      const instance = (mockHistoryModel as jest.Mock).mock.instances[0];
+
+      expect(instance.save).toHaveBeenCalled();
+      expect(result._id).toBe("abc");
+    });
+
+    it("should throw if save fails", async () => {
+      const error = new Error("Database error");
+
+      (mockHistoryModel as jest.Mock).mockImplementationOnce(function () {
+        return {
+          save: jest.fn().mockRejectedValue(error),
+        };
+      });
+
+      await expect(service.createHistory(mockHistoryItem)).rejects.toThrow(
+        "Database error"
+      );
+    });
+  });
+
+  describe("HistoryService.getHistoryParams", () => {
+    it("should throw for invalid dataId", () => {
+      const invalidId = "not-a-valid-id";
+      expect(() =>
+        service.getHistoryParams(
+          invalidId,
+          TargetModel.Claim,
+          null,
+          HistoryType.Create,
+          { some: "value" }
+        )
+      ).toThrow(`Invalid dataId received: ${invalidId}`);
+    });
+
+    it("should return correct params for valid dataId", () => {
+      const validId = mockHistoryItem.targetId.toString();
+      const params = service.getHistoryParams(
+        validId,
+        TargetModel.Claim,
+        null,
+        HistoryType.Update,
+        { some: "latest" },
+        { some: "previous" }
+      );
+
+      expect(params).toHaveProperty("targetId");
+      expect(params.targetModel).toBe(TargetModel.Claim);
+      expect(params.details.after).toEqual({ some: "latest" });
+      expect(params.details.before).toEqual({ some: "previous" });
+    });
+  });
+
+  describe("HistoryService.getDescriptionForHide", () => {
+    it("should return empty string when content missing or not hidden", async () => {
+      const responseWithoutContent = await service.getDescriptionForHide(
+        {},
+        TargetModel.Claim
+      );
+      expect(responseWithoutContent).toBe("");
+
+      const responseHidden = await service.getDescriptionForHide(
+        { content: mockHistoryItem._id, isHidden: false },
+        TargetModel.Claim
+      );
+      expect(responseHidden).toBe("");
+    });
+
+    it("should return description from history when hidden", async () => {
+      jest
+        .spyOn(service, "getHistoryForTarget")
+        .mockResolvedValue(mockHistoryResponse);
+
+      const response = await service.getDescriptionForHide(
+        { _id: mockHistoryItem._id, isHidden: true },
+        TargetModel.Claim
+      );
+      expect(response).toBe(
+        mockHistoryResponse.history[0].details.after.description
+      );
+    });
+  });
+
+  describe("HistoryService.getHistoryForTarget", () => {
+    it("should return paginated history and counts", async () => {
+      mockHistoryModel.aggregate.mockResolvedValueOnce(
+        mockAggregateMongoResult
+      );
+
+      const res = await service.getHistoryForTarget(
+        mockHistoryItem.targetId.toString(),
+        TargetModel.Claim,
+        { page: 0, pageSize: 10, order: "asc" }
+      );
+
+      expect(res.history).toEqual([mockHistoryItem]);
+      expect(res.totalChanges).toBe(1);
+      expect(res.totalPages).toBe(1);
+      expect(res.page).toBe(0);
+      expect(res.pageSize).toBe(10);
+    });
+
+    it("should handle empty aggregate result", async () => {
+      (mockHistoryModel.aggregate as jest.Mock).mockResolvedValue(
+        [{ data: [], totalCount: [] }]
+      );
+
+      const res = await service.getHistoryForTarget(
+        mockHistoryItem.targetId.toString(),
+        TargetModel.Claim,
+        { page: 0, pageSize: 10, order: "asc" }
+      );
+
+      expect(res.history).toEqual([]);
+      expect(res.totalChanges).toBe(0);
+      expect(res.totalPages).toBe(0);
+    });
+  });
+});

server/mocks/HistoryMock.ts

@@ -0,0 +1,50 @@
+import { HistoryType, TargetModel } from "../history/schema/history.schema";
+import { Types } from "mongoose";
+
+export const historyServiceMock = {
+  getHistoryForTarget: jest.fn(),
+};
+
+export const mockHistoryItem = {
+  _id: "23432",
+  targetId: new Types.ObjectId(),
+  targetModel: TargetModel.Claim,
+  type: HistoryType.Update,
+  details: { after: { description: "new" }, before: { description: "old" } },
+  date: new Date(),
+};
+
+export const mockHistoryResponse = {
+  history: [mockHistoryItem],
+  totalChanges: 1,
+  totalPages: 1,
+  page: 0,
+  pageSize: 10,
+};
+
+export const mockAggregateMongoResult = [
+  {
+    data: [mockHistoryItem],
+    totalCount: [{ total: 1 }],
+  },
+];
+
+type MockedModel = jest.Mock & {
+  aggregate: jest.Mock;
+};
+
+export const mockHistoryModel = jest.fn() as MockedModel;
+
+mockHistoryModel.mockImplementation(function (this: any, data) {
+  this.save = jest.fn().mockResolvedValue({
+    ...mockHistoryItem,
+    _id: "abc",
+  });
+});
+
+mockHistoryModel.aggregate = jest.fn();
+
+
+
+
+