@blackcode_sa/metaestetics-api 1.13.3 → 1.13.5

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

@@ -1,346 +1,346 @@
-// Mock Firebase Auth
-const mockFirebaseUser = {
-  uid: "test-uid",
-  email: "test@example.com",
-  isAnonymous: false,
-  emailVerified: false,
-  metadata: {},
-  providerData: [],
-  refreshToken: "test-refresh-token",
-  tenantId: null,
-  delete: jest.fn(),
-  getIdToken: jest.fn(),
-  getIdTokenResult: jest.fn(),
-  reload: jest.fn(),
-  toJSON: jest.fn(),
-  displayName: null,
-  phoneNumber: null,
-  photoURL: null,
-  providerId: "firebase",
-} as unknown as FirebaseUser;
-
-const mockAnonymousUser = {
-  ...mockFirebaseUser,
-  uid: "test-uid",
-  email: null,
-  isAnonymous: true,
-} as unknown as FirebaseUser;
-
-const mockAuth = {
-  currentUser: mockFirebaseUser as FirebaseUser | null,
-  signInWithEmailAndPassword: jest
-    .fn()
-    .mockImplementation((auth, email, password) => {
-      if (email === "invalid-email") {
-        throw new Error("Invalid email format");
-      }
-      if (password.length < 8) {
-        throw new Error("Password must be at least 8 characters");
-      }
-      return Promise.resolve({ user: mockFirebaseUser });
-    }),
-  createUserWithEmailAndPassword: jest
-    .fn()
-    .mockImplementation((auth, email, password) => {
-      if (email === "invalid-email") {
-        throw new Error("Invalid email format");
-      }
-      if (password.length < 8) {
-        throw new Error("Password must be at least 8 characters");
-      }
-      return Promise.resolve({ user: mockFirebaseUser });
-    }),
-  signInAnonymously: jest.fn().mockResolvedValue({ user: mockAnonymousUser }),
-  signOut: jest.fn().mockResolvedValue(undefined),
-  signInWithPopup: jest.fn().mockImplementation((auth, provider) => {
-    if (provider.providerId === "facebook.com") {
-      return Promise.resolve({ user: mockFacebookUser });
-    }
-    if (provider.providerId === "apple.com") {
-      return Promise.resolve({ user: mockAppleUser });
-    }
-    return Promise.resolve({ user: mockFirebaseUser });
-  }),
-  onAuthStateChanged: jest.fn(),
-};
-
-// Hoisting mocks
-jest.mock("firebase/auth", () => ({
-  getAuth: jest.fn().mockReturnValue(mockAuth),
-  GoogleAuthProvider: jest.fn().mockImplementation(() => ({})),
-  FacebookAuthProvider: jest.fn().mockImplementation(() => ({})),
-  OAuthProvider: jest.fn().mockImplementation(() => ({})),
-  signInWithEmailAndPassword: jest
-    .fn()
-    .mockImplementation((auth, email, password) => {
-      if (email === "invalid-email") {
-        throw new Error("Invalid email format");
-      }
-      if (password.length < 8) {
-        throw new Error("Password must be at least 8 characters");
-      }
-      return Promise.resolve({ user: mockFirebaseUser });
-    }),
-  createUserWithEmailAndPassword: jest
-    .fn()
-    .mockImplementation((auth, email, password) => {
-      if (email === "invalid-email") {
-        throw new Error("Invalid email format");
-      }
-      if (password.length < 8) {
-        throw new Error("Password must be at least 8 characters");
-      }
-      return Promise.resolve({ user: mockFirebaseUser });
-    }),
-  signInAnonymously: jest.fn().mockResolvedValue({ user: mockAnonymousUser }),
-  signOut: jest.fn().mockResolvedValue(undefined),
-  signInWithPopup: jest.fn().mockImplementation((auth, provider) => {
-    if (provider.providerId === "facebook.com") {
-      return Promise.resolve({ user: mockFacebookUser });
-    }
-    if (provider.providerId === "apple.com") {
-      return Promise.resolve({ user: mockAppleUser });
-    }
-    return Promise.resolve({ user: mockFirebaseUser });
-  }),
-  onAuthStateChanged: jest.fn(),
-}));
-
-jest.mock("../../config/firebase", () => ({
-  initializeFirebase: jest.fn().mockResolvedValue({
-    app: {},
-    auth: mockAuth,
-    db: {},
-    analytics: null,
-  }),
-  getFirebaseInstance: jest.fn().mockResolvedValue({
-    db: {},
-    auth: mockAuth,
-  }),
-}));
-
-import { AuthService } from "../auth/auth.service";
-import { User as FirebaseUser } from "firebase/auth";
-import { UserRole } from "../../types";
-
-const mockFacebookUser = {
-  ...mockFirebaseUser,
-  uid: "facebook-uid",
-  email: "facebook@example.com",
-} as unknown as FirebaseUser;
-
-const mockAppleUser = {
-  ...mockFirebaseUser,
-  uid: "apple-uid",
-  email: "apple@example.com",
-} as unknown as FirebaseUser;
-
-// Setup mocks
-beforeAll(() => {
-  const { initializeFirebase } = require("../../config/firebase");
-  (initializeFirebase as jest.Mock).mockResolvedValue({
-    app: {},
-    auth: mockAuth,
-    db: {},
-    analytics: null,
-  });
-});
-
-describe("AuthService", () => {
-  let service: AuthService;
-
-  beforeEach(async () => {
-    service = new AuthService();
-    await service["initialized"]; // Čekamo da se inicijalizacija završi
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe("signUp", () => {
-    it("should create a new user account with email and password", async () => {
-      const email = "test@example.com";
-      const password = "Password123!";
-      const expectedUser = {
-        uid: "test-uid",
-        email: "test@example.com",
-        roles: [UserRole.PATIENT],
-        isAnonymous: false,
-        createdAt: expect.any(Date),
-        updatedAt: expect.any(Date),
-        lastLoginAt: expect.any(Date),
-        patientProfile: {
-          firstName: "Test",
-          lastName: "User",
-        },
-        practitionerProfile: null,
-        adminProfile: null,
-      };
-
-      const result = await service.signUp(email, password, UserRole.PATIENT);
-
-      expect(result).toEqual(expectedUser);
-    });
-
-    it("should throw an error if email is invalid", async () => {
-      const email = "invalid-email";
-      const password = "Password123!";
-
-      await expect(
-        service.signUp(email, password, UserRole.PATIENT)
-      ).rejects.toThrow("Invalid email format");
-    });
-
-    it("should throw an error if password is invalid", async () => {
-      const email = "test@example.com";
-      const password = "123"; // Prekratka lozinka
-
-      await expect(
-        service.signUp(email, password, UserRole.PATIENT)
-      ).rejects.toThrow("Password must be at least 8 characters");
-    });
-  });
-
-  describe("signIn", () => {
-    it("should sign in user with email and password", async () => {
-      const email = "test@example.com";
-      const password = "Password123!";
-      const expectedUser = {
-        uid: "test-uid",
-        email: "test@example.com",
-        roles: [UserRole.PATIENT],
-        isAnonymous: false,
-        createdAt: expect.any(Date),
-        updatedAt: expect.any(Date),
-        lastLoginAt: expect.any(Date),
-        patientProfile: null,
-        practitionerProfile: null,
-        adminProfile: null,
-      };
-
-      const result = await service.signIn(email, password);
-
-      expect(result).toEqual(expectedUser);
-    });
-
-    it("should throw an error if email is invalid", async () => {
-      const email = "invalid-email";
-      const password = "Password123!";
-
-      await expect(service.signIn(email, password)).rejects.toThrow(
-        "Invalid email format"
-      );
-    });
-
-    it("should throw an error if password is invalid", async () => {
-      const email = "test@example.com";
-      const password = "123";
-
-      await expect(service.signIn(email, password)).rejects.toThrow(
-        "Password must be at least 8 characters"
-      );
-    });
-  });
-
-  describe("signInWithFacebook", () => {
-    it("should sign in user with Facebook", async () => {
-      const expectedUser = {
-        uid: "facebook-uid",
-        email: "facebook@example.com",
-        roles: [UserRole.PATIENT],
-        isAnonymous: false,
-        createdAt: expect.any(Date),
-        updatedAt: expect.any(Date),
-        lastLoginAt: expect.any(Date),
-        patientProfile: null,
-        practitionerProfile: null,
-        adminProfile: null,
-      };
-
-      const result = await service.signInWithFacebook();
-
-      expect(result).toEqual(expectedUser);
-    });
-  });
-
-  describe("signInWithApple", () => {
-    it("should sign in user with Apple", async () => {
-      const expectedUser = {
-        uid: "apple-uid",
-        email: "apple@example.com",
-        roles: [UserRole.PATIENT],
-        isAnonymous: false,
-        createdAt: expect.any(Date),
-        updatedAt: expect.any(Date),
-        lastLoginAt: expect.any(Date),
-        patientProfile: null,
-        practitionerProfile: null,
-        adminProfile: null,
-      };
-
-      const result = await service.signInWithApple();
-
-      expect(result).toEqual(expectedUser);
-    });
-  });
-
-  describe("signInAnonymously", () => {
-    it("should sign in user anonymously", async () => {
-      const expectedUser = {
-        uid: "test-uid",
-        email: null,
-        roles: [UserRole.PATIENT],
-        isAnonymous: true,
-        createdAt: expect.any(Date),
-        updatedAt: expect.any(Date),
-        lastLoginAt: expect.any(Date),
-        patientProfile: null,
-        practitionerProfile: null,
-        adminProfile: null,
-      };
-
-      const result = await service.signInAnonymously();
-
-      expect(result).toEqual(expectedUser);
-    });
-  });
-
-  describe("signOut", () => {
-    it("should sign out current user", async () => {
-      await expect(service.signOut()).resolves.not.toThrow();
-    });
-  });
-
-  describe("getCurrentUser", () => {
-    it("should return current user", async () => {
-      const expectedUser = {
-        uid: "test-uid",
-        email: "test@example.com",
-        roles: [UserRole.PATIENT],
-        isAnonymous: false,
-        createdAt: expect.any(Date),
-        updatedAt: expect.any(Date),
-        lastLoginAt: expect.any(Date),
-        patientProfile: null,
-        practitionerProfile: null,
-        adminProfile: null,
-      };
-
-      const result = await service.getCurrentUser();
-
-      expect(result).toEqual(expectedUser);
-    });
-
-    it("should return null when no user is signed in", async () => {
-      mockAuth.currentUser = null;
-
-      const result = await service.getCurrentUser();
-
-      expect(result).toBeNull();
-
-      // Vraćamo originalnu vrednost
-      mockAuth.currentUser = mockFirebaseUser as FirebaseUser;
-    });
-  });
-});
+// Mock Firebase Auth
+const mockFirebaseUser = {
+  uid: "test-uid",
+  email: "test@example.com",
+  isAnonymous: false,
+  emailVerified: false,
+  metadata: {},
+  providerData: [],
+  refreshToken: "test-refresh-token",
+  tenantId: null,
+  delete: jest.fn(),
+  getIdToken: jest.fn(),
+  getIdTokenResult: jest.fn(),
+  reload: jest.fn(),
+  toJSON: jest.fn(),
+  displayName: null,
+  phoneNumber: null,
+  photoURL: null,
+  providerId: "firebase",
+} as unknown as FirebaseUser;
+
+const mockAnonymousUser = {
+  ...mockFirebaseUser,
+  uid: "test-uid",
+  email: null,
+  isAnonymous: true,
+} as unknown as FirebaseUser;
+
+const mockAuth = {
+  currentUser: mockFirebaseUser as FirebaseUser | null,
+  signInWithEmailAndPassword: jest
+    .fn()
+    .mockImplementation((auth, email, password) => {
+      if (email === "invalid-email") {
+        throw new Error("Invalid email format");
+      }
+      if (password.length < 8) {
+        throw new Error("Password must be at least 8 characters");
+      }
+      return Promise.resolve({ user: mockFirebaseUser });
+    }),
+  createUserWithEmailAndPassword: jest
+    .fn()
+    .mockImplementation((auth, email, password) => {
+      if (email === "invalid-email") {
+        throw new Error("Invalid email format");
+      }
+      if (password.length < 8) {
+        throw new Error("Password must be at least 8 characters");
+      }
+      return Promise.resolve({ user: mockFirebaseUser });
+    }),
+  signInAnonymously: jest.fn().mockResolvedValue({ user: mockAnonymousUser }),
+  signOut: jest.fn().mockResolvedValue(undefined),
+  signInWithPopup: jest.fn().mockImplementation((auth, provider) => {
+    if (provider.providerId === "facebook.com") {
+      return Promise.resolve({ user: mockFacebookUser });
+    }
+    if (provider.providerId === "apple.com") {
+      return Promise.resolve({ user: mockAppleUser });
+    }
+    return Promise.resolve({ user: mockFirebaseUser });
+  }),
+  onAuthStateChanged: jest.fn(),
+};
+
+// Hoisting mocks
+jest.mock("firebase/auth", () => ({
+  getAuth: jest.fn().mockReturnValue(mockAuth),
+  GoogleAuthProvider: jest.fn().mockImplementation(() => ({})),
+  FacebookAuthProvider: jest.fn().mockImplementation(() => ({})),
+  OAuthProvider: jest.fn().mockImplementation(() => ({})),
+  signInWithEmailAndPassword: jest
+    .fn()
+    .mockImplementation((auth, email, password) => {
+      if (email === "invalid-email") {
+        throw new Error("Invalid email format");
+      }
+      if (password.length < 8) {
+        throw new Error("Password must be at least 8 characters");
+      }
+      return Promise.resolve({ user: mockFirebaseUser });
+    }),
+  createUserWithEmailAndPassword: jest
+    .fn()
+    .mockImplementation((auth, email, password) => {
+      if (email === "invalid-email") {
+        throw new Error("Invalid email format");
+      }
+      if (password.length < 8) {
+        throw new Error("Password must be at least 8 characters");
+      }
+      return Promise.resolve({ user: mockFirebaseUser });
+    }),
+  signInAnonymously: jest.fn().mockResolvedValue({ user: mockAnonymousUser }),
+  signOut: jest.fn().mockResolvedValue(undefined),
+  signInWithPopup: jest.fn().mockImplementation((auth, provider) => {
+    if (provider.providerId === "facebook.com") {
+      return Promise.resolve({ user: mockFacebookUser });
+    }
+    if (provider.providerId === "apple.com") {
+      return Promise.resolve({ user: mockAppleUser });
+    }
+    return Promise.resolve({ user: mockFirebaseUser });
+  }),
+  onAuthStateChanged: jest.fn(),
+}));
+
+jest.mock("../../config/firebase", () => ({
+  initializeFirebase: jest.fn().mockResolvedValue({
+    app: {},
+    auth: mockAuth,
+    db: {},
+    analytics: null,
+  }),
+  getFirebaseInstance: jest.fn().mockResolvedValue({
+    db: {},
+    auth: mockAuth,
+  }),
+}));
+
+import { AuthService } from "../auth/auth.service";
+import { User as FirebaseUser } from "firebase/auth";
+import { UserRole } from "../../types";
+
+const mockFacebookUser = {
+  ...mockFirebaseUser,
+  uid: "facebook-uid",
+  email: "facebook@example.com",
+} as unknown as FirebaseUser;
+
+const mockAppleUser = {
+  ...mockFirebaseUser,
+  uid: "apple-uid",
+  email: "apple@example.com",
+} as unknown as FirebaseUser;
+
+// Setup mocks
+beforeAll(() => {
+  const { initializeFirebase } = require("../../config/firebase");
+  (initializeFirebase as jest.Mock).mockResolvedValue({
+    app: {},
+    auth: mockAuth,
+    db: {},
+    analytics: null,
+  });
+});
+
+describe("AuthService", () => {
+  let service: AuthService;
+
+  beforeEach(async () => {
+    service = new AuthService();
+    await service["initialized"]; // Čekamo da se inicijalizacija završi
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe("signUp", () => {
+    it("should create a new user account with email and password", async () => {
+      const email = "test@example.com";
+      const password = "Password123!";
+      const expectedUser = {
+        uid: "test-uid",
+        email: "test@example.com",
+        roles: [UserRole.PATIENT],
+        isAnonymous: false,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+        lastLoginAt: expect.any(Date),
+        patientProfile: {
+          firstName: "Test",
+          lastName: "User",
+        },
+        practitionerProfile: null,
+        adminProfile: null,
+      };
+
+      const result = await service.signUp(email, password, UserRole.PATIENT);
+
+      expect(result).toEqual(expectedUser);
+    });
+
+    it("should throw an error if email is invalid", async () => {
+      const email = "invalid-email";
+      const password = "Password123!";
+
+      await expect(
+        service.signUp(email, password, UserRole.PATIENT)
+      ).rejects.toThrow("Invalid email format");
+    });
+
+    it("should throw an error if password is invalid", async () => {
+      const email = "test@example.com";
+      const password = "123"; // Prekratka lozinka
+
+      await expect(
+        service.signUp(email, password, UserRole.PATIENT)
+      ).rejects.toThrow("Password must be at least 8 characters");
+    });
+  });
+
+  describe("signIn", () => {
+    it("should sign in user with email and password", async () => {
+      const email = "test@example.com";
+      const password = "Password123!";
+      const expectedUser = {
+        uid: "test-uid",
+        email: "test@example.com",
+        roles: [UserRole.PATIENT],
+        isAnonymous: false,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+        lastLoginAt: expect.any(Date),
+        patientProfile: null,
+        practitionerProfile: null,
+        adminProfile: null,
+      };
+
+      const result = await service.signIn(email, password);
+
+      expect(result).toEqual(expectedUser);
+    });
+
+    it("should throw an error if email is invalid", async () => {
+      const email = "invalid-email";
+      const password = "Password123!";
+
+      await expect(service.signIn(email, password)).rejects.toThrow(
+        "Invalid email format"
+      );
+    });
+
+    it("should throw an error if password is invalid", async () => {
+      const email = "test@example.com";
+      const password = "123";
+
+      await expect(service.signIn(email, password)).rejects.toThrow(
+        "Password must be at least 8 characters"
+      );
+    });
+  });
+
+  describe("signInWithFacebook", () => {
+    it("should sign in user with Facebook", async () => {
+      const expectedUser = {
+        uid: "facebook-uid",
+        email: "facebook@example.com",
+        roles: [UserRole.PATIENT],
+        isAnonymous: false,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+        lastLoginAt: expect.any(Date),
+        patientProfile: null,
+        practitionerProfile: null,
+        adminProfile: null,
+      };
+
+      const result = await service.signInWithFacebook();
+
+      expect(result).toEqual(expectedUser);
+    });
+  });
+
+  describe("signInWithApple", () => {
+    it("should sign in user with Apple", async () => {
+      const expectedUser = {
+        uid: "apple-uid",
+        email: "apple@example.com",
+        roles: [UserRole.PATIENT],
+        isAnonymous: false,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+        lastLoginAt: expect.any(Date),
+        patientProfile: null,
+        practitionerProfile: null,
+        adminProfile: null,
+      };
+
+      const result = await service.signInWithApple();
+
+      expect(result).toEqual(expectedUser);
+    });
+  });
+
+  describe("signInAnonymously", () => {
+    it("should sign in user anonymously", async () => {
+      const expectedUser = {
+        uid: "test-uid",
+        email: null,
+        roles: [UserRole.PATIENT],
+        isAnonymous: true,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+        lastLoginAt: expect.any(Date),
+        patientProfile: null,
+        practitionerProfile: null,
+        adminProfile: null,
+      };
+
+      const result = await service.signInAnonymously();
+
+      expect(result).toEqual(expectedUser);
+    });
+  });
+
+  describe("signOut", () => {
+    it("should sign out current user", async () => {
+      await expect(service.signOut()).resolves.not.toThrow();
+    });
+  });
+
+  describe("getCurrentUser", () => {
+    it("should return current user", async () => {
+      const expectedUser = {
+        uid: "test-uid",
+        email: "test@example.com",
+        roles: [UserRole.PATIENT],
+        isAnonymous: false,
+        createdAt: expect.any(Date),
+        updatedAt: expect.any(Date),
+        lastLoginAt: expect.any(Date),
+        patientProfile: null,
+        practitionerProfile: null,
+        adminProfile: null,
+      };
+
+      const result = await service.getCurrentUser();
+
+      expect(result).toEqual(expectedUser);
+    });
+
+    it("should return null when no user is signed in", async () => {
+      mockAuth.currentUser = null;
+
+      const result = await service.getCurrentUser();
+
+      expect(result).toBeNull();
+
+      // Vraćamo originalnu vrednost
+      mockAuth.currentUser = mockFirebaseUser as FirebaseUser;
+    });
+  });
+});