Added tests to schedule service and controller

Author: michu2k

src/booking/booking.service.spec.ts

@@ -23,16 +23,14 @@ describe("BookingService", () => {
     let findAllBookingsSpy: jest.SpyInstance;
 
     beforeEach(() => {
-      findAllBookingsSpy = jest
-        .spyOn(service, "findAllBookings")
-        .mockResolvedValue([mockBooking, mockBooking, mockBooking]);
+      findAllBookingsSpy = jest.spyOn(service, "findAllBookings").mockResolvedValue([mockBooking, mockBooking]);
     });
 
     it("should get all bookings", async () => {
       const result = await service.findAllBookings();
 
       expect(findAllBookingsSpy).toHaveBeenCalled();
-      expect(result).toEqual([mockBooking, mockBooking, mockBooking]);
+      expect(result).toEqual([mockBooking, mockBooking]);
     });
 
     it("should get bookings with the specified limit", async () => {

src/location/location.service.spec.ts

@@ -23,16 +23,14 @@ describe("LocationService", () => {
     let findAllLocationsSpy: jest.SpyInstance;
 
     beforeEach(() => {
-      findAllLocationsSpy = jest
-        .spyOn(service, "findAllLocations")
-        .mockResolvedValue([mockLocation, mockLocation, mockLocation]);
+      findAllLocationsSpy = jest.spyOn(service, "findAllLocations").mockResolvedValue([mockLocation, mockLocation]);
     });
 
     it("should get all locations", async () => {
       const result = await service.findAllLocations();
 
       expect(findAllLocationsSpy).toHaveBeenCalled();
-      expect(result).toEqual([mockLocation, mockLocation, mockLocation]);
+      expect(result).toEqual([mockLocation, mockLocation]);
     });
 
     it("should get all locations with specified limit", async () => {

src/schedule/schedule.controller.spec.ts

@@ -0,0 +1,55 @@
+import { Test } from "@nestjs/testing";
+
+import { ScheduleController } from "./schedule.controller";
+import { mockSchedule, mockUpdateSchedule } from "./schedule.mocks";
+import { ScheduleService } from "./schedule.service";
+
+describe("ScheduleController", () => {
+  let controller: ScheduleController;
+  let scheduleService: ScheduleService;
+
+  const mockScheduleService = {
+    findSchedule: jest.fn().mockResolvedValue([mockSchedule, mockSchedule]),
+    updateSchedule: jest.fn((_, data) => Promise.resolve({ ...mockSchedule, ...data }))
+  };
+
+  beforeEach(async () => {
+    const moduleRef = await Test.createTestingModule({
+      providers: [
+        {
+          provide: ScheduleService,
+          useValue: mockScheduleService
+        }
+      ],
+      controllers: [ScheduleController]
+    }).compile();
+
+    controller = moduleRef.get(ScheduleController);
+    scheduleService = moduleRef.get(ScheduleService);
+  });
+
+  it("should be defined", () => {
+    expect(controller).toBeDefined();
+  });
+
+  it("scheduleService should be defined", () => {
+    expect(scheduleService).toBeDefined();
+  });
+
+  describe("findAll", () => {
+    it("should get schedule for a service with the specified id", async () => {
+      const result = await controller.findAll(mockSchedule.serviceId);
+
+      expect(scheduleService.findSchedule).toHaveBeenCalled();
+      expect(result).toEqual([mockSchedule, mockSchedule]);
+    });
+  });
+
+  describe("update", () => {
+    it("should update a schedule", async () => {
+      const result = await controller.update(mockSchedule.id, mockUpdateSchedule);
+
+      expect(result).toEqual({ ...mockSchedule, ...mockUpdateSchedule });
+    });
+  });
+});

src/schedule/schedule.service.spec.ts

@@ -0,0 +1,52 @@
+import { Test } from "@nestjs/testing";
+
+import { PrismaService } from "../prisma/prisma.service";
+import { mockSchedule, mockUpdateSchedule } from "./schedule.mocks";
+import { ScheduleService } from "./schedule.service";
+
+describe("ScheduleService", () => {
+  let service: ScheduleService;
+
+  beforeEach(async () => {
+    const moduleRef = await Test.createTestingModule({
+      providers: [ScheduleService, PrismaService]
+    }).compile();
+
+    service = moduleRef.get(ScheduleService);
+  });
+
+  it("should be defined", () => {
+    expect(service).toBeDefined();
+  });
+
+  describe("findSchedule", () => {
+    it("should get a schedule", async () => {
+      const findScheduleSpy = jest.spyOn(service, "findSchedule").mockResolvedValue([mockSchedule, mockSchedule]);
+      const result = await service.findSchedule({ serviceId: mockSchedule.serviceId });
+
+      expect(findScheduleSpy).toHaveBeenCalled();
+      expect(result).toEqual([mockSchedule, mockSchedule]);
+    });
+  });
+
+  describe("createSchedule", () => {
+    it("should create a schedule", async () => {
+      const createScheduleSpy = jest.spyOn(service, "createSchedule").mockResolvedValue([mockSchedule, mockSchedule]);
+      const result = await service.createSchedule(mockSchedule.serviceId);
+
+      expect(createScheduleSpy).toHaveBeenCalledWith(mockSchedule.serviceId);
+      expect(result).toEqual([mockSchedule, mockSchedule]);
+    });
+  });
+
+  describe("updateSchedule", () => {
+    it("should update a schedule", async () => {
+      const mockUpdatedSchedule = { ...mockSchedule, ...mockUpdateSchedule };
+      const updateScheduleSpy = jest.spyOn(service, "updateSchedule").mockResolvedValue(mockUpdatedSchedule);
+      const result = await service.updateSchedule(mockSchedule.id, mockUpdateSchedule);
+
+      expect(updateScheduleSpy).toHaveBeenCalledWith(mockSchedule.id, mockUpdateSchedule);
+      expect(result).toEqual(mockUpdatedSchedule);
+    });
+  });
+});

src/service/service.service.spec.ts

@@ -1,6 +1,7 @@
 import { Test } from "@nestjs/testing";
 
 import { PrismaService } from "../prisma/prisma.service";
+import { ScheduleService } from "../schedule/schedule.service";
 import { mockCreateService, mockService, mockUpdateService } from "./service.mocks";
 import { ServiceService } from "./service.service";
 
@@ -9,7 +10,7 @@ describe("ServiceService", () => {
 
   beforeEach(async () => {
     const moduleRef = await Test.createTestingModule({
-      providers: [ServiceService, PrismaService]
+      providers: [ServiceService, PrismaService, ScheduleService]
     }).compile();
 
     service = moduleRef.get(ServiceService);
@@ -23,16 +24,14 @@ describe("ServiceService", () => {
     let findAllServicesSpy: jest.SpyInstance;
 
     beforeEach(() => {
-      findAllServicesSpy = jest
-        .spyOn(service, "findAllServices")
-        .mockResolvedValue([mockService, mockService, mockService]);
+      findAllServicesSpy = jest.spyOn(service, "findAllServices").mockResolvedValue([mockService, mockService]);
     });
 
     it("should get all services", async () => {
       const result = await service.findAllServices();
 
       expect(findAllServicesSpy).toHaveBeenCalled();
-      expect(result).toEqual([mockService, mockService, mockService]);
+      expect(result).toEqual([mockService, mockService]);
     });
 
     it("should get all services with specified limit", async () => {