@blackcode_sa/metaestetics-api 1.13.3 → 1.13.5

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

@@ -1,352 +1,352 @@
-import { ClinicGroupService } from "../clinic-group.service";
-import { mockDb, mockTimestamp } from "../../../config/__mocks__/firebase";
-import { getFirebaseInstance } from "../../../config/firebase";
-import {
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  query,
-  where,
-  updateDoc,
-  deleteDoc,
-  setDoc,
-} from "firebase/firestore";
-
-// Mock Firebase
-jest.mock("firebase/firestore");
-jest.mock("../../../config/firebase");
-
-describe("ClinicGroupService", () => {
-  let clinicGroupService: ClinicGroupService;
-
-  const mockClinicGroup = {
-    id: "test-group-id",
-    name: "Test Clinic Group",
-    description: "Test Description",
-    logo: "test-logo-url",
-    website: "https://test.com",
-    contactInfo: {
-      email: "contact@test.com",
-      phone: "+1234567890",
-      address: "Test Address",
-    },
-    ownerId: "test-owner-id",
-    clinics: ["clinic-1", "clinic-2"],
-    isActive: true,
-    createdAt: mockTimestamp.now().toDate(),
-    updatedAt: mockTimestamp.now().toDate(),
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-
-    (getFirebaseInstance as jest.Mock).mockResolvedValue({
-      db: mockDb,
-      auth: {},
-      app: {},
-      analytics: null,
-    });
-
-    clinicGroupService = new ClinicGroupService();
-
-    // 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);
-    (deleteDoc as jest.Mock).mockResolvedValue(undefined);
-
-    // Mock getDoc response
-    (getDoc as jest.Mock).mockResolvedValue({
-      exists: () => true,
-      data: () => ({
-        ...mockClinicGroup,
-        createdAt: mockTimestamp.now(),
-        updatedAt: mockTimestamp.now(),
-      }),
-      id: mockClinicGroup.id,
-    });
-
-    // Mock getDocs response
-    (getDocs as jest.Mock).mockResolvedValue({
-      docs: [
-        {
-          exists: () => true,
-          data: () => ({
-            ...mockClinicGroup,
-            createdAt: mockTimestamp.now(),
-            updatedAt: mockTimestamp.now(),
-          }),
-          id: mockClinicGroup.id,
-        },
-      ],
-    });
-  });
-
-  describe("createClinicGroup", () => {
-    it("treba da kreira novu kliničku grupu", async () => {
-      const groupData = {
-        name: "New Clinic Group",
-        description: "New Description",
-        logo: "new-logo-url",
-        website: "https://new.com",
-        contactInfo: {
-          email: "contact@new.com",
-          phone: "+0987654321",
-          address: "New Address",
-        },
-        clinics: [],
-        isActive: true,
-      };
-
-      const ownerId = "new-owner-id";
-      const result = await clinicGroupService.createClinicGroup(
-        groupData,
-        ownerId
-      );
-
-      expect(setDoc).toHaveBeenCalled();
-      expect(result).toEqual(
-        expect.objectContaining({
-          id: expect.any(String),
-          ...groupData,
-          ownerId,
-          createdAt: expect.any(Date),
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-  });
-
-  describe("getClinicGroup", () => {
-    it("treba da vrati kliničku grupu po ID-u", async () => {
-      const result = await clinicGroupService.getClinicGroup(
-        mockClinicGroup.id
-      );
-
-      expect(doc).toHaveBeenCalled();
-      expect(getDoc).toHaveBeenCalled();
-      expect(result).toEqual(
-        expect.objectContaining({
-          id: mockClinicGroup.id,
-          name: mockClinicGroup.name,
-        })
-      );
-    });
-
-    it("treba da baci grešku ako grupa ne postoji", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => false,
-      });
-
-      await expect(
-        clinicGroupService.getClinicGroup("non-existent")
-      ).rejects.toThrow();
-    });
-  });
-
-  describe("getClinicGroupsByOwner", () => {
-    it("treba da vrati kliničke grupe po vlasniku", async () => {
-      const result = await clinicGroupService.getClinicGroupsByOwner(
-        mockClinicGroup.ownerId
-      );
-
-      expect(collection).toHaveBeenCalled();
-      expect(query).toHaveBeenCalled();
-      expect(where).toHaveBeenCalledWith(
-        "ownerId",
-        "==",
-        mockClinicGroup.ownerId
-      );
-      expect(result).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            id: mockClinicGroup.id,
-            ownerId: mockClinicGroup.ownerId,
-          }),
-        ])
-      );
-    });
-  });
-
-  describe("updateClinicGroup", () => {
-    it("treba da ažurira kliničku grupu", async () => {
-      const updates = {
-        name: "Updated Name",
-        description: "Updated Description",
-      };
-
-      const result = await clinicGroupService.updateClinicGroup(
-        mockClinicGroup.id,
-        updates
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result).toEqual(
-        expect.objectContaining({
-          ...mockClinicGroup,
-          ...updates,
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-
-    it("treba da baci grešku ako grupa ne postoji", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => false,
-      });
-
-      await expect(
-        clinicGroupService.updateClinicGroup("non-existent", {})
-      ).rejects.toThrow();
-    });
-  });
-
-  describe("deleteClinicGroup", () => {
-    it("treba da obriše kliničku grupu", async () => {
-      await clinicGroupService.deleteClinicGroup(mockClinicGroup.id);
-
-      expect(deleteDoc).toHaveBeenCalledWith("doc-ref");
-    });
-
-    it("treba da baci grešku ako grupa ne postoji", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => false,
-      });
-
-      await expect(
-        clinicGroupService.deleteClinicGroup("non-existent")
-      ).rejects.toThrow();
-    });
-  });
-
-  describe("addClinicToGroup", () => {
-    it("treba da doda kliniku u grupu", async () => {
-      const clinicId = "new-clinic-id";
-      const result = await clinicGroupService.addClinicToGroup(
-        mockClinicGroup.id,
-        clinicId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.clinics).toContain(clinicId);
-    });
-  });
-
-  describe("removeClinicFromGroup", () => {
-    it("treba da ukloni kliniku iz grupe", async () => {
-      const clinicId = mockClinicGroup.clinics[0];
-      const result = await clinicGroupService.removeClinicFromGroup(
-        mockClinicGroup.id,
-        clinicId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.clinics).not.toContain(clinicId);
-    });
-  });
-
-  describe("getClinicGroupByAdmin", () => {
-    it("treba da vrati kliničke grupe po admin ID-u", async () => {
-      const result = await clinicGroupService.getClinicGroupByAdmin(
-        mockClinicGroup.ownerId
-      );
-
-      expect(collection).toHaveBeenCalled();
-      expect(query).toHaveBeenCalled();
-      expect(where).toHaveBeenCalledWith(
-        "admins",
-        "array-contains",
-        mockClinicGroup.ownerId
-      );
-      expect(result).toEqual(
-        expect.arrayContaining([
-          expect.objectContaining({
-            id: mockClinicGroup.id,
-            ownerId: mockClinicGroup.ownerId,
-          }),
-        ])
-      );
-    });
-  });
-
-  describe("deactivateClinicGroup", () => {
-    it("treba da deaktivira kliničku grupu", async () => {
-      await clinicGroupService.deactivateClinicGroup(mockClinicGroup.id);
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(updateDoc).toHaveBeenCalledWith(
-        "doc-ref",
-        expect.objectContaining({
-          isActive: false,
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-
-    it("treba da baci grešku ako grupa ne postoji", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => false,
-      });
-
-      await expect(
-        clinicGroupService.deactivateClinicGroup("non-existent")
-      ).rejects.toThrow();
-    });
-  });
-
-  describe("addClinic", () => {
-    it("treba da doda kliniku u grupu", async () => {
-      const clinicId = "new-clinic-id";
-      const result = await clinicGroupService.addClinic(
-        mockClinicGroup.id,
-        clinicId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.clinics).toContain(clinicId);
-    });
-  });
-
-  describe("removeClinic", () => {
-    it("treba da ukloni kliniku iz grupe", async () => {
-      const clinicId = mockClinicGroup.clinics[0];
-      const result = await clinicGroupService.removeClinic(
-        mockClinicGroup.id,
-        clinicId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.clinics).not.toContain(clinicId);
-    });
-  });
-
-  describe("addAdmin", () => {
-    it("treba da doda admina u grupu", async () => {
-      const adminId = "new-admin-id";
-      const result = await clinicGroupService.addAdmin(
-        mockClinicGroup.id,
-        adminId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.admins).toContain(adminId);
-    });
-  });
-
-  describe("removeAdmin", () => {
-    it("treba da ukloni admina iz grupe", async () => {
-      const adminId = "admin-to-remove";
-      const result = await clinicGroupService.removeAdmin(
-        mockClinicGroup.id,
-        adminId
-      );
-
-      expect(updateDoc).toHaveBeenCalled();
-      expect(result.admins).not.toContain(adminId);
-    });
-  });
-});
+import { ClinicGroupService } from "../clinic-group.service";
+import { mockDb, mockTimestamp } from "../../../config/__mocks__/firebase";
+import { getFirebaseInstance } from "../../../config/firebase";
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  query,
+  where,
+  updateDoc,
+  deleteDoc,
+  setDoc,
+} from "firebase/firestore";
+
+// Mock Firebase
+jest.mock("firebase/firestore");
+jest.mock("../../../config/firebase");
+
+describe("ClinicGroupService", () => {
+  let clinicGroupService: ClinicGroupService;
+
+  const mockClinicGroup = {
+    id: "test-group-id",
+    name: "Test Clinic Group",
+    description: "Test Description",
+    logo: "test-logo-url",
+    website: "https://test.com",
+    contactInfo: {
+      email: "contact@test.com",
+      phone: "+1234567890",
+      address: "Test Address",
+    },
+    ownerId: "test-owner-id",
+    clinics: ["clinic-1", "clinic-2"],
+    isActive: true,
+    createdAt: mockTimestamp.now().toDate(),
+    updatedAt: mockTimestamp.now().toDate(),
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    (getFirebaseInstance as jest.Mock).mockResolvedValue({
+      db: mockDb,
+      auth: {},
+      app: {},
+      analytics: null,
+    });
+
+    clinicGroupService = new ClinicGroupService();
+
+    // 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);
+    (deleteDoc as jest.Mock).mockResolvedValue(undefined);
+
+    // Mock getDoc response
+    (getDoc as jest.Mock).mockResolvedValue({
+      exists: () => true,
+      data: () => ({
+        ...mockClinicGroup,
+        createdAt: mockTimestamp.now(),
+        updatedAt: mockTimestamp.now(),
+      }),
+      id: mockClinicGroup.id,
+    });
+
+    // Mock getDocs response
+    (getDocs as jest.Mock).mockResolvedValue({
+      docs: [
+        {
+          exists: () => true,
+          data: () => ({
+            ...mockClinicGroup,
+            createdAt: mockTimestamp.now(),
+            updatedAt: mockTimestamp.now(),
+          }),
+          id: mockClinicGroup.id,
+        },
+      ],
+    });
+  });
+
+  describe("createClinicGroup", () => {
+    it("treba da kreira novu kliničku grupu", async () => {
+      const groupData = {
+        name: "New Clinic Group",
+        description: "New Description",
+        logo: "new-logo-url",
+        website: "https://new.com",
+        contactInfo: {
+          email: "contact@new.com",
+          phone: "+0987654321",
+          address: "New Address",
+        },
+        clinics: [],
+        isActive: true,
+      };
+
+      const ownerId = "new-owner-id";
+      const result = await clinicGroupService.createClinicGroup(
+        groupData,
+        ownerId
+      );
+
+      expect(setDoc).toHaveBeenCalled();
+      expect(result).toEqual(
+        expect.objectContaining({
+          id: expect.any(String),
+          ...groupData,
+          ownerId,
+          createdAt: expect.any(Date),
+          updatedAt: expect.any(Date),
+        })
+      );
+    });
+  });
+
+  describe("getClinicGroup", () => {
+    it("treba da vrati kliničku grupu po ID-u", async () => {
+      const result = await clinicGroupService.getClinicGroup(
+        mockClinicGroup.id
+      );
+
+      expect(doc).toHaveBeenCalled();
+      expect(getDoc).toHaveBeenCalled();
+      expect(result).toEqual(
+        expect.objectContaining({
+          id: mockClinicGroup.id,
+          name: mockClinicGroup.name,
+        })
+      );
+    });
+
+    it("treba da baci grešku ako grupa ne postoji", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => false,
+      });
+
+      await expect(
+        clinicGroupService.getClinicGroup("non-existent")
+      ).rejects.toThrow();
+    });
+  });
+
+  describe("getClinicGroupsByOwner", () => {
+    it("treba da vrati kliničke grupe po vlasniku", async () => {
+      const result = await clinicGroupService.getClinicGroupsByOwner(
+        mockClinicGroup.ownerId
+      );
+
+      expect(collection).toHaveBeenCalled();
+      expect(query).toHaveBeenCalled();
+      expect(where).toHaveBeenCalledWith(
+        "ownerId",
+        "==",
+        mockClinicGroup.ownerId
+      );
+      expect(result).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: mockClinicGroup.id,
+            ownerId: mockClinicGroup.ownerId,
+          }),
+        ])
+      );
+    });
+  });
+
+  describe("updateClinicGroup", () => {
+    it("treba da ažurira kliničku grupu", async () => {
+      const updates = {
+        name: "Updated Name",
+        description: "Updated Description",
+      };
+
+      const result = await clinicGroupService.updateClinicGroup(
+        mockClinicGroup.id,
+        updates
+      );
+
+      expect(updateDoc).toHaveBeenCalled();
+      expect(result).toEqual(
+        expect.objectContaining({
+          ...mockClinicGroup,
+          ...updates,
+          updatedAt: expect.any(Date),
+        })
+      );
+    });
+
+    it("treba da baci grešku ako grupa ne postoji", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => false,
+      });
+
+      await expect(
+        clinicGroupService.updateClinicGroup("non-existent", {})
+      ).rejects.toThrow();
+    });
+  });
+
+  describe("deleteClinicGroup", () => {
+    it("treba da obriše kliničku grupu", async () => {
+      await clinicGroupService.deleteClinicGroup(mockClinicGroup.id);
+
+      expect(deleteDoc).toHaveBeenCalledWith("doc-ref");
+    });
+
+    it("treba da baci grešku ako grupa ne postoji", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => false,
+      });
+
+      await expect(
+        clinicGroupService.deleteClinicGroup("non-existent")
+      ).rejects.toThrow();
+    });
+  });
+
+  describe("addClinicToGroup", () => {
+    it("treba da doda kliniku u grupu", async () => {
+      const clinicId = "new-clinic-id";
+      const result = await clinicGroupService.addClinicToGroup(
+        mockClinicGroup.id,
+        clinicId
+      );
+
+      expect(updateDoc).toHaveBeenCalled();
+      expect(result.clinics).toContain(clinicId);
+    });
+  });
+
+  describe("removeClinicFromGroup", () => {
+    it("treba da ukloni kliniku iz grupe", async () => {
+      const clinicId = mockClinicGroup.clinics[0];
+      const result = await clinicGroupService.removeClinicFromGroup(
+        mockClinicGroup.id,
+        clinicId
+      );
+
+      expect(updateDoc).toHaveBeenCalled();
+      expect(result.clinics).not.toContain(clinicId);
+    });
+  });
+
+  describe("getClinicGroupByAdmin", () => {
+    it("treba da vrati kliničke grupe po admin ID-u", async () => {
+      const result = await clinicGroupService.getClinicGroupByAdmin(
+        mockClinicGroup.ownerId
+      );
+
+      expect(collection).toHaveBeenCalled();
+      expect(query).toHaveBeenCalled();
+      expect(where).toHaveBeenCalledWith(
+        "admins",
+        "array-contains",
+        mockClinicGroup.ownerId
+      );
+      expect(result).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: mockClinicGroup.id,
+            ownerId: mockClinicGroup.ownerId,
+          }),
+        ])
+      );
+    });
+  });
+
+  describe("deactivateClinicGroup", () => {
+    it("treba da deaktivira kliničku grupu", async () => {
+      await clinicGroupService.deactivateClinicGroup(mockClinicGroup.id);
+
+      expect(updateDoc).toHaveBeenCalled();
+      expect(updateDoc).toHaveBeenCalledWith(
+        "doc-ref",
+        expect.objectContaining({
+          isActive: false,
+          updatedAt: expect.any(Date),
+        })
+      );
+    });
+
+    it("treba da baci grešku ako grupa ne postoji", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => false,
+      });
+
+      await expect(
+        clinicGroupService.deactivateClinicGroup("non-existent")
+      ).rejects.toThrow();
+    });
+  });
+
+  describe("addClinic", () => {
+    it("treba da doda kliniku u grupu", async () => {
+      const clinicId = "new-clinic-id";
+      const result = await clinicGroupService.addClinic(
+        mockClinicGroup.id,
+        clinicId
+      );
+
+      expect(updateDoc).toHaveBeenCalled();
+      expect(result.clinics).toContain(clinicId);
+    });
+  });
+
+  describe("removeClinic", () => {
+    it("treba da ukloni kliniku iz grupe", async () => {
+      const clinicId = mockClinicGroup.clinics[0];
+      const result = await clinicGroupService.removeClinic(
+        mockClinicGroup.id,
+        clinicId
+      );
+
+      expect(updateDoc).toHaveBeenCalled();
+      expect(result.clinics).not.toContain(clinicId);
+    });
+  });
+
+  describe("addAdmin", () => {
+    it("treba da doda admina u grupu", async () => {
+      const adminId = "new-admin-id";
+      const result = await clinicGroupService.addAdmin(
+        mockClinicGroup.id,
+        adminId
+      );
+
+      expect(updateDoc).toHaveBeenCalled();
+      expect(result.admins).toContain(adminId);
+    });
+  });
+
+  describe("removeAdmin", () => {
+    it("treba da ukloni admina iz grupe", async () => {
+      const adminId = "admin-to-remove";
+      const result = await clinicGroupService.removeAdmin(
+        mockClinicGroup.id,
+        adminId
+      );
+
+      expect(updateDoc).toHaveBeenCalled();
+      expect(result.admins).not.toContain(adminId);
+    });
+  });
+});