@croacroa/react-native-template 2.0.1 → 3.2.0

package/__tests__/hooks/useAuth.test.tsx

@@ -68,8 +68,10 @@ describe("useAuth", () => {
 
     it("should load stored auth on mount", async () => {
       mockSecureStore.getItemAsync.mockImplementation((key) => {
-        if (key === "auth_tokens") return Promise.resolve(JSON.stringify(mockTokens));
-        if (key === "auth_user") return Promise.resolve(JSON.stringify(mockUser));
+        if (key === "auth_tokens")
+          return Promise.resolve(JSON.stringify(mockTokens));
+        if (key === "auth_user")
+          return Promise.resolve(JSON.stringify(mockUser));
         return Promise.resolve(null);
       });
 
@@ -85,8 +87,10 @@ describe("useAuth", () => {
 
     it("should attempt refresh if stored tokens are expired", async () => {
       mockSecureStore.getItemAsync.mockImplementation((key) => {
-        if (key === "auth_tokens") return Promise.resolve(JSON.stringify(expiredTokens));
-        if (key === "auth_user") return Promise.resolve(JSON.stringify(mockUser));
+        if (key === "auth_tokens")
+          return Promise.resolve(JSON.stringify(expiredTokens));
+        if (key === "auth_user")
+          return Promise.resolve(JSON.stringify(mockUser));
         return Promise.resolve(null);
       });
 
@@ -102,9 +106,13 @@ describe("useAuth", () => {
     });
 
     it("should handle storage errors gracefully", async () => {
-      const consoleSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+      const consoleSpy = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
 
-      mockSecureStore.getItemAsync.mockRejectedValue(new Error("Storage error"));
+      mockSecureStore.getItemAsync.mockRejectedValue(
+        new Error("Storage error")
+      );
 
       const { result } = renderHook(() => useAuth(), { wrapper });
 
@@ -173,7 +181,10 @@ describe("useAuth", () => {
         await result.current.signIn("test@example.com", "password123");
       });
 
-      expect(toast.success).toHaveBeenCalledWith("Welcome back!", expect.any(String));
+      expect(toast.success).toHaveBeenCalledWith(
+        "Welcome back!",
+        expect.any(String)
+      );
     });
 
     it("should show error toast on failed sign in", async () => {
@@ -192,7 +203,10 @@ describe("useAuth", () => {
         }
       });
 
-      expect(toast.error).toHaveBeenCalledWith("Sign in failed", expect.any(String));
+      expect(toast.error).toHaveBeenCalledWith(
+        "Sign in failed",
+        expect.any(String)
+      );
     });
   });
 
@@ -205,7 +219,11 @@ describe("useAuth", () => {
       });
 
       await act(async () => {
-        await result.current.signUp("newuser@example.com", "password123", "New User");
+        await result.current.signUp(
+          "newuser@example.com",
+          "password123",
+          "New User"
+        );
       });
 
       expect(result.current.isAuthenticated).toBe(true);
@@ -225,7 +243,10 @@ describe("useAuth", () => {
         await result.current.signUp("new@example.com", "password", "Test");
       });
 
-      expect(toast.success).toHaveBeenCalledWith("Account created!", expect.any(String));
+      expect(toast.success).toHaveBeenCalledWith(
+        "Account created!",
+        expect.any(String)
+      );
     });
   });
 
@@ -233,8 +254,10 @@ describe("useAuth", () => {
     it("should sign out and clear storage", async () => {
       // Start with authenticated state
       mockSecureStore.getItemAsync.mockImplementation((key) => {
-        if (key === "auth_tokens") return Promise.resolve(JSON.stringify(mockTokens));
-        if (key === "auth_user") return Promise.resolve(JSON.stringify(mockUser));
+        if (key === "auth_tokens")
+          return Promise.resolve(JSON.stringify(mockTokens));
+        if (key === "auth_user")
+          return Promise.resolve(JSON.stringify(mockUser));
         return Promise.resolve(null);
       });
 
@@ -250,14 +273,18 @@ describe("useAuth", () => {
 
       expect(result.current.isAuthenticated).toBe(false);
       expect(result.current.user).toBeNull();
-      expect(mockSecureStore.deleteItemAsync).toHaveBeenCalledWith("auth_tokens");
+      expect(mockSecureStore.deleteItemAsync).toHaveBeenCalledWith(
+        "auth_tokens"
+      );
       expect(mockSecureStore.deleteItemAsync).toHaveBeenCalledWith("auth_user");
     });
 
     it("should redirect to login after sign out", async () => {
       mockSecureStore.getItemAsync.mockImplementation((key) => {
-        if (key === "auth_tokens") return Promise.resolve(JSON.stringify(mockTokens));
-        if (key === "auth_user") return Promise.resolve(JSON.stringify(mockUser));
+        if (key === "auth_tokens")
+          return Promise.resolve(JSON.stringify(mockTokens));
+        if (key === "auth_user")
+          return Promise.resolve(JSON.stringify(mockUser));
         return Promise.resolve(null);
       });
 
@@ -278,8 +305,10 @@ describe("useAuth", () => {
       const { toast } = require("@/utils/toast");
 
       mockSecureStore.getItemAsync.mockImplementation((key) => {
-        if (key === "auth_tokens") return Promise.resolve(JSON.stringify(mockTokens));
-        if (key === "auth_user") return Promise.resolve(JSON.stringify(mockUser));
+        if (key === "auth_tokens")
+          return Promise.resolve(JSON.stringify(mockTokens));
+        if (key === "auth_user")
+          return Promise.resolve(JSON.stringify(mockUser));
         return Promise.resolve(null);
       });
 
@@ -300,8 +329,10 @@ describe("useAuth", () => {
   describe("updateUser", () => {
     it("should update user data", async () => {
       mockSecureStore.getItemAsync.mockImplementation((key) => {
-        if (key === "auth_tokens") return Promise.resolve(JSON.stringify(mockTokens));
-        if (key === "auth_user") return Promise.resolve(JSON.stringify(mockUser));
+        if (key === "auth_tokens")
+          return Promise.resolve(JSON.stringify(mockTokens));
+        if (key === "auth_user")
+          return Promise.resolve(JSON.stringify(mockUser));
         return Promise.resolve(null);
       });
 
@@ -337,15 +368,19 @@ describe("useAuth", () => {
 
       expect(result.current.user).toBeNull();
       // setItemAsync should not have been called for user update
-      expect(mockSecureStore.setItemAsync.mock.calls.length).toBe(setItemCallsBefore);
+      expect(mockSecureStore.setItemAsync.mock.calls.length).toBe(
+        setItemCallsBefore
+      );
     });
   });
 
   describe("refreshSession", () => {
     it("should refresh session when tokens exist", async () => {
       mockSecureStore.getItemAsync.mockImplementation((key) => {
-        if (key === "auth_tokens") return Promise.resolve(JSON.stringify(mockTokens));
-        if (key === "auth_user") return Promise.resolve(JSON.stringify(mockUser));
+        if (key === "auth_tokens")
+          return Promise.resolve(JSON.stringify(mockTokens));
+        if (key === "auth_user")
+          return Promise.resolve(JSON.stringify(mockUser));
         return Promise.resolve(null);
       });
 
@@ -390,8 +425,10 @@ describe("useAuth", () => {
 
     it("should setup refresh interval when tokens exist", async () => {
       mockSecureStore.getItemAsync.mockImplementation((key) => {
-        if (key === "auth_tokens") return Promise.resolve(JSON.stringify(mockTokens));
-        if (key === "auth_user") return Promise.resolve(JSON.stringify(mockUser));
+        if (key === "auth_tokens")
+          return Promise.resolve(JSON.stringify(mockTokens));
+        if (key === "auth_user")
+          return Promise.resolve(JSON.stringify(mockUser));
         return Promise.resolve(null);
       });
 
@@ -412,8 +449,10 @@ describe("useAuth", () => {
       };
 
       mockSecureStore.getItemAsync.mockImplementation((key) => {
-        if (key === "auth_tokens") return Promise.resolve(JSON.stringify(soonToExpireTokens));
-        if (key === "auth_user") return Promise.resolve(JSON.stringify(mockUser));
+        if (key === "auth_tokens")
+          return Promise.resolve(JSON.stringify(soonToExpireTokens));
+        if (key === "auth_user")
+          return Promise.resolve(JSON.stringify(mockUser));
         return Promise.resolve(null);
       });
 
@@ -434,7 +473,9 @@ describe("useAuth", () => {
   describe("error handling", () => {
     it("should throw error when useAuth is used outside AuthProvider", () => {
       // Suppress console.error for this test
-      const consoleSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+      const consoleSpy = jest
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
 
       expect(() => {
         renderHook(() => useAuth());
@@ -483,7 +524,9 @@ describe("getAuthToken", () => {
   });
 
   it("should handle storage errors gracefully", async () => {
-    const consoleSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+    const consoleSpy = jest
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
 
     (SecureStore.getItemAsync as jest.Mock).mockRejectedValue(
       new Error("Storage error")

package/__tests__/hooks/useMedia.test.ts

@@ -0,0 +1,318 @@
+import { renderHook, act } from "@testing-library/react-native";
+
+import { useImagePicker } from "@/hooks/useImagePicker";
+import { useUpload } from "@/hooks/useUpload";
+import type { PickedMedia } from "@/services/media/media-picker";
+import type { UploadResult } from "@/services/media/media-upload";
+
+// Mock usePermission
+const mockRequest = jest.fn();
+const mockOpenSettings = jest.fn();
+
+jest.mock("@/hooks/usePermission", () => ({
+  usePermission: jest.fn((type: string) => ({
+    status: "granted",
+    isGranted: true,
+    isBlocked: false,
+    isLoading: false,
+    config: { title: `${type} Access`, message: "Test message", icon: "test" },
+    request: mockRequest,
+    openSettings: mockOpenSettings,
+    refresh: jest.fn(),
+  })),
+}));
+
+// Mock media picker
+const mockPickFromLibrary = jest.fn();
+const mockPickFromCamera = jest.fn();
+
+jest.mock("@/services/media/media-picker", () => ({
+  pickFromLibrary: (...args: any[]) => mockPickFromLibrary(...args),
+  pickFromCamera: (...args: any[]) => mockPickFromCamera(...args),
+}));
+
+// Mock compression
+const mockCompressImage = jest.fn();
+
+jest.mock("@/services/media/compression", () => ({
+  compressImage: (...args: any[]) => mockCompressImage(...args),
+}));
+
+// Mock media upload
+const mockUploadFile = jest.fn();
+
+jest.mock("@/services/media/media-upload", () => ({
+  uploadFile: (...args: any[]) => mockUploadFile(...args),
+}));
+
+// Mock Alert
+jest.mock("react-native", () => {
+  const RN = jest.requireActual("react-native");
+  RN.Alert.alert = jest.fn();
+  return RN;
+});
+
+// Test data
+const mockMedia: PickedMedia = {
+  uri: "file:///test/photo.jpg",
+  width: 1920,
+  height: 1080,
+  type: "image",
+  fileName: "photo.jpg",
+};
+
+const mockCompressedMedia = {
+  uri: "file:///test/compressed.jpg",
+  width: 1080,
+  height: 607,
+};
+
+describe("useImagePicker", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockRequest.mockResolvedValue("granted");
+    mockCompressImage.mockResolvedValue(mockCompressedMedia);
+
+    // Reset usePermission to default "granted" state
+    const { usePermission } = require("@/hooks/usePermission");
+    (usePermission as jest.Mock).mockImplementation((type: string) => ({
+      status: "granted",
+      isGranted: true,
+      isBlocked: false,
+      isLoading: false,
+      config: {
+        title: `${type} Access`,
+        message: "Test message",
+        icon: "test",
+      },
+      request: mockRequest,
+      openSettings: mockOpenSettings,
+      refresh: jest.fn(),
+    }));
+  });
+
+  it("should pick and compress image from library", async () => {
+    mockPickFromLibrary.mockResolvedValue([mockMedia]);
+
+    const { result } = renderHook(() => useImagePicker());
+
+    let picked: PickedMedia | null = null;
+    await act(async () => {
+      picked = await result.current.pickFromLibrary();
+    });
+
+    expect(mockPickFromLibrary).toHaveBeenCalled();
+    expect(mockCompressImage).toHaveBeenCalledWith(mockMedia.uri, {
+      maxWidth: 1080,
+      maxHeight: 1080,
+      quality: 0.7,
+    });
+    expect(picked).toBeTruthy();
+    expect(picked!.uri).toBe(mockCompressedMedia.uri);
+    expect(result.current.selectedMedia).toBeTruthy();
+  });
+
+  it("should pick and compress image from camera", async () => {
+    mockPickFromCamera.mockResolvedValue(mockMedia);
+
+    const { result } = renderHook(() => useImagePicker());
+
+    let picked: PickedMedia | null = null;
+    await act(async () => {
+      picked = await result.current.pickFromCamera();
+    });
+
+    expect(mockPickFromCamera).toHaveBeenCalled();
+    expect(mockCompressImage).toHaveBeenCalled();
+    expect(picked).toBeTruthy();
+    expect(result.current.selectedMedia).toBeTruthy();
+  });
+
+  it("should return preview URI after pick", async () => {
+    mockPickFromLibrary.mockResolvedValue([mockMedia]);
+
+    const { result } = renderHook(() => useImagePicker());
+
+    await act(async () => {
+      await result.current.pickFromLibrary();
+    });
+
+    expect(result.current.selectedMedia?.uri).toBe(mockCompressedMedia.uri);
+  });
+
+  it("should clear state when clear() is called", async () => {
+    mockPickFromLibrary.mockResolvedValue([mockMedia]);
+
+    const { result } = renderHook(() => useImagePicker());
+
+    await act(async () => {
+      await result.current.pickFromLibrary();
+    });
+
+    expect(result.current.selectedMedia).toBeTruthy();
+
+    act(() => {
+      result.current.clear();
+    });
+
+    expect(result.current.selectedMedia).toBeNull();
+  });
+
+  it("should handle permission denied", async () => {
+    const { usePermission } = require("@/hooks/usePermission");
+    (usePermission as jest.Mock).mockImplementation((type: string) => ({
+      status: "denied",
+      isGranted: false,
+      isBlocked: false,
+      isLoading: false,
+      config: {
+        title: `${type} Access`,
+        message: "Test message",
+        icon: "test",
+      },
+      request: mockRequest,
+      openSettings: mockOpenSettings,
+      refresh: jest.fn(),
+    }));
+
+    mockRequest.mockResolvedValue("denied");
+
+    const { result } = renderHook(() => useImagePicker());
+
+    let picked: PickedMedia | null = null;
+    await act(async () => {
+      picked = await result.current.pickFromLibrary();
+    });
+
+    expect(picked).toBeNull();
+    expect(mockPickFromLibrary).not.toHaveBeenCalled();
+  });
+});
+
+describe("useUpload", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("should call uploadFile and track progress", async () => {
+    const mockResult: UploadResult = { status: 200, body: '{"ok":true}' };
+    mockUploadFile.mockReturnValue({
+      promise: Promise.resolve(mockResult),
+      abort: jest.fn(),
+    });
+
+    const { result } = renderHook(() =>
+      useUpload({ url: "https://api.example.com/upload" })
+    );
+
+    let uploadResult: UploadResult | null = null;
+    await act(async () => {
+      uploadResult = await result.current.upload("file:///test/photo.jpg");
+    });
+
+    expect(mockUploadFile).toHaveBeenCalledWith(
+      expect.objectContaining({
+        url: "https://api.example.com/upload",
+        uri: "file:///test/photo.jpg",
+        fieldName: "file",
+      })
+    );
+    expect(uploadResult).toEqual(mockResult);
+  });
+
+  it("should report progress updates", async () => {
+    let onProgressCallback: ((p: any) => void) | null = null;
+    mockUploadFile.mockImplementation((options: any) => {
+      onProgressCallback = options.onProgress;
+      return {
+        promise: new Promise((resolve) => {
+          // Simulate progress then resolve
+          setTimeout(() => {
+            if (onProgressCallback) {
+              onProgressCallback({ loaded: 50, total: 100, percentage: 50 });
+            }
+            resolve({ status: 200, body: "ok" });
+          }, 0);
+        }),
+        abort: jest.fn(),
+      };
+    });
+
+    const { result } = renderHook(() =>
+      useUpload({ url: "https://api.example.com/upload" })
+    );
+
+    await act(async () => {
+      await result.current.upload("file:///test/photo.jpg");
+    });
+
+    // The onProgress callback was provided to uploadFile
+    expect(onProgressCallback).toBeDefined();
+  });
+
+  it("should cancel upload when cancel() is called", async () => {
+    const mockAbort = jest.fn();
+    mockUploadFile.mockReturnValue({
+      promise: new Promise(() => {}), // Never resolves
+      abort: mockAbort,
+    });
+
+    const { result } = renderHook(() =>
+      useUpload({ url: "https://api.example.com/upload" })
+    );
+
+    act(() => {
+      result.current.upload("file:///test/photo.jpg");
+    });
+
+    act(() => {
+      result.current.cancel();
+    });
+
+    expect(mockAbort).toHaveBeenCalled();
+  });
+
+  it("should reset all state when reset() is called", async () => {
+    const mockResult: UploadResult = { status: 200, body: '{"ok":true}' };
+    mockUploadFile.mockReturnValue({
+      promise: Promise.resolve(mockResult),
+      abort: jest.fn(),
+    });
+
+    const { result } = renderHook(() =>
+      useUpload({ url: "https://api.example.com/upload" })
+    );
+
+    await act(async () => {
+      await result.current.upload("file:///test/photo.jpg");
+    });
+
+    act(() => {
+      result.current.reset();
+    });
+
+    expect(result.current.progress).toBeNull();
+    expect(result.current.isUploading).toBe(false);
+    expect(result.current.error).toBeNull();
+  });
+
+  it("should handle upload error", async () => {
+    mockUploadFile.mockReturnValue({
+      promise: Promise.reject(new Error("Network error")),
+      abort: jest.fn(),
+    });
+
+    const { result } = renderHook(() =>
+      useUpload({ url: "https://api.example.com/upload" })
+    );
+
+    let uploadResult: UploadResult | null = null;
+    await act(async () => {
+      uploadResult = await result.current.upload("file:///test/photo.jpg");
+    });
+
+    expect(uploadResult).toBeNull();
+    expect(result.current.error).toBe("Network error");
+    expect(result.current.isUploading).toBe(false);
+  });
+});