@youversion/platform-react-hooks 1.18.1 → 1.20.0

package/src/useVerses.test.tsx

@@ -1,15 +1,13 @@
 import { renderHook, waitFor, act } from '@testing-library/react';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { ReactNode } from 'react';
+import { describe, expect, vi, beforeEach, it } from 'vitest';
 import { useVerses } from './useVerses';
-import { YouVersionContext } from './context';
 import { type BibleClient, type BibleVerse, type Collection } from '@youversion/platform-core';
 import { useBibleClient } from './useBibleClient';
+import { createYVWrapper } from './test/utils';
 
 vi.mock('./useBibleClient');
 
 describe('useVerses', () => {
-  const mockAppKey = 'test-app-key';
   const mockGetVerses = vi.fn();
 
   const mockVerses: Collection<BibleVerse> = {
@@ -21,15 +19,7 @@ describe('useVerses', () => {
     next_page_token: null,
   };
 
-  const createWrapper = (contextValue: { appKey: string }) => {
-    return ({ children }: { children: ReactNode }) => (
-      <YouVersionContext.Provider value={contextValue}>{children}</YouVersionContext.Provider>
-    );
-  };
-
   beforeEach(() => {
-    vi.resetAllMocks();
-
     mockGetVerses.mockResolvedValue(mockVerses);
 
     const mockClient: Partial<BibleClient> = { getVerses: mockGetVerses };
@@ -38,10 +28,7 @@ describe('useVerses', () => {
 
   describe('fetching verses', () => {
     it('should fetch verses with all 3 parameters', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useVerses(111, 'MAT', 1), { wrapper });
 
       expect(result.current.loading).toBe(true);
@@ -51,102 +38,54 @@ describe('useVerses', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVerses).toHaveBeenCalledWith(111, 'MAT', 1);
-      expect(result.current.verses).toEqual(mockVerses);
-    });
-
-    it('should refetch when versionId changes', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
-      const { result, rerender } = renderHook(({ versionId }) => useVerses(versionId, 'MAT', 1), {
-        wrapper,
-        initialProps: { versionId: 1 },
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetVerses).toHaveBeenCalledTimes(1);
-      expect(mockGetVerses).toHaveBeenLastCalledWith(1, 'MAT', 1);
-
-      act(() => {
-        rerender({ versionId: 111 });
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetVerses).toHaveBeenCalledTimes(2);
-      expect(mockGetVerses).toHaveBeenLastCalledWith(111, 'MAT', 1);
-    });
-
-    it('should refetch when book changes', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
-      const { result, rerender } = renderHook(({ book }) => useVerses(1, book, 1), {
-        wrapper,
-        initialProps: { book: 'MAT' },
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetVerses).toHaveBeenCalledTimes(1);
-      expect(mockGetVerses).toHaveBeenLastCalledWith(1, 'MAT', 1);
-
-      act(() => {
-        rerender({ book: 'GEN' });
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetVerses).toHaveBeenCalledTimes(2);
-      expect(mockGetVerses).toHaveBeenLastCalledWith(1, 'GEN', 1);
+      expect.soft(mockGetVerses).toHaveBeenCalledWith(111, 'MAT', 1);
+      expect.soft(result.current.verses).toEqual(mockVerses);
     });
 
-    it('should refetch when chapter changes', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
-      const { result, rerender } = renderHook(({ chapter }) => useVerses(1, 'MAT', chapter), {
+    it.each([
+      {
+        param: 'versionId',
+        initialArgs: [1, 'MAT', 1] as [number, string, number],
+        updatedArgs: [111, 'MAT', 1] as [number, string, number],
+      },
+      {
+        param: 'book',
+        initialArgs: [1, 'MAT', 1] as [number, string, number],
+        updatedArgs: [1, 'GEN', 1] as [number, string, number],
+      },
+      {
+        param: 'chapter',
+        initialArgs: [1, 'MAT', 1] as [number, string, number],
+        updatedArgs: [1, 'MAT', 5] as [number, string, number],
+      },
+    ])('should refetch when $param changes', async ({ initialArgs, updatedArgs }) => {
+      const wrapper = createYVWrapper();
+      const { result, rerender } = renderHook(({ args }) => useVerses(args[0], args[1], args[2]), {
         wrapper,
-        initialProps: { chapter: 1 },
+        initialProps: { args: initialArgs },
       });
 
       await waitFor(() => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVerses).toHaveBeenCalledTimes(1);
-      expect(mockGetVerses).toHaveBeenLastCalledWith(1, 'MAT', 1);
+      expect.soft(mockGetVerses).toHaveBeenCalledTimes(1);
+      expect.soft(mockGetVerses).toHaveBeenLastCalledWith(...initialArgs);
 
       act(() => {
-        rerender({ chapter: 5 });
+        rerender({ args: updatedArgs });
       });
 
       await waitFor(() => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVerses).toHaveBeenCalledTimes(2);
-      expect(mockGetVerses).toHaveBeenLastCalledWith(1, 'MAT', 5);
+      expect.soft(mockGetVerses).toHaveBeenCalledTimes(2);
+      expect.soft(mockGetVerses).toHaveBeenLastCalledWith(...updatedArgs);
     });
 
     it('should not fetch when enabled is false', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useVerses(1, 'MAT', 1, { enabled: false }), {
         wrapper,
       });
@@ -155,33 +94,27 @@ describe('useVerses', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVerses).not.toHaveBeenCalled();
-      expect(result.current.verses).toBe(null);
+      expect.soft(mockGetVerses).not.toHaveBeenCalled();
+      expect.soft(result.current.verses).toBe(null);
     });
 
     it('should handle fetch errors', async () => {
+      const wrapper = createYVWrapper();
       const error = new Error('Failed to fetch verses');
       mockGetVerses.mockRejectedValueOnce(error);
 
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
       const { result } = renderHook(() => useVerses(1, 'MAT', 1), { wrapper });
 
       await waitFor(() => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(result.current.error).toEqual(error);
-      expect(result.current.verses).toBe(null);
+      expect.soft(result.current.error).toEqual(error);
+      expect.soft(result.current.verses).toBe(null);
     });
 
     it('should support manual refetch', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useVerses(1, 'MAT', 1), { wrapper });
 
       await waitFor(() => {

package/src/useVersion.test.tsx

@@ -1,15 +1,13 @@
 import { renderHook, waitFor, act } from '@testing-library/react';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import type { ReactNode } from 'react';
+import { describe, expect, vi, beforeEach, it } from 'vitest';
 import { useVersion } from './useVersion';
-import { YouVersionContext } from './context';
 import { type BibleClient, type BibleVersion } from '@youversion/platform-core';
 import { useBibleClient } from './useBibleClient';
+import { createYVWrapper } from './test/utils';
 
 vi.mock('./useBibleClient');
 
 describe('useVersion', () => {
-  const mockAppKey = 'test-app-key';
   const mockGetVersion = vi.fn();
 
   const mockVersion: BibleVersion = {
@@ -23,15 +21,7 @@ describe('useVersion', () => {
     youversion_deep_link: 'https://bible.com/versions/111',
   };
 
-  const createWrapper = (contextValue: { appKey: string }) => {
-    return ({ children }: { children: ReactNode }) => (
-      <YouVersionContext.Provider value={contextValue}>{children}</YouVersionContext.Provider>
-    );
-  };
-
   beforeEach(() => {
-    vi.resetAllMocks();
-
     mockGetVersion.mockResolvedValue(mockVersion);
 
     const mockClient: Partial<BibleClient> = { getVersion: mockGetVersion };
@@ -40,10 +30,7 @@ describe('useVersion', () => {
 
   describe('fetching version', () => {
     it('should fetch version by ID', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useVersion(111), { wrapper });
 
       expect(result.current.loading).toBe(true);
@@ -53,11 +40,12 @@ describe('useVersion', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVersion).toHaveBeenCalledWith(111);
-      expect(result.current.version).toEqual(mockVersion);
+      expect.soft(mockGetVersion).toHaveBeenCalledWith(111);
+      expect.soft(result.current.version).toEqual(mockVersion);
     });
 
     it('should fetch different version by ID', async () => {
+      const wrapper = createYVWrapper();
       const mockKJV: BibleVersion = {
         id: 1,
         title: 'King James Version',
@@ -70,27 +58,20 @@ describe('useVersion', () => {
       };
       mockGetVersion.mockResolvedValueOnce(mockKJV);
 
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
       const { result } = renderHook(() => useVersion(1), { wrapper });
 
       await waitFor(() => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVersion).toHaveBeenCalledWith(1);
-      expect(result.current.version).toEqual(mockKJV);
+      expect.soft(mockGetVersion).toHaveBeenCalledWith(1);
+      expect.soft(result.current.version).toEqual(mockKJV);
     });
   });
 
   describe('refetch behavior', () => {
     it('should refetch when versionId changes', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result, rerender } = renderHook(({ versionId }) => useVersion(versionId), {
         wrapper,
         initialProps: { versionId: 111 },
@@ -100,8 +81,8 @@ describe('useVersion', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVersion).toHaveBeenCalledTimes(1);
-      expect(mockGetVersion).toHaveBeenNthCalledWith(1, 111);
+      expect.soft(mockGetVersion).toHaveBeenCalledTimes(1);
+      expect.soft(mockGetVersion).toHaveBeenNthCalledWith(1, 111);
 
       rerender({ versionId: 1 });
 
@@ -109,17 +90,14 @@ describe('useVersion', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVersion).toHaveBeenCalledTimes(2);
-      expect(mockGetVersion).toHaveBeenNthCalledWith(2, 1);
+      expect.soft(mockGetVersion).toHaveBeenCalledTimes(2);
+      expect.soft(mockGetVersion).toHaveBeenNthCalledWith(2, 1);
     });
   });
 
   describe('enabled option', () => {
     it('should not fetch when enabled is false', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useVersion(111, { enabled: false }), {
         wrapper,
       });
@@ -128,15 +106,12 @@ describe('useVersion', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVersion).not.toHaveBeenCalled();
-      expect(result.current.version).toBe(null);
+      expect.soft(mockGetVersion).not.toHaveBeenCalled();
+      expect.soft(result.current.version).toBe(null);
     });
 
     it('should fetch when enabled is true', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useVersion(111, { enabled: true }), {
         wrapper,
       });
@@ -145,15 +120,12 @@ describe('useVersion', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVersion).toHaveBeenCalled();
-      expect(result.current.version).toEqual(mockVersion);
+      expect.soft(mockGetVersion).toHaveBeenCalled();
+      expect.soft(result.current.version).toEqual(mockVersion);
     });
 
     it('should fetch when enabled is not specified', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useVersion(111), {
         wrapper,
       });
@@ -168,31 +140,25 @@ describe('useVersion', () => {
 
   describe('error handling', () => {
     it('should handle fetch errors', async () => {
+      const wrapper = createYVWrapper();
       const error = new Error('Failed to fetch version');
       mockGetVersion.mockRejectedValueOnce(error);
 
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
       const { result } = renderHook(() => useVersion(111), { wrapper });
 
       await waitFor(() => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(result.current.error).toEqual(error);
-      expect(result.current.version).toBe(null);
+      expect.soft(result.current.error).toEqual(error);
+      expect.soft(result.current.version).toBe(null);
     });
 
     it('should clear error on successful refetch', async () => {
+      const wrapper = createYVWrapper();
       const error = new Error('Failed to fetch version');
       mockGetVersion.mockRejectedValueOnce(error).mockResolvedValueOnce(mockVersion);
 
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
       const { result } = renderHook(() => useVersion(111), { wrapper });
 
       await waitFor(() => {
@@ -210,25 +176,22 @@ describe('useVersion', () => {
         expect(result.current.error).toBe(null);
       });
 
-      expect(result.current.error).toBe(null);
-      expect(result.current.version).toEqual(mockVersion);
+      expect.soft(result.current.error).toBe(null);
+      expect.soft(result.current.version).toEqual(mockVersion);
     });
   });
 
   describe('manual refetch', () => {
     it('should support manual refetch', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useVersion(111), { wrapper });
 
       await waitFor(() => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVersion).toHaveBeenCalledTimes(1);
-      expect(mockGetVersion).toHaveBeenNthCalledWith(1, 111);
+      expect.soft(mockGetVersion).toHaveBeenCalledTimes(1);
+      expect.soft(mockGetVersion).toHaveBeenNthCalledWith(1, 111);
 
       act(() => {
         result.current.refetch();