@blackcode_sa/metaestetics-api 1.13.5 → 1.13.8

package/src/services/__tests__/user.service.test.ts

@@ -1,528 +1,528 @@
-import { UserService } from "../user/user.service";
-import { User, UserRole, USERS_COLLECTION } from "../../types";
-import { USER_ERRORS } from "../../errors/user.errors";
-import { AUTH_ERRORS } from "../../errors/auth.errors";
-import {
-  collection,
-  doc,
-  getDoc,
-  getDocs,
-  query,
-  where,
-  updateDoc,
-  deleteDoc,
-  Timestamp,
-  setDoc,
-  serverTimestamp,
-} from "firebase/firestore";
-import { PatientService } from "../patient/patient.service";
-import { ClinicAdminService } from "../clinic/clinic-admin.service";
-import { mockTimestamp } from "../../config/__mocks__/firebase";
-import { mockDb, mockAuth } from "../../config/__mocks__/firebase";
-import { getFirebaseInstance } from "../../config/firebase";
-
-// Mock Firebase
-jest.mock("firebase/firestore", () => {
-  const originalModule = jest.requireActual("firebase/firestore");
-  const mockTimestamp = new originalModule.Timestamp(
-    Math.floor(Date.now() / 1000),
-    0
-  );
-
-  return {
-    ...originalModule,
-    collection: jest.fn(),
-    doc: jest.fn(),
-    getDoc: jest.fn(),
-    getDocs: jest.fn(),
-    query: jest.fn(),
-    where: jest.fn(),
-    updateDoc: jest.fn(),
-    setDoc: jest.fn(),
-    deleteDoc: jest.fn(),
-    Timestamp: {
-      ...originalModule.Timestamp,
-      now: jest.fn().mockReturnValue(mockTimestamp),
-      fromDate: jest.fn().mockReturnValue(mockTimestamp),
-    },
-    serverTimestamp: jest.fn().mockReturnValue(mockTimestamp),
-  };
-});
-
-jest.mock("../../config/firebase", () => ({
-  getFirebaseInstance: jest.fn().mockResolvedValue({
-    db: {},
-    auth: {},
-  }),
-}));
-
-// Mock services
-const mockPatientService = {
-  createPatientProfile: jest
-    .fn()
-    .mockResolvedValue({ id: "patient-profile-id" }),
-  deletePatientProfile: jest.fn().mockResolvedValue(undefined),
-};
-
-const mockClinicAdminService = {
-  createClinicAdmin: jest.fn().mockResolvedValue({ id: "admin-profile-id" }),
-  deleteClinicAdmin: jest.fn().mockResolvedValue(undefined),
-};
-
-jest.mock("../patient/patient.service", () => ({
-  PatientService: jest.fn().mockImplementation(() => mockPatientService),
-}));
-
-jest.mock("../clinic/clinic-admin.service", () => ({
-  ClinicAdminService: jest
-    .fn()
-    .mockImplementation(() => mockClinicAdminService),
-}));
-
-describe("UserService", () => {
-  let userService: UserService;
-
-  const mockUser: User = {
-    uid: "test-uid",
-    email: "test@example.com",
-    roles: [UserRole.PATIENT],
-    isAnonymous: false,
-    createdAt: new Timestamp(Math.floor(Date.now() / 1000), 0),
-    updatedAt: new Timestamp(Math.floor(Date.now() / 1000), 0),
-    lastLoginAt: new Timestamp(Math.floor(Date.now() / 1000), 0),
-    patientProfile: "test-uid",
-    practitionerProfile: undefined,
-    adminProfile: undefined,
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-
-    // Mock za Firestore funkcije
-    (doc as jest.Mock).mockReturnValue({ id: "test-uid" });
-    (collection as jest.Mock).mockReturnValue({ id: "users" });
-    (query as jest.Mock).mockReturnValue({ id: "query" });
-    (where as jest.Mock).mockReturnValue({ id: "where" });
-
-    // Mock za getDoc response sa ispravnim Timestamp objektima
-    (getDoc as jest.Mock).mockResolvedValue({
-      exists: () => true,
-      data: () => ({
-        ...mockUser,
-        createdAt: mockTimestamp.now(),
-        updatedAt: mockTimestamp.now(),
-        lastLoginAt: mockTimestamp.now(),
-      }),
-    });
-
-    // Mock za getDocs response sa ispravnim Timestamp objektima
-    (getDocs as jest.Mock).mockResolvedValue({
-      empty: false,
-      docs: [
-        {
-          data: () => ({
-            ...mockUser,
-            createdAt: mockTimestamp.now(),
-            updatedAt: mockTimestamp.now(),
-            lastLoginAt: mockTimestamp.now(),
-          }),
-        },
-      ],
-    });
-
-    userService = new UserService(
-      mockAuth,
-      new PatientService(),
-      new ClinicAdminService()
-    );
-  });
-
-  describe("createUser", () => {
-    it("treba da kreira novog korisnika sa profilima", async () => {
-      const newUser: User = {
-        ...mockUser,
-        roles: [UserRole.PATIENT, UserRole.CLINIC_ADMIN],
-        patientProfile: undefined,
-        adminProfile: undefined,
-        createdAt: mockTimestamp.now(),
-        updatedAt: mockTimestamp.now(),
-        lastLoginAt: mockTimestamp.now(),
-      };
-
-      const result = await userService.createUser(
-        newUser as any,
-        newUser.roles
-      );
-
-      expect(setDoc).toHaveBeenCalledWith(
-        { id: "test-uid" },
-        expect.objectContaining({
-          ...newUser,
-          patientProfile: "patient-profile-id",
-          adminProfile: "admin-profile-id",
-        })
-      );
-
-      expect(result).toEqual(
-        expect.objectContaining({
-          ...newUser,
-          patientProfile: "patient-profile-id",
-          adminProfile: "admin-profile-id",
-        })
-      );
-    });
-
-    it("treba da obriše profile ako dođe do greške", async () => {
-      const newUser: User = {
-        ...mockUser,
-        roles: [UserRole.PATIENT],
-        patientProfile: "existing-profile",
-      };
-
-      (setDoc as jest.Mock).mockRejectedValueOnce(new Error("Database error"));
-
-      await expect(
-        userService.createUser(newUser as any, newUser.roles)
-      ).rejects.toThrow("Database error");
-      expect(mockPatientService.deletePatientProfile).toHaveBeenCalledWith(
-        "existing-profile"
-      );
-    });
-  });
-
-  describe("getUserById", () => {
-    it("treba da konvertuje Timestamp objekte u Date", async () => {
-      const timestamp = mockTimestamp.now();
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => true,
-        data: () => ({
-          uid: "test-uid",
-          email: "test@example.com",
-          roles: [UserRole.PATIENT],
-          isAnonymous: false,
-          patientProfile: undefined,
-          practitionerProfile: undefined,
-          adminProfile: undefined,
-          createdAt: timestamp,
-          updatedAt: timestamp,
-          lastLoginAt: timestamp,
-        }),
-      });
-
-      const result = await userService.getUserById("test-uid");
-
-      expect(result.createdAt).toBeInstanceOf(Date);
-      expect(result.updatedAt).toBeInstanceOf(Date);
-      expect(result.lastLoginAt).toBeInstanceOf(Date);
-    });
-
-    it("treba da baci ValidationError ako podaci nisu validni", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => true,
-        data: () => ({
-          ...mockUser,
-          email: "invalid-email",
-          createdAt: mockTimestamp.now(),
-          updatedAt: mockTimestamp.now(),
-          lastLoginAt: mockTimestamp.now(),
-        }),
-      });
-
-      await expect(userService.getUserById("test-uid")).rejects.toThrow(
-        USER_ERRORS.VALIDATION_ERROR.message
-      );
-    });
-  });
-
-  describe("getUserByEmail", () => {
-    it("treba da vrati korisnika ako postoji", async () => {
-      (getDocs as jest.Mock).mockResolvedValueOnce({
-        empty: false,
-        docs: [
-          {
-            data: () => ({
-              ...mockUser,
-              createdAt: mockTimestamp.now(),
-              updatedAt: mockTimestamp.now(),
-              lastLoginAt: mockTimestamp.now(),
-            }),
-          },
-        ],
-      });
-
-      const result = await userService.getUserByEmail("test@example.com");
-      expect(result).toEqual({
-        ...mockUser,
-        createdAt: expect.any(Date),
-        updatedAt: expect.any(Date),
-        lastLoginAt: expect.any(Date),
-      });
-    });
-
-    it("treba da vrati null ako korisnik ne postoji", async () => {
-      (getDocs as jest.Mock).mockResolvedValueOnce({
-        empty: true,
-        docs: [],
-      });
-
-      const result = await userService.getUserByEmail(
-        "nonexistent@example.com"
-      );
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("updateUserLoginTimestamp", () => {
-    it("treba da ažurira vreme poslednje prijave", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => true,
-        data: () => mockUser,
-      });
-
-      const result = await userService.updateUserLoginTimestamp("test-uid");
-
-      expect(setDoc).toHaveBeenCalledWith(
-        expect.anything(),
-        expect.objectContaining({
-          lastLoginAt: serverTimestamp(),
-          updatedAt: serverTimestamp(),
-        }),
-        { merge: true }
-      );
-
-      expect(result).toEqual(
-        expect.objectContaining({
-          lastLoginAt: expect.any(Date),
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-
-    it("treba da baci grešku ako korisnik ne postoji", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => false,
-      });
-
-      await expect(
-        userService.updateUserLoginTimestamp("non-existent")
-      ).rejects.toEqual(AUTH_ERRORS.USER_NOT_FOUND);
-    });
-  });
-
-  describe("upgradeAnonymousUser", () => {
-    it("treba da nadogradi anonimnog korisnika", async () => {
-      const email = "test@example.com";
-      const result = await userService.upgradeAnonymousUser("test-uid", email);
-
-      const mockTimestamp = new Date();
-      (serverTimestamp as jest.Mock).mockReturnValue(mockTimestamp);
-
-      expect(updateDoc).toHaveBeenCalledWith(
-        { id: "test-uid" },
-        expect.objectContaining({
-          email,
-          isAnonymous: false,
-          updatedAt: expect.any(Date),
-        })
-      );
-
-      expect(result).toEqual(
-        expect.objectContaining({
-          email,
-          isAnonymous: false,
-          updatedAt: mockTimestamp,
-        })
-      );
-    });
-
-    it("treba da baci grešku ako korisnik ne postoji", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => false,
-      });
-
-      await expect(
-        userService.upgradeAnonymousUser("non-existent", "test@example.com")
-      ).rejects.toEqual(USER_ERRORS.NOT_FOUND);
-    });
-  });
-
-  describe("getUsersByRole", () => {
-    it("treba da vrati listu korisnika sa određenom ulogom", async () => {
-      const result = await userService.getUsersByRole(UserRole.PATIENT);
-      expect(result).toEqual([mockUser]);
-    });
-  });
-
-  describe("updateUser", () => {
-    const updates = { email: "updated@example.com" };
-
-    it("treba da ažurira korisnika ako postoji", async () => {
-      const updatedUser = {
-        ...mockUser,
-        ...updates,
-        updatedAt: expect.any(Date),
-      };
-
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => true,
-        data: () => mockUser,
-      });
-
-      const result = await userService.updateUser("test-uid", updates);
-
-      expect(updateDoc).toHaveBeenCalledWith(
-        expect.anything(),
-        expect.objectContaining({
-          email: updates.email,
-          updatedAt: serverTimestamp(),
-        })
-      );
-
-      expect(result).toEqual(
-        expect.objectContaining({
-          email: updates.email,
-          updatedAt: expect.any(Date),
-        })
-      );
-    });
-
-    it("treba da baci grešku ako korisnik ne postoji", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => false,
-      });
-
-      await expect(
-        userService.updateUser("non-existent", updates)
-      ).rejects.toThrow(USER_ERRORS.NOT_FOUND.message);
-    });
-
-    it("treba da baci grešku ako podaci nisu validni", async () => {
-      const invalidUpdates = { email: "invalid-email" };
-
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => true,
-        data: () => mockUser,
-      });
-
-      await expect(
-        userService.updateUser("test-uid", invalidUpdates)
-      ).rejects.toThrow(USER_ERRORS.VALIDATION_ERROR.message);
-    });
-  });
-
-  describe("addRole", () => {
-    it("treba da doda novu ulogu i kreira odgovarajući profil", async () => {
-      const newRole = UserRole.CLINIC_ADMIN;
-      const result = await userService.addRole("test-uid", newRole);
-
-      expect(updateDoc).toHaveBeenCalledWith(
-        expect.anything(),
-        expect.objectContaining({
-          roles: [...mockUser.roles, newRole],
-          adminProfile: "admin-profile-id",
-          updatedAt: expect.any(Date),
-        })
-      );
-
-      expect(result).toEqual(
-        expect.objectContaining({
-          roles: [...mockUser.roles, newRole],
-          adminProfile: "admin-profile-id",
-        })
-      );
-    });
-
-    it("treba da baci grešku ako uloga već postoji", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => true,
-        data: () => mockUser,
-      });
-
-      await expect(
-        userService.addRole("test-uid", UserRole.PATIENT)
-      ).rejects.toEqual(USER_ERRORS.ROLE_EXISTS);
-    });
-
-    it("treba da baci grešku ako korisnik ima maksimalan broj uloga", async () => {
-      const userWithMaxRoles = {
-        ...mockUser,
-        roles: [UserRole.PATIENT, UserRole.PRACTITIONER, UserRole.CLINIC_ADMIN],
-      };
-
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => true,
-        data: () => userWithMaxRoles,
-      });
-
-      await expect(
-        userService.addRole("test-uid", UserRole.PATIENT)
-      ).rejects.toEqual(USER_ERRORS.MAX_ROLES_EXCEEDED);
-    });
-  });
-
-  describe("removeRole", () => {
-    it("treba da ukloni ulogu korisniku", async () => {
-      const userWithMultipleRoles = {
-        ...mockUser,
-        roles: [UserRole.PATIENT, UserRole.PRACTITIONER],
-        createdAt: mockTimestamp.now(),
-        updatedAt: mockTimestamp.now(),
-        lastLoginAt: mockTimestamp.now(),
-      };
-      const updatedUser = {
-        ...userWithMultipleRoles,
-        roles: [UserRole.PRACTITIONER],
-        createdAt: mockTimestamp.now(),
-        updatedAt: mockTimestamp.now(),
-        lastLoginAt: mockTimestamp.now(),
-      };
-
-      (getDoc as jest.Mock)
-        .mockResolvedValueOnce({
-          exists: () => true,
-          data: () => userWithMultipleRoles,
-        })
-        .mockResolvedValueOnce({
-          exists: () => true,
-          data: () => updatedUser,
-        });
-
-      await userService.removeRole("test-uid", UserRole.PATIENT);
-
-      // Provera da li je pozvan updateDoc sa ispravnim parametrima
-      expect(updateDoc).toHaveBeenCalledWith(
-        { id: "test-uid" },
-        expect.objectContaining({
-          roles: [UserRole.PRACTITIONER],
-          updatedAt: mockTimestamp.now(),
-        })
-      );
-    });
-  });
-
-  describe("deleteUser", () => {
-    it("treba da obriše korisnika i njegove profile", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => true,
-        data: () => mockUser,
-      });
-
-      await userService.deleteUser("test-uid");
-
-      expect(deleteDoc).toHaveBeenCalled();
-      expect(mockPatientService.deletePatientProfile).toHaveBeenCalledWith(
-        "test-uid"
-      );
-    });
-
-    it("treba da baci grešku ako korisnik ne postoji", async () => {
-      (getDoc as jest.Mock).mockResolvedValueOnce({
-        exists: () => false,
-      });
-
-      await expect(userService.deleteUser("non-existent")).rejects.toEqual(
-        USER_ERRORS.NOT_FOUND
-      );
-    });
-  });
-});
+import { UserService } from "../user/user.service";
+import { User, UserRole, USERS_COLLECTION } from "../../types";
+import { USER_ERRORS } from "../../errors/user.errors";
+import { AUTH_ERRORS } from "../../errors/auth.errors";
+import {
+  collection,
+  doc,
+  getDoc,
+  getDocs,
+  query,
+  where,
+  updateDoc,
+  deleteDoc,
+  Timestamp,
+  setDoc,
+  serverTimestamp,
+} from "firebase/firestore";
+import { PatientService } from "../patient/patient.service";
+import { ClinicAdminService } from "../clinic/clinic-admin.service";
+import { mockTimestamp } from "../../config/__mocks__/firebase";
+import { mockDb, mockAuth } from "../../config/__mocks__/firebase";
+import { getFirebaseInstance } from "../../config/firebase";
+
+// Mock Firebase
+jest.mock("firebase/firestore", () => {
+  const originalModule = jest.requireActual("firebase/firestore");
+  const mockTimestamp = new originalModule.Timestamp(
+    Math.floor(Date.now() / 1000),
+    0
+  );
+
+  return {
+    ...originalModule,
+    collection: jest.fn(),
+    doc: jest.fn(),
+    getDoc: jest.fn(),
+    getDocs: jest.fn(),
+    query: jest.fn(),
+    where: jest.fn(),
+    updateDoc: jest.fn(),
+    setDoc: jest.fn(),
+    deleteDoc: jest.fn(),
+    Timestamp: {
+      ...originalModule.Timestamp,
+      now: jest.fn().mockReturnValue(mockTimestamp),
+      fromDate: jest.fn().mockReturnValue(mockTimestamp),
+    },
+    serverTimestamp: jest.fn().mockReturnValue(mockTimestamp),
+  };
+});
+
+jest.mock("../../config/firebase", () => ({
+  getFirebaseInstance: jest.fn().mockResolvedValue({
+    db: {},
+    auth: {},
+  }),
+}));
+
+// Mock services
+const mockPatientService = {
+  createPatientProfile: jest
+    .fn()
+    .mockResolvedValue({ id: "patient-profile-id" }),
+  deletePatientProfile: jest.fn().mockResolvedValue(undefined),
+};
+
+const mockClinicAdminService = {
+  createClinicAdmin: jest.fn().mockResolvedValue({ id: "admin-profile-id" }),
+  deleteClinicAdmin: jest.fn().mockResolvedValue(undefined),
+};
+
+jest.mock("../patient/patient.service", () => ({
+  PatientService: jest.fn().mockImplementation(() => mockPatientService),
+}));
+
+jest.mock("../clinic/clinic-admin.service", () => ({
+  ClinicAdminService: jest
+    .fn()
+    .mockImplementation(() => mockClinicAdminService),
+}));
+
+describe("UserService", () => {
+  let userService: UserService;
+
+  const mockUser: User = {
+    uid: "test-uid",
+    email: "test@example.com",
+    roles: [UserRole.PATIENT],
+    isAnonymous: false,
+    createdAt: new Timestamp(Math.floor(Date.now() / 1000), 0),
+    updatedAt: new Timestamp(Math.floor(Date.now() / 1000), 0),
+    lastLoginAt: new Timestamp(Math.floor(Date.now() / 1000), 0),
+    patientProfile: "test-uid",
+    practitionerProfile: undefined,
+    adminProfile: undefined,
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    // Mock za Firestore funkcije
+    (doc as jest.Mock).mockReturnValue({ id: "test-uid" });
+    (collection as jest.Mock).mockReturnValue({ id: "users" });
+    (query as jest.Mock).mockReturnValue({ id: "query" });
+    (where as jest.Mock).mockReturnValue({ id: "where" });
+
+    // Mock za getDoc response sa ispravnim Timestamp objektima
+    (getDoc as jest.Mock).mockResolvedValue({
+      exists: () => true,
+      data: () => ({
+        ...mockUser,
+        createdAt: mockTimestamp.now(),
+        updatedAt: mockTimestamp.now(),
+        lastLoginAt: mockTimestamp.now(),
+      }),
+    });
+
+    // Mock za getDocs response sa ispravnim Timestamp objektima
+    (getDocs as jest.Mock).mockResolvedValue({
+      empty: false,
+      docs: [
+        {
+          data: () => ({
+            ...mockUser,
+            createdAt: mockTimestamp.now(),
+            updatedAt: mockTimestamp.now(),
+            lastLoginAt: mockTimestamp.now(),
+          }),
+        },
+      ],
+    });
+
+    userService = new UserService(
+      mockAuth,
+      new PatientService(),
+      new ClinicAdminService()
+    );
+  });
+
+  describe("createUser", () => {
+    it("treba da kreira novog korisnika sa profilima", async () => {
+      const newUser: User = {
+        ...mockUser,
+        roles: [UserRole.PATIENT, UserRole.CLINIC_ADMIN],
+        patientProfile: undefined,
+        adminProfile: undefined,
+        createdAt: mockTimestamp.now(),
+        updatedAt: mockTimestamp.now(),
+        lastLoginAt: mockTimestamp.now(),
+      };
+
+      const result = await userService.createUser(
+        newUser as any,
+        newUser.roles
+      );
+
+      expect(setDoc).toHaveBeenCalledWith(
+        { id: "test-uid" },
+        expect.objectContaining({
+          ...newUser,
+          patientProfile: "patient-profile-id",
+          adminProfile: "admin-profile-id",
+        })
+      );
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          ...newUser,
+          patientProfile: "patient-profile-id",
+          adminProfile: "admin-profile-id",
+        })
+      );
+    });
+
+    it("treba da obriše profile ako dođe do greške", async () => {
+      const newUser: User = {
+        ...mockUser,
+        roles: [UserRole.PATIENT],
+        patientProfile: "existing-profile",
+      };
+
+      (setDoc as jest.Mock).mockRejectedValueOnce(new Error("Database error"));
+
+      await expect(
+        userService.createUser(newUser as any, newUser.roles)
+      ).rejects.toThrow("Database error");
+      expect(mockPatientService.deletePatientProfile).toHaveBeenCalledWith(
+        "existing-profile"
+      );
+    });
+  });
+
+  describe("getUserById", () => {
+    it("treba da konvertuje Timestamp objekte u Date", async () => {
+      const timestamp = mockTimestamp.now();
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => true,
+        data: () => ({
+          uid: "test-uid",
+          email: "test@example.com",
+          roles: [UserRole.PATIENT],
+          isAnonymous: false,
+          patientProfile: undefined,
+          practitionerProfile: undefined,
+          adminProfile: undefined,
+          createdAt: timestamp,
+          updatedAt: timestamp,
+          lastLoginAt: timestamp,
+        }),
+      });
+
+      const result = await userService.getUserById("test-uid");
+
+      expect(result.createdAt).toBeInstanceOf(Date);
+      expect(result.updatedAt).toBeInstanceOf(Date);
+      expect(result.lastLoginAt).toBeInstanceOf(Date);
+    });
+
+    it("treba da baci ValidationError ako podaci nisu validni", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => true,
+        data: () => ({
+          ...mockUser,
+          email: "invalid-email",
+          createdAt: mockTimestamp.now(),
+          updatedAt: mockTimestamp.now(),
+          lastLoginAt: mockTimestamp.now(),
+        }),
+      });
+
+      await expect(userService.getUserById("test-uid")).rejects.toThrow(
+        USER_ERRORS.VALIDATION_ERROR.message
+      );
+    });
+  });
+
+  describe("getUserByEmail", () => {
+    it("treba da vrati korisnika ako postoji", async () => {
+      (getDocs as jest.Mock).mockResolvedValueOnce({
+        empty: false,
+        docs: [
+          {
+            data: () => ({
+              ...mockUser,
+              createdAt: mockTimestamp.now(),
+              updatedAt: mockTimestamp.now(),
+              lastLoginAt: mockTimestamp.now(),
+            }),
+          },
+        ],
+      });
+
+      const result = await userService.getUserByEmail("test@example.com");
+      expect(result).toEqual({
+        ...mockUser,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+        lastLoginAt: expect.any(Date),
+      });
+    });
+
+    it("treba da vrati null ako korisnik ne postoji", async () => {
+      (getDocs as jest.Mock).mockResolvedValueOnce({
+        empty: true,
+        docs: [],
+      });
+
+      const result = await userService.getUserByEmail(
+        "nonexistent@example.com"
+      );
+      expect(result).toBeNull();
+    });
+  });
+
+  describe("updateUserLoginTimestamp", () => {
+    it("treba da ažurira vreme poslednje prijave", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => true,
+        data: () => mockUser,
+      });
+
+      const result = await userService.updateUserLoginTimestamp("test-uid");
+
+      expect(setDoc).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({
+          lastLoginAt: serverTimestamp(),
+          updatedAt: serverTimestamp(),
+        }),
+        { merge: true }
+      );
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          lastLoginAt: expect.any(Date),
+          updatedAt: expect.any(Date),
+        })
+      );
+    });
+
+    it("treba da baci grešku ako korisnik ne postoji", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => false,
+      });
+
+      await expect(
+        userService.updateUserLoginTimestamp("non-existent")
+      ).rejects.toEqual(AUTH_ERRORS.USER_NOT_FOUND);
+    });
+  });
+
+  describe("upgradeAnonymousUser", () => {
+    it("treba da nadogradi anonimnog korisnika", async () => {
+      const email = "test@example.com";
+      const result = await userService.upgradeAnonymousUser("test-uid", email);
+
+      const mockTimestamp = new Date();
+      (serverTimestamp as jest.Mock).mockReturnValue(mockTimestamp);
+
+      expect(updateDoc).toHaveBeenCalledWith(
+        { id: "test-uid" },
+        expect.objectContaining({
+          email,
+          isAnonymous: false,
+          updatedAt: expect.any(Date),
+        })
+      );
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          email,
+          isAnonymous: false,
+          updatedAt: mockTimestamp,
+        })
+      );
+    });
+
+    it("treba da baci grešku ako korisnik ne postoji", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => false,
+      });
+
+      await expect(
+        userService.upgradeAnonymousUser("non-existent", "test@example.com")
+      ).rejects.toEqual(USER_ERRORS.NOT_FOUND);
+    });
+  });
+
+  describe("getUsersByRole", () => {
+    it("treba da vrati listu korisnika sa određenom ulogom", async () => {
+      const result = await userService.getUsersByRole(UserRole.PATIENT);
+      expect(result).toEqual([mockUser]);
+    });
+  });
+
+  describe("updateUser", () => {
+    const updates = { email: "updated@example.com" };
+
+    it("treba da ažurira korisnika ako postoji", async () => {
+      const updatedUser = {
+        ...mockUser,
+        ...updates,
+        updatedAt: expect.any(Date),
+      };
+
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => true,
+        data: () => mockUser,
+      });
+
+      const result = await userService.updateUser("test-uid", updates);
+
+      expect(updateDoc).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({
+          email: updates.email,
+          updatedAt: serverTimestamp(),
+        })
+      );
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          email: updates.email,
+          updatedAt: expect.any(Date),
+        })
+      );
+    });
+
+    it("treba da baci grešku ako korisnik ne postoji", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => false,
+      });
+
+      await expect(
+        userService.updateUser("non-existent", updates)
+      ).rejects.toThrow(USER_ERRORS.NOT_FOUND.message);
+    });
+
+    it("treba da baci grešku ako podaci nisu validni", async () => {
+      const invalidUpdates = { email: "invalid-email" };
+
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => true,
+        data: () => mockUser,
+      });
+
+      await expect(
+        userService.updateUser("test-uid", invalidUpdates)
+      ).rejects.toThrow(USER_ERRORS.VALIDATION_ERROR.message);
+    });
+  });
+
+  describe("addRole", () => {
+    it("treba da doda novu ulogu i kreira odgovarajući profil", async () => {
+      const newRole = UserRole.CLINIC_ADMIN;
+      const result = await userService.addRole("test-uid", newRole);
+
+      expect(updateDoc).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({
+          roles: [...mockUser.roles, newRole],
+          adminProfile: "admin-profile-id",
+          updatedAt: expect.any(Date),
+        })
+      );
+
+      expect(result).toEqual(
+        expect.objectContaining({
+          roles: [...mockUser.roles, newRole],
+          adminProfile: "admin-profile-id",
+        })
+      );
+    });
+
+    it("treba da baci grešku ako uloga već postoji", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => true,
+        data: () => mockUser,
+      });
+
+      await expect(
+        userService.addRole("test-uid", UserRole.PATIENT)
+      ).rejects.toEqual(USER_ERRORS.ROLE_EXISTS);
+    });
+
+    it("treba da baci grešku ako korisnik ima maksimalan broj uloga", async () => {
+      const userWithMaxRoles = {
+        ...mockUser,
+        roles: [UserRole.PATIENT, UserRole.PRACTITIONER, UserRole.CLINIC_ADMIN],
+      };
+
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => true,
+        data: () => userWithMaxRoles,
+      });
+
+      await expect(
+        userService.addRole("test-uid", UserRole.PATIENT)
+      ).rejects.toEqual(USER_ERRORS.MAX_ROLES_EXCEEDED);
+    });
+  });
+
+  describe("removeRole", () => {
+    it("treba da ukloni ulogu korisniku", async () => {
+      const userWithMultipleRoles = {
+        ...mockUser,
+        roles: [UserRole.PATIENT, UserRole.PRACTITIONER],
+        createdAt: mockTimestamp.now(),
+        updatedAt: mockTimestamp.now(),
+        lastLoginAt: mockTimestamp.now(),
+      };
+      const updatedUser = {
+        ...userWithMultipleRoles,
+        roles: [UserRole.PRACTITIONER],
+        createdAt: mockTimestamp.now(),
+        updatedAt: mockTimestamp.now(),
+        lastLoginAt: mockTimestamp.now(),
+      };
+
+      (getDoc as jest.Mock)
+        .mockResolvedValueOnce({
+          exists: () => true,
+          data: () => userWithMultipleRoles,
+        })
+        .mockResolvedValueOnce({
+          exists: () => true,
+          data: () => updatedUser,
+        });
+
+      await userService.removeRole("test-uid", UserRole.PATIENT);
+
+      // Provera da li je pozvan updateDoc sa ispravnim parametrima
+      expect(updateDoc).toHaveBeenCalledWith(
+        { id: "test-uid" },
+        expect.objectContaining({
+          roles: [UserRole.PRACTITIONER],
+          updatedAt: mockTimestamp.now(),
+        })
+      );
+    });
+  });
+
+  describe("deleteUser", () => {
+    it("treba da obriše korisnika i njegove profile", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => true,
+        data: () => mockUser,
+      });
+
+      await userService.deleteUser("test-uid");
+
+      expect(deleteDoc).toHaveBeenCalled();
+      expect(mockPatientService.deletePatientProfile).toHaveBeenCalledWith(
+        "test-uid"
+      );
+    });
+
+    it("treba da baci grešku ako korisnik ne postoji", async () => {
+      (getDoc as jest.Mock).mockResolvedValueOnce({
+        exists: () => false,
+      });
+
+      await expect(userService.deleteUser("non-existent")).rejects.toEqual(
+        USER_ERRORS.NOT_FOUND
+      );
+    });
+  });
+});