@youversion/platform-react-hooks 1.18.1 → 1.19.0

package/src/useVOTD.test.tsx

@@ -1,11 +1,11 @@
 import { renderHook, waitFor } from '@testing-library/react';
-import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
+import { describe, expect, vi, beforeEach, it, type Mock } from 'vitest';
 import type { ReactNode } from 'react';
 import { useVerseOfTheDay } from './useVOTD';
 import { YouVersionContext } from './context';
 import { BibleClient, ApiClient, type VOTD } from '@youversion/platform-core';
+import { createYVWrapper } from './test/utils';
 
-// Mock the core package
 vi.mock('@youversion/platform-core', async () => {
   const actual = await vi.importActual('@youversion/platform-core');
   return {
@@ -20,8 +20,6 @@ vi.mock('@youversion/platform-core', async () => {
 });
 
 describe('useVerseOfTheDay', () => {
-  const mockAppKey = 'test-app-key';
-
   const mockVOTD: VOTD = {
     day: 1,
     passage_id: 'ISA.43.19',
@@ -29,15 +27,7 @@ describe('useVerseOfTheDay', () => {
 
   let mockGetVOTD: Mock;
 
-  const createWrapper = (contextValue: { appKey: string }) => {
-    return ({ children }: { children: ReactNode }) => (
-      <YouVersionContext.Provider value={contextValue}>{children}</YouVersionContext.Provider>
-    );
-  };
-
   beforeEach(() => {
-    vi.clearAllMocks();
-
     mockGetVOTD = vi.fn().mockResolvedValue(mockVOTD);
 
     (BibleClient as unknown as ReturnType<typeof vi.fn>).mockImplementation(function () {
@@ -61,9 +51,7 @@ describe('useVerseOfTheDay', () => {
     });
 
     it('should throw error when appKey is missing', () => {
-      const wrapper = createWrapper({
-        appKey: '',
-      });
+      const wrapper = createYVWrapper('');
 
       expect(() => renderHook(() => useVerseOfTheDay(1), { wrapper })).toThrow(
         'YouVersion context not found. Make sure your component is wrapped with YouVersionProvider and an API key is provided.',
@@ -73,23 +61,17 @@ describe('useVerseOfTheDay', () => {
 
   describe('client creation', () => {
     it('should create BibleClient with correct ApiClient config', () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       renderHook(() => useVerseOfTheDay(1), { wrapper });
 
       expect(ApiClient).toHaveBeenCalledWith({
-        appKey: mockAppKey,
+        appKey: 'test-app-key',
       });
       expect(BibleClient).toHaveBeenCalledWith(expect.objectContaining({ isApiClient: true }));
     });
 
     it('should memoize BibleClient instance', () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result, rerender } = renderHook(() => useVerseOfTheDay(1), { wrapper });
       const _firstRefetch = result.current.refetch;
 
@@ -100,7 +82,7 @@ describe('useVerseOfTheDay', () => {
     });
 
     it('should create new BibleClient when context values change', () => {
-      let currentAppKey = mockAppKey;
+      let currentAppKey = 'test-app-key';
 
       const wrapper = ({ children }: { children: ReactNode }) => (
         <YouVersionContext.Provider
@@ -125,10 +107,7 @@ describe('useVerseOfTheDay', () => {
 
   describe('fetching VOTD', () => {
     it('should fetch VOTD for day 1', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useVerseOfTheDay(1), { wrapper });
 
       expect(result.current.loading).toBe(true);
@@ -138,51 +117,42 @@ describe('useVerseOfTheDay', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVOTD).toHaveBeenCalledWith(1);
-      expect(result.current.data).toEqual(mockVOTD);
+      expect.soft(mockGetVOTD).toHaveBeenCalledWith(1);
+      expect.soft(result.current.data).toEqual(mockVOTD);
     });
 
     it('should fetch VOTD for day 100', async () => {
+      const wrapper = createYVWrapper();
       const mockVOTD100: VOTD = { day: 100, passage_id: 'PSA.23.1' };
       mockGetVOTD.mockResolvedValueOnce(mockVOTD100);
 
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
       const { result } = renderHook(() => useVerseOfTheDay(100), { wrapper });
 
       await waitFor(() => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVOTD).toHaveBeenCalledWith(100);
-      expect(result.current.data).toEqual(mockVOTD100);
+      expect.soft(mockGetVOTD).toHaveBeenCalledWith(100);
+      expect.soft(result.current.data).toEqual(mockVOTD100);
     });
 
     it('should fetch VOTD for day 366', async () => {
+      const wrapper = createYVWrapper();
       const mockVOTD366: VOTD = { day: 366, passage_id: 'REV.22.21' };
       mockGetVOTD.mockResolvedValueOnce(mockVOTD366);
 
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
       const { result } = renderHook(() => useVerseOfTheDay(366), { wrapper });
 
       await waitFor(() => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVOTD).toHaveBeenCalledWith(366);
-      expect(result.current.data).toEqual(mockVOTD366);
+      expect.soft(mockGetVOTD).toHaveBeenCalledWith(366);
+      expect.soft(result.current.data).toEqual(mockVOTD366);
     });
 
     it('should refetch when day changes', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result, rerender } = renderHook(({ day }) => useVerseOfTheDay(day), {
         wrapper,
         initialProps: { day: 1 },
@@ -192,8 +162,8 @@ describe('useVerseOfTheDay', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVOTD).toHaveBeenCalledTimes(1);
-      expect(mockGetVOTD).toHaveBeenLastCalledWith(1);
+      expect.soft(mockGetVOTD).toHaveBeenCalledTimes(1);
+      expect.soft(mockGetVOTD).toHaveBeenLastCalledWith(1);
 
       rerender({ day: 100 });
 
@@ -201,48 +171,39 @@ describe('useVerseOfTheDay', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVOTD).toHaveBeenCalledTimes(2);
-      expect(mockGetVOTD).toHaveBeenLastCalledWith(100);
+      expect.soft(mockGetVOTD).toHaveBeenCalledTimes(2);
+      expect.soft(mockGetVOTD).toHaveBeenLastCalledWith(100);
     });
 
     it('should not fetch when enabled is false', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useVerseOfTheDay(1, { enabled: false }), { wrapper });
 
       await waitFor(() => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVOTD).not.toHaveBeenCalled();
-      expect(result.current.data).toBe(null);
+      expect.soft(mockGetVOTD).not.toHaveBeenCalled();
+      expect.soft(result.current.data).toBe(null);
     });
 
     it('should handle fetch errors', async () => {
+      const wrapper = createYVWrapper();
       const error = new Error('Failed to fetch VOTD');
       mockGetVOTD.mockRejectedValueOnce(error);
 
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
       const { result } = renderHook(() => useVerseOfTheDay(1), { wrapper });
 
       await waitFor(() => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(result.current.error).toEqual(error);
-      expect(result.current.data).toBe(null);
+      expect.soft(result.current.error).toEqual(error);
+      expect.soft(result.current.data).toBe(null);
     });
 
     it('should support manual refetch', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useVerseOfTheDay(1), { wrapper });
 
       await waitFor(() => {

package/src/useVerse.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 { useVerse } from './useVerse';
-import { YouVersionContext } from './context';
 import { type BibleClient, type BibleVerse } from '@youversion/platform-core';
 import { useBibleClient } from './useBibleClient';
+import { createYVWrapper } from './test/utils';
 
 vi.mock('./useBibleClient');
 
 describe('useVerse', () => {
-  const mockAppKey = 'test-app-key';
   const mockGetVerse = vi.fn();
 
   const mockVerse: BibleVerse = {
@@ -18,15 +16,7 @@ describe('useVerse', () => {
     title: '1',
   };
 
-  const createWrapper = (contextValue: { appKey: string }) => {
-    return ({ children }: { children: ReactNode }) => (
-      <YouVersionContext.Provider value={contextValue}>{children}</YouVersionContext.Provider>
-    );
-  };
-
   beforeEach(() => {
-    vi.resetAllMocks();
-
     mockGetVerse.mockResolvedValue(mockVerse);
 
     const mockClient: Partial<BibleClient> = { getVerse: mockGetVerse };
@@ -35,10 +25,7 @@ describe('useVerse', () => {
 
   describe('fetching verse', () => {
     it('should fetch verse with all 4 parameters', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useVerse(111, 'MAT', 1, 1), { wrapper });
 
       expect(result.current.loading).toBe(true);
@@ -48,131 +35,74 @@ describe('useVerse', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVerse).toHaveBeenCalledWith(111, 'MAT', 1, 1);
-      expect(result.current.verse).toEqual(mockVerse);
-    });
-
-    it('should refetch when versionId changes', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
-      const { result, rerender } = renderHook(({ versionId }) => useVerse(versionId, 'MAT', 1, 1), {
-        wrapper,
-        initialProps: { versionId: 1 },
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetVerse).toHaveBeenCalledTimes(1);
-      expect(mockGetVerse).toHaveBeenLastCalledWith(1, 'MAT', 1, 1);
-
-      act(() => {
-        rerender({ versionId: 111 });
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetVerse).toHaveBeenCalledTimes(2);
-      expect(mockGetVerse).toHaveBeenLastCalledWith(111, 'MAT', 1, 1);
-    });
-
-    it('should refetch when book changes', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
-      const { result, rerender } = renderHook(({ book }) => useVerse(1, book, 1, 1), {
-        wrapper,
-        initialProps: { book: 'MAT' },
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetVerse).toHaveBeenCalledTimes(1);
-      expect(mockGetVerse).toHaveBeenLastCalledWith(1, 'MAT', 1, 1);
-
-      act(() => {
-        rerender({ book: 'GEN' });
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetVerse).toHaveBeenCalledTimes(2);
-      expect(mockGetVerse).toHaveBeenLastCalledWith(1, 'GEN', 1, 1);
-    });
-
-    it('should refetch when chapter changes', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
-      const { result, rerender } = renderHook(({ chapter }) => useVerse(1, 'MAT', chapter, 1), {
-        wrapper,
-        initialProps: { chapter: 1 },
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetVerse).toHaveBeenCalledTimes(1);
-      expect(mockGetVerse).toHaveBeenLastCalledWith(1, 'MAT', 1, 1);
-
-      act(() => {
-        rerender({ chapter: 5 });
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetVerse).toHaveBeenCalledTimes(2);
-      expect(mockGetVerse).toHaveBeenLastCalledWith(1, 'MAT', 5, 1);
+      expect.soft(mockGetVerse).toHaveBeenCalledWith(111, 'MAT', 1, 1);
+      expect.soft(result.current.verse).toEqual(mockVerse);
     });
 
-    it('should refetch when verse changes', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
-      const { result, rerender } = renderHook(({ verse }) => useVerse(1, 'MAT', 1, verse), {
-        wrapper,
-        initialProps: { verse: 1 },
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetVerse).toHaveBeenCalledTimes(1);
-      expect(mockGetVerse).toHaveBeenLastCalledWith(1, 'MAT', 1, 1);
-
-      act(() => {
-        rerender({ verse: 10 });
-      });
-
-      await waitFor(() => {
-        expect(result.current.loading).toBe(false);
-      });
-
-      expect(mockGetVerse).toHaveBeenCalledTimes(2);
-      expect(mockGetVerse).toHaveBeenLastCalledWith(1, 'MAT', 1, 10);
-    });
+    it.each([
+      {
+        param: 'versionId',
+        HookFn: ({ val }: { val: number | string }) => useVerse(val as number, 'MAT', 1, 1),
+        initial: { val: 1 },
+        updated: { val: 111 },
+        expectedInitial: [1, 'MAT', 1, 1],
+        expectedUpdated: [111, 'MAT', 1, 1],
+      },
+      {
+        param: 'book',
+        HookFn: ({ val }: { val: number | string }) => useVerse(1, val as string, 1, 1),
+        initial: { val: 'MAT' },
+        updated: { val: 'GEN' },
+        expectedInitial: [1, 'MAT', 1, 1],
+        expectedUpdated: [1, 'GEN', 1, 1],
+      },
+      {
+        param: 'chapter',
+        HookFn: ({ val }: { val: number | string }) => useVerse(1, 'MAT', val as number, 1),
+        initial: { val: 1 },
+        updated: { val: 5 },
+        expectedInitial: [1, 'MAT', 1, 1],
+        expectedUpdated: [1, 'MAT', 5, 1],
+      },
+      {
+        param: 'verse',
+        HookFn: ({ val }: { val: number | string }) => useVerse(1, 'MAT', 1, val as number),
+        initial: { val: 1 },
+        updated: { val: 10 },
+        expectedInitial: [1, 'MAT', 1, 1],
+        expectedUpdated: [1, 'MAT', 1, 10],
+      },
+    ])(
+      'should refetch when $param changes',
+      async ({ HookFn, initial, updated, expectedInitial, expectedUpdated }) => {
+        const wrapper = createYVWrapper();
+        const { result, rerender } = renderHook(HookFn, {
+          wrapper,
+          initialProps: initial,
+        });
+
+        await waitFor(() => {
+          expect(result.current.loading).toBe(false);
+        });
+
+        expect.soft(mockGetVerse).toHaveBeenCalledTimes(1);
+        expect.soft(mockGetVerse).toHaveBeenLastCalledWith(...expectedInitial);
+
+        act(() => {
+          rerender(updated);
+        });
+
+        await waitFor(() => {
+          expect(result.current.loading).toBe(false);
+        });
+
+        expect.soft(mockGetVerse).toHaveBeenCalledTimes(2);
+        expect.soft(mockGetVerse).toHaveBeenLastCalledWith(...expectedUpdated);
+      },
+    );
 
     it('should not fetch when enabled is false', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useVerse(1, 'MAT', 1, 1, { enabled: false }), {
         wrapper,
       });
@@ -181,33 +111,27 @@ describe('useVerse', () => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(mockGetVerse).not.toHaveBeenCalled();
-      expect(result.current.verse).toBe(null);
+      expect.soft(mockGetVerse).not.toHaveBeenCalled();
+      expect.soft(result.current.verse).toBe(null);
     });
 
     it('should handle fetch errors', async () => {
+      const wrapper = createYVWrapper();
       const error = new Error('Failed to fetch verse');
       mockGetVerse.mockRejectedValueOnce(error);
 
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
       const { result } = renderHook(() => useVerse(1, 'MAT', 1, 1), { wrapper });
 
       await waitFor(() => {
         expect(result.current.loading).toBe(false);
       });
 
-      expect(result.current.error).toEqual(error);
-      expect(result.current.verse).toBe(null);
+      expect.soft(result.current.error).toEqual(error);
+      expect.soft(result.current.verse).toBe(null);
     });
 
     it('should support manual refetch', async () => {
-      const wrapper = createWrapper({
-        appKey: mockAppKey,
-      });
-
+      const wrapper = createYVWrapper();
       const { result } = renderHook(() => useVerse(1, 'MAT', 1, 1), { wrapper });
 
       await waitFor(() => {

package/src/useVerseSelection.ts

@@ -4,6 +4,9 @@ import {
   type VerseSelectionContextData,
 } from './context/VerseSelectionContext';
 
+/**
+ * @deprecated No replacement needed. Remove usage. Will be removed in the next major version.
+ */
 export function useVerseSelection(): VerseSelectionContextData {
   const context = useContext(VerseSelectionContext);
   if (!context) {