@blackcode_sa/metaestetics-api 1.12.65 → 1.12.67

package/src/services/clinic/__tests__/clinic-admin.service.test.ts

@@ -1,287 +1,287 @@
-import { ClinicAdminService } from "../clinic-admin.service";
-import { mockDb, mockTimestamp } from "../../../config/__mocks__/firebase";
-import { getFirebaseInstance } from "../../../config/firebase";
-import {
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  query,
-  where,
-  updateDoc,
-  setDoc,
-} from "firebase/firestore";
-import {
-  CreateClinicAdminData,
-  ClinicAdmin,
-} from "../../../types/clinic-admin";
-import { CLINIC_ADMIN_ERRORS } from "../../../errors/clinic.errors";
-
-// Mock Firebase
-jest.mock("firebase/firestore");
-jest.mock("../../../config/firebase");
-
-describe("ClinicAdminService", () => {
-  let clinicAdminService: ClinicAdminService;
-
-  const mockClinicAdmin: ClinicAdmin = {
-    id: "test-admin-id",
-    userRef: "test-user-id",
-    clinicGroupId: "test-group-id",
-    isGroupOwner: false,
-    clinicsManaged: ["clinic-1", "clinic-2"],
-    contactInfo: {
-      firstName: "John",
-      lastName: "Doe",
-      title: "Admin",
-      email: "john@example.com",
-      phoneNumber: "+1234567890",
-    },
-    roleTitle: "Clinic Administrator",
-    isActive: true,
-    createdAt: mockTimestamp.now().toDate(),
-    updatedAt: mockTimestamp.now().toDate(),
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-
-    (getFirebaseInstance as jest.Mock).mockResolvedValue({
-      db: mockDb,
-      auth: {},
-      app: {},
-      analytics: null,
-    });
-
-    clinicAdminService = new ClinicAdminService();
-
-    // Mock Firestore functions
-    (doc as jest.Mock).mockReturnValue("doc-ref");
-    (collection as jest.Mock).mockReturnValue("collection-ref");
-    (query as jest.Mock).mockReturnValue("query-ref");
-    (where as jest.Mock).mockReturnValue("where-clause");
-    (setDoc as jest.Mock).mockResolvedValue(undefined);
-    (updateDoc as jest.Mock).mockResolvedValue(undefined);
-
-    // Mock getDoc response
-    (getDoc as jest.Mock).mockResolvedValue({
-      exists: () => true,
-      data: () => ({
-        ...mockClinicAdmin,
-        createdAt: mockTimestamp.now(),
-        updatedAt: mockTimestamp.now(),
-      }),
-      id: mockClinicAdmin.id,
-    });
-
-    // Mock getDocs response
-    (getDocs as jest.Mock).mockResolvedValue({
-      docs: [
-        {
-          exists: () => true,
-          data: () => ({
-            ...mockClinicAdmin,
-            createdAt: mockTimestamp.now(),
-            updatedAt: mockTimestamp.now(),
-          }),
-          id: mockClinicAdmin.id,
-        },
-      ],
-    });
-  });
-
-  describe("createClinicAdmin", () => {
-    it("treba da kreira novog clinic admina", async () => {
-      const adminData: CreateClinicAdminData = {
-        userRef: "test-user-id",
-        clinicGroupId: "",
-        isGroupOwner: false,
-        clinicsManaged: [],
-        contactInfo: {
-          firstName: "John",
-          lastName: "Doe",
-          title: "Admin",
-          email: "john@example.com",
-          phoneNumber: "+1234567890",
-        },
-        roleTitle: "Clinic Administrator",
-        isActive: true,
-      };
-
-      const result = await clinicAdminService.createClinicAdmin(adminData);
-
-      expect(setDoc).toHaveBeenCalled();
-      expect(result).toEqual(
-        expect.objectContaining({
-          id: expect.any(String),
-          ...adminData,
-          createdAt: expect.any(Date),
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-  });
-
-  describe("getClinicAdmin", () => {
-    it("treba da vrati clinic admina po ID-u", async () => {
-      const result = await clinicAdminService.getClinicAdmin(
-        mockClinicAdmin.id
-      );
-
-      expect(doc).toHaveBeenCalled();
-      expect(getDoc).toHaveBeenCalled();
-      expect(result).toEqual(
-        expect.objectContaining({
-          id: mockClinicAdmin.id,
-          userRef: mockClinicAdmin.userRef,
-        })
-      );
-    });
-
-    it("treba da baci grešku ako admin ne postoji", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => false,
-      });
-
-      await expect(
-        clinicAdminService.getClinicAdmin("non-existent")
-      ).rejects.toThrow(CLINIC_ADMIN_ERRORS.NOT_FOUND);
-    });
-  });
-
-  describe("getClinicAdminByUserRef", () => {
-    it("treba da vrati clinic admina po user ID-u", async () => {
-      const result = await clinicAdminService.getClinicAdminByUserRef(
-        mockClinicAdmin.userRef
-      );
-
-      expect(collection).toHaveBeenCalled();
-      expect(query).toHaveBeenCalled();
-      expect(where).toHaveBeenCalledWith(
-        "userRef",
-        "==",
-        mockClinicAdmin.userRef
-      );
-      expect(result).toEqual(
-        expect.objectContaining({
-          id: mockClinicAdmin.id,
-          userRef: mockClinicAdmin.userRef,
-        })
-      );
-    });
-
-    it("treba da vrati null ako admin ne postoji", async () => {
-      (getDocs as jest.Mock).mockResolvedValueOnce({
-        empty: true,
-        docs: [],
-      });
-
-      const result = await clinicAdminService.getClinicAdminByUserRef(
-        "non-existent"
-      );
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("updateClinicAdmin", () => {
-    it("treba da ažurira clinic admina", async () => {
-      const updates = {
-        contactInfo: {
-          ...mockClinicAdmin.contactInfo,
-          firstName: "Jane",
-        },
-      };
-
-      const result = await clinicAdminService.updateClinicAdmin(
-        mockClinicAdmin.id,
-        updates
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result).toEqual(
-        expect.objectContaining({
-          ...mockClinicAdmin,
-          ...updates,
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-
-    it("treba da baci grešku ako admin ne postoji", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => false,
-      });
-
-      await expect(
-        clinicAdminService.updateClinicAdmin("non-existent", {})
-      ).rejects.toThrow(CLINIC_ADMIN_ERRORS.NOT_FOUND);
-    });
-  });
-
-  describe("setActive", () => {
-    it("treba da aktivira/deaktivira clinic admina", async () => {
-      await clinicAdminService.setActive(mockClinicAdmin.id, false);
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          isActive: false,
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-
-    it("treba da baci grešku ako admin ne postoji", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => false,
-      });
-
-      await expect(
-        clinicAdminService.setActive("non-existent", false)
-      ).rejects.toThrow(CLINIC_ADMIN_ERRORS.NOT_FOUND);
-    });
-  });
-
-  describe("addClinicToManaged", () => {
-    it("treba da doda kliniku admin-u", async () => {
-      const clinicId = "new-clinic-id";
-      const result = await clinicAdminService.addClinicToManaged(
-        mockClinicAdmin.id,
-        clinicId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.clinicsManaged).toContain(clinicId);
-    });
-
-    it("treba da baci grešku ako klinika već postoji", async () => {
-      const clinicId = mockClinicAdmin.clinicsManaged[0];
-
-      await expect(
-        clinicAdminService.addClinicToManaged(mockClinicAdmin.id, clinicId)
-      ).rejects.toThrow(CLINIC_ADMIN_ERRORS.CLINIC_ALREADY_MANAGED);
-    });
-  });
-
-  describe("removeClinicFromManaged", () => {
-    it("treba da ukloni kliniku iz admin-a", async () => {
-      const clinicId = mockClinicAdmin.clinicsManaged[0];
-      const result = await clinicAdminService.removeClinicFromManaged(
-        mockClinicAdmin.id,
-        clinicId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.clinicsManaged).not.toContain(clinicId);
-    });
-
-    it("treba da baci grešku ako klinika ne postoji", async () => {
-      const clinicId = "non-existent-clinic";
-
-      await expect(
-        clinicAdminService.removeClinicFromManaged(mockClinicAdmin.id, clinicId)
-      ).rejects.toThrow(CLINIC_ADMIN_ERRORS.CLINIC_NOT_MANAGED);
-    });
-  });
-});
+import { ClinicAdminService } from "../clinic-admin.service";
+import { mockDb, mockTimestamp } from "../../../config/__mocks__/firebase";
+import { getFirebaseInstance } from "../../../config/firebase";
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  query,
+  where,
+  updateDoc,
+  setDoc,
+} from "firebase/firestore";
+import {
+  CreateClinicAdminData,
+  ClinicAdmin,
+} from "../../../types/clinic-admin";
+import { CLINIC_ADMIN_ERRORS } from "../../../errors/clinic.errors";
+
+// Mock Firebase
+jest.mock("firebase/firestore");
+jest.mock("../../../config/firebase");
+
+describe("ClinicAdminService", () => {
+  let clinicAdminService: ClinicAdminService;
+
+  const mockClinicAdmin: ClinicAdmin = {
+    id: "test-admin-id",
+    userRef: "test-user-id",
+    clinicGroupId: "test-group-id",
+    isGroupOwner: false,
+    clinicsManaged: ["clinic-1", "clinic-2"],
+    contactInfo: {
+      firstName: "John",
+      lastName: "Doe",
+      title: "Admin",
+      email: "john@example.com",
+      phoneNumber: "+1234567890",
+    },
+    roleTitle: "Clinic Administrator",
+    isActive: true,
+    createdAt: mockTimestamp.now().toDate(),
+    updatedAt: mockTimestamp.now().toDate(),
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    (getFirebaseInstance as jest.Mock).mockResolvedValue({
+      db: mockDb,
+      auth: {},
+      app: {},
+      analytics: null,
+    });
+
+    clinicAdminService = new ClinicAdminService();
+
+    // Mock Firestore functions
+    (doc as jest.Mock).mockReturnValue("doc-ref");
+    (collection as jest.Mock).mockReturnValue("collection-ref");
+    (query as jest.Mock).mockReturnValue("query-ref");
+    (where as jest.Mock).mockReturnValue("where-clause");
+    (setDoc as jest.Mock).mockResolvedValue(undefined);
+    (updateDoc as jest.Mock).mockResolvedValue(undefined);
+
+    // Mock getDoc response
+    (getDoc as jest.Mock).mockResolvedValue({
+      exists: () => true,
+      data: () => ({
+        ...mockClinicAdmin,
+        createdAt: mockTimestamp.now(),
+        updatedAt: mockTimestamp.now(),
+      }),
+      id: mockClinicAdmin.id,
+    });
+
+    // Mock getDocs response
+    (getDocs as jest.Mock).mockResolvedValue({
+      docs: [
+        {
+          exists: () => true,
+          data: () => ({
+            ...mockClinicAdmin,
+            createdAt: mockTimestamp.now(),
+            updatedAt: mockTimestamp.now(),
+          }),
+          id: mockClinicAdmin.id,
+        },
+      ],
+    });
+  });
+
+  describe("createClinicAdmin", () => {
+    it("treba da kreira novog clinic admina", async () => {
+      const adminData: CreateClinicAdminData = {
+        userRef: "test-user-id",
+        clinicGroupId: "",
+        isGroupOwner: false,
+        clinicsManaged: [],
+        contactInfo: {
+          firstName: "John",
+          lastName: "Doe",
+          title: "Admin",
+          email: "john@example.com",
+          phoneNumber: "+1234567890",
+        },
+        roleTitle: "Clinic Administrator",
+        isActive: true,
+      };
+
+      const result = await clinicAdminService.createClinicAdmin(adminData);
+
+      expect(setDoc).toHaveBeenCalled();
+      expect(result).toEqual(
+        expect.objectContaining({
+          id: expect.any(String),
+          ...adminData,
+          createdAt: expect.any(Date),
+          updatedAt: expect.any(Date),
+        })
+      );
+    });
+  });
+
+  describe("getClinicAdmin", () => {
+    it("treba da vrati clinic admina po ID-u", async () => {
+      const result = await clinicAdminService.getClinicAdmin(
+        mockClinicAdmin.id
+      );
+
+      expect(doc).toHaveBeenCalled();
+      expect(getDoc).toHaveBeenCalled();
+      expect(result).toEqual(
+        expect.objectContaining({
+          id: mockClinicAdmin.id,
+          userRef: mockClinicAdmin.userRef,
+        })
+      );
+    });
+
+    it("treba da baci grešku ako admin ne postoji", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => false,
+      });
+
+      await expect(
+        clinicAdminService.getClinicAdmin("non-existent")
+      ).rejects.toThrow(CLINIC_ADMIN_ERRORS.NOT_FOUND);
+    });
+  });
+
+  describe("getClinicAdminByUserRef", () => {
+    it("treba da vrati clinic admina po user ID-u", async () => {
+      const result = await clinicAdminService.getClinicAdminByUserRef(
+        mockClinicAdmin.userRef
+      );
+
+      expect(collection).toHaveBeenCalled();
+      expect(query).toHaveBeenCalled();
+      expect(where).toHaveBeenCalledWith(
+        "userRef",
+        "==",
+        mockClinicAdmin.userRef
+      );
+      expect(result).toEqual(
+        expect.objectContaining({
+          id: mockClinicAdmin.id,
+          userRef: mockClinicAdmin.userRef,
+        })
+      );
+    });
+
+    it("treba da vrati null ako admin ne postoji", async () => {
+      (getDocs as jest.Mock).mockResolvedValueOnce({
+        empty: true,
+        docs: [],
+      });
+
+      const result = await clinicAdminService.getClinicAdminByUserRef(
+        "non-existent"
+      );
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("updateClinicAdmin", () => {
+    it("treba da ažurira clinic admina", async () => {
+      const updates = {
+        contactInfo: {
+          ...mockClinicAdmin.contactInfo,
+          firstName: "Jane",
+        },
+      };
+
+      const result = await clinicAdminService.updateClinicAdmin(
+        mockClinicAdmin.id,
+        updates
+      );
+
+      expect(updateDoc).toHaveBeenCalled();
+      expect(result).toEqual(
+        expect.objectContaining({
+          ...mockClinicAdmin,
+          ...updates,
+          updatedAt: expect.any(Date),
+        })
+      );
+    });
+
+    it("treba da baci grešku ako admin ne postoji", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => false,
+      });
+
+      await expect(
+        clinicAdminService.updateClinicAdmin("non-existent", {})
+      ).rejects.toThrow(CLINIC_ADMIN_ERRORS.NOT_FOUND);
+    });
+  });
+
+  describe("setActive", () => {
+    it("treba da aktivira/deaktivira clinic admina", async () => {
+      await clinicAdminService.setActive(mockClinicAdmin.id, false);
+
+      expect(updateDoc).toHaveBeenCalled();
+      expect(updateDoc).toHaveBeenCalledWith(
+        "doc-ref",
+        expect.objectContaining({
+          isActive: false,
+          updatedAt: expect.any(Date),
+        })
+      );
+    });
+
+    it("treba da baci grešku ako admin ne postoji", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => false,
+      });
+
+      await expect(
+        clinicAdminService.setActive("non-existent", false)
+      ).rejects.toThrow(CLINIC_ADMIN_ERRORS.NOT_FOUND);
+    });
+  });
+
+  describe("addClinicToManaged", () => {
+    it("treba da doda kliniku admin-u", async () => {
+      const clinicId = "new-clinic-id";
+      const result = await clinicAdminService.addClinicToManaged(
+        mockClinicAdmin.id,
+        clinicId
+      );
+
+      expect(updateDoc).toHaveBeenCalled();
+      expect(result.clinicsManaged).toContain(clinicId);
+    });
+
+    it("treba da baci grešku ako klinika već postoji", async () => {
+      const clinicId = mockClinicAdmin.clinicsManaged[0];
+
+      await expect(
+        clinicAdminService.addClinicToManaged(mockClinicAdmin.id, clinicId)
+      ).rejects.toThrow(CLINIC_ADMIN_ERRORS.CLINIC_ALREADY_MANAGED);
+    });
+  });
+
+  describe("removeClinicFromManaged", () => {
+    it("treba da ukloni kliniku iz admin-a", async () => {
+      const clinicId = mockClinicAdmin.clinicsManaged[0];
+      const result = await clinicAdminService.removeClinicFromManaged(
+        mockClinicAdmin.id,
+        clinicId
+      );
+
+      expect(updateDoc).toHaveBeenCalled();
+      expect(result.clinicsManaged).not.toContain(clinicId);
+    });
+
+    it("treba da baci grešku ako klinika ne postoji", async () => {
+      const clinicId = "non-existent-clinic";
+
+      await expect(
+        clinicAdminService.removeClinicFromManaged(mockClinicAdmin.id, clinicId)
+      ).rejects.toThrow(CLINIC_ADMIN_ERRORS.CLINIC_NOT_MANAGED);
+    });
+  });
+});