@youversion/platform-react-hooks 1.18.1 → 1.20.0

package/src/useYVAuth.test.tsx

@@ -1,5 +1,4 @@
-/* eslint-disable @typescript-eslint/unbound-method, @typescript-eslint/no-unsafe-argument */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { renderHook, act } from '@testing-library/react';
 import { YouVersionAPIUsers, YouVersionPlatformConfiguration } from '@youversion/platform-core';
 import { useYVAuth } from './useYVAuth';
@@ -8,117 +7,10 @@ import { createMockUserInfo, createMockAuthResult } from './__tests__/mocks/auth
 import { createAuthProviderWrapper } from './__tests__/utils/test-utils';
 import type { AuthenticationScopes } from '@youversion/platform-core';
 
-// Mock the core modules
-vi.mock('@youversion/platform-core', () => {
-  // Create a mock configuration object that can be updated
-  const mockConfiguration = {
-    accessToken: null as string | null,
-    idToken: null as string | null,
-    refreshToken: null as string | null,
-    appKey: '',
-    apiHost: 'test-api.example.com',
-    installationId: null as string | null,
-    clearAuthTokens: vi.fn(() => {
-      mockConfiguration.accessToken = null;
-      mockConfiguration.idToken = null;
-      mockConfiguration.refreshToken = null;
-    }),
-    saveAuthData: vi.fn(
-      (
-        accessToken: string | null,
-        refreshToken: string | null,
-        idToken: string | null,
-        installationId: string | null,
-      ) => {
-        mockConfiguration.accessToken = accessToken;
-        mockConfiguration.refreshToken = refreshToken;
-        mockConfiguration.idToken = idToken;
-        mockConfiguration.installationId = installationId;
-      },
-    ),
-  };
-
-  return {
-    YouVersionAPIUsers: {
-      signIn: vi.fn(),
-      handleAuthCallback: vi.fn(),
-      userInfo: vi.fn(),
-      refreshTokenIfNeeded: vi.fn(),
-    },
-    YouVersionPlatformConfiguration: mockConfiguration,
-    SignInWithYouVersionPermission: {
-      bibles: 'bibles',
-      highlights: 'highlights',
-      user: 'user',
-    },
-    YouVersionUserInfo: class YouVersionUserInfo {
-      readonly name?: string;
-      readonly userId?: string;
-      readonly email?: string;
-      readonly avatarUrlFormat?: string;
-
-      constructor(data: any) {
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-        this.name = data.name;
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-        this.userId = data.id;
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-        this.email = data.email;
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
-        this.avatarUrlFormat = data.avatar_url;
-      }
-
-      getAvatarUrl(width: number = 200, height: number = 200): URL | null {
-        if (!this.avatarUrlFormat) {
-          return null;
-        }
-        try {
-          let urlString = this.avatarUrlFormat;
-          urlString = urlString.replace('{width}', width.toString());
-          urlString = urlString.replace('{height}', height.toString());
-          return new URL(urlString);
-        } catch {
-          return null;
-        }
-      }
-
-      get avatarUrl(): URL | null {
-        return this.getAvatarUrl();
-      }
-    },
-    SignInWithYouVersionResult: class SignInWithYouVersionResult {
-      accessToken: string | undefined;
-      expiryDate: Date | undefined;
-      refreshToken: string | undefined;
-      idToken: string | undefined;
-      yvpUserId: string | undefined;
-      name: string | undefined;
-      profilePicture: string | undefined;
-      email: string | undefined;
-
-      constructor(props: {
-        accessToken?: string;
-        expiresIn?: number;
-        refreshToken?: string;
-        idToken?: string;
-        yvpUserId?: string;
-        name?: string;
-        profilePicture?: string;
-        email?: string;
-      }) {
-        this.accessToken = props.accessToken;
-        this.expiryDate = props.expiresIn
-          ? new Date(Date.now() + props.expiresIn * 1000)
-          : new Date();
-        this.refreshToken = props.refreshToken;
-        this.idToken = props.idToken;
-        this.yvpUserId = props.yvpUserId;
-        this.name = props.name;
-        this.profilePicture = props.profilePicture;
-        this.email = props.email;
-      }
-    },
-  };
+// Mock the core modules using shared factory
+vi.mock('@youversion/platform-core', async () => {
+  const { createSimpleCoreMockFactory } = await import('./__tests__/mocks/core-mock-factory');
+  return createSimpleCoreMockFactory();
 });
 
 const mockUserInfo = createMockUserInfo();
@@ -150,8 +42,6 @@ const renderAuthHook = async () => {
 
 describe('useYVAuth', () => {
   beforeEach(() => {
-    vi.resetAllMocks();
-
     // Setup window mock
     vi.stubGlobal('window', mockWindow);
     mockWindow.location.search = '';
@@ -161,11 +51,6 @@ describe('useYVAuth', () => {
     YouVersionPlatformConfiguration.installationId = null;
   });
 
-  afterEach(() => {
-    vi.clearAllMocks();
-    vi.unstubAllGlobals();
-  });
-
   describe('initialization', () => {
     it('should return unauthenticated state when no user info available', async () => {
       const { result } = await renderAuthHook();
@@ -198,7 +83,7 @@ describe('useYVAuth', () => {
         await result.current.signIn({ redirectUrl, scopes: ['profile'] });
       });
 
-      expect(vi.mocked(YouVersionAPIUsers.signIn)).toHaveBeenCalledWith(redirectUrl, ['profile']);
+      expect(vi.mocked(YouVersionAPIUsers).signIn).toHaveBeenCalledWith(redirectUrl, ['profile']);
     });
 
     it('should call signIn with empty scopes when not provided', async () => {
@@ -209,7 +94,7 @@ describe('useYVAuth', () => {
         await result.current.signIn({ redirectUrl });
       });
 
-      expect(vi.mocked(YouVersionAPIUsers.signIn)).toHaveBeenCalledWith(redirectUrl);
+      expect(vi.mocked(YouVersionAPIUsers).signIn).toHaveBeenCalledWith(redirectUrl);
     });
 
     it('should call YouVersionAPIUsers.signIn exactly once with scopes', async () => {
@@ -221,8 +106,8 @@ describe('useYVAuth', () => {
         await result.current.signIn({ redirectUrl, scopes });
       });
 
-      expect(vi.mocked(YouVersionAPIUsers.signIn)).toHaveBeenCalledTimes(1);
-      expect(vi.mocked(YouVersionAPIUsers.signIn)).toHaveBeenCalledWith(redirectUrl, scopes);
+      expect(vi.mocked(YouVersionAPIUsers).signIn).toHaveBeenCalledTimes(1);
+      expect(vi.mocked(YouVersionAPIUsers).signIn).toHaveBeenCalledWith(redirectUrl, scopes);
     });
 
     it('should call YouVersionAPIUsers.signIn exactly once without scopes', async () => {
@@ -233,14 +118,15 @@ describe('useYVAuth', () => {
         await result.current.signIn({ redirectUrl });
       });
 
-      expect(vi.mocked(YouVersionAPIUsers.signIn)).toHaveBeenCalledTimes(1);
-      expect(vi.mocked(YouVersionAPIUsers.signIn)).toHaveBeenCalledWith(redirectUrl);
+      expect(vi.mocked(YouVersionAPIUsers).signIn).toHaveBeenCalledTimes(1);
+      expect(vi.mocked(YouVersionAPIUsers).signIn).toHaveBeenCalledWith(redirectUrl);
     });
 
     it('should throw error when signIn fails', async () => {
       const { result } = await renderAuthHook();
       const error = new Error('Sign in failed');
-      vi.mocked(YouVersionAPIUsers.signIn).mockRejectedValue(error);
+      const signInMock = vi.spyOn(YouVersionAPIUsers, 'signIn');
+      signInMock.mockRejectedValue(error);
 
       await expect(
         act(async () => {
@@ -256,7 +142,7 @@ describe('useYVAuth', () => {
         await result.current.signIn();
       });
 
-      expect(vi.mocked(YouVersionAPIUsers.signIn)).toHaveBeenCalledWith('http://test.example.com');
+      expect(vi.mocked(YouVersionAPIUsers).signIn).toHaveBeenCalledWith('http://test.example.com');
     });
 
     it('should use redirectUri from provider with scopes when redirectUrl is not passed', async () => {
@@ -267,7 +153,7 @@ describe('useYVAuth', () => {
         await result.current.signIn({ scopes });
       });
 
-      expect(vi.mocked(YouVersionAPIUsers.signIn)).toHaveBeenCalledWith(
+      expect(vi.mocked(YouVersionAPIUsers).signIn).toHaveBeenCalledWith(
         'http://test.example.com',
         scopes,
       );
@@ -277,21 +163,23 @@ describe('useYVAuth', () => {
   describe('processCallback', () => {
     it('should call handleAuthCallback and return result', async () => {
       const { result } = await renderAuthHook();
-      vi.mocked(YouVersionAPIUsers.handleAuthCallback).mockResolvedValue(mockAuthResult as any);
+      const callbackMock = vi.spyOn(YouVersionAPIUsers, 'handleAuthCallback');
+      callbackMock.mockResolvedValue(mockAuthResult);
 
       let callbackResult;
       await act(async () => {
         callbackResult = await result.current.processCallback();
       });
 
-      expect(vi.mocked(YouVersionAPIUsers.handleAuthCallback)).toHaveBeenCalled();
+      expect(callbackMock).toHaveBeenCalled();
       expect(callbackResult).toEqual(mockAuthResult);
     });
 
     it('should throw error when callback processing fails', async () => {
       const { result } = await renderAuthHook();
       const error = new Error('Callback processing failed');
-      vi.mocked(YouVersionAPIUsers.handleAuthCallback).mockRejectedValue(error);
+      const callbackMock = vi.spyOn(YouVersionAPIUsers, 'handleAuthCallback');
+      callbackMock.mockRejectedValue(error);
 
       await expect(
         act(async () => {
@@ -302,7 +190,8 @@ describe('useYVAuth', () => {
 
     it('should return null when no result from callback', async () => {
       const { result } = await renderAuthHook();
-      vi.mocked(YouVersionAPIUsers.handleAuthCallback).mockResolvedValue(null);
+      const callbackMock = vi.spyOn(YouVersionAPIUsers, 'handleAuthCallback');
+      callbackMock.mockResolvedValue(null);
 
       let callbackResult;
       await act(async () => {
@@ -317,11 +206,14 @@ describe('useYVAuth', () => {
     it('should call clearAuthTokens and reset user info', async () => {
       const { result } = await renderAuthHook();
 
+      const clearAuthTokensSpy = vi.spyOn(YouVersionPlatformConfiguration, 'clearAuthTokens');
+      clearAuthTokensSpy.mockClear();
+
       act(() => {
         result.current.signOut();
       });
 
-      expect(YouVersionPlatformConfiguration.clearAuthTokens).toHaveBeenCalled();
+      expect(clearAuthTokensSpy).toHaveBeenCalledTimes(1);
     });
   });
 

package/src/utility/getDayOfYear.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect, test } from 'vitest';
+import { getDayOfYear } from './getDayOfYear';
+
+describe('getDayOfYear', () => {
+  // Group 1: Standard days
+  test.for([
+    { date: new Date(2025, 0, 1), expected: 1, label: 'Jan 1' },
+    { date: new Date(2025, 0, 2), expected: 2, label: 'Jan 2' },
+    { date: new Date(2025, 1, 1), expected: 32, label: 'Feb 1' },
+    { date: new Date(2025, 6, 4), expected: 185, label: 'Jul 4 (non-leap)' },
+    { date: new Date(2025, 11, 31), expected: 365, label: 'Dec 31 (non-leap)' },
+  ])('should return $expected for $label', ({ date, expected }, { expect }) => {
+    expect(getDayOfYear(date)).toBe(expected);
+  });
+
+  // Group 2: Leap year handling
+  test.for([
+    { date: new Date(2024, 1, 28), expected: 59, label: 'Feb 28 (leap)' },
+    { date: new Date(2024, 1, 29), expected: 60, label: 'Feb 29 (leap)' },
+    { date: new Date(2024, 2, 1), expected: 61, label: 'Mar 1 (leap)' },
+    { date: new Date(2025, 2, 1), expected: 60, label: 'Mar 1 (non-leap)' },
+    { date: new Date(2024, 11, 31), expected: 366, label: 'Dec 31 (leap)' },
+  ])('should return $expected for $label', ({ date, expected }, { expect }) => {
+    expect(getDayOfYear(date)).toBe(expected);
+  });
+
+  // Group 3: Time-of-day stability
+  test.for([
+    { date: new Date(2025, 0, 1, 0, 0, 0), expected: 1, label: 'midnight' },
+    { date: new Date(2025, 0, 1, 23, 59, 59), expected: 1, label: 'end of day' },
+    { date: new Date(2025, 5, 15, 12, 0, 0), expected: 166, label: 'noon Jun 15' },
+  ])('should return $expected at $label', ({ date, expected }, { expect }) => {
+    expect(getDayOfYear(date)).toBe(expected);
+  });
+
+  // Group 4: Edge cases
+  it('should handle century non-leap year (1900)', () => {
+    expect(getDayOfYear(new Date(1900, 2, 1))).toBe(60);
+  });
+
+  it('should handle century leap year (2000)', () => {
+    expect(getDayOfYear(new Date(2000, 2, 1))).toBe(61);
+  });
+
+  it('should handle far future dates', () => {
+    expect(getDayOfYear(new Date(2100, 0, 1))).toBe(1);
+  });
+});

package/vitest.config.ts

@@ -4,15 +4,27 @@ import react from '@vitejs/plugin-react';
 export default defineConfig({
   plugins: [react()],
   test: {
+    env: { TZ: 'UTC' }, // Pin to UTC so date-arithmetic tests are timezone-independent
     environment: 'jsdom',
     setupFiles: ['./src/test/setup.ts'],
     globals: true,
+    mockReset: true,
+    unstubGlobals: true,
     coverage: {
       provider: 'v8',
       reporter: ['text', 'json-summary'],
       reportsDirectory: './coverage',
       all: true,
       include: ['src/**/*.{ts,tsx}'],
+      exclude: [
+        'src/useInitData.ts',
+        'src/useChapterNavigation.ts',
+        'src/useVerseSelection.ts',
+        'src/context/ReaderContext.tsx',
+        'src/context/ReaderProvider.tsx',
+        'src/context/VerseSelectionContext.tsx',
+        'src/context/VerseSelectionProvider.tsx',
+      ],
     },
   },
 });

package/src/context/ReaderProvider.test.tsx

@@ -1,264 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { renderHook, act } from '@testing-library/react';
-import React from 'react';
-import { useReaderContext } from './ReaderContext';
-import { ReaderProvider } from './ReaderProvider';
-import {
-  createMockBook,
-  createMockChapter,
-  createMockVerse,
-  createMockVersion,
-} from '../__tests__/mocks/bibles';
-
-// Mock Bible data
-const mockVersion = createMockVersion();
-const mockBook = createMockBook();
-const mockChapter = createMockChapter();
-const mockVerse = createMockVerse();
-
-// Alternative mock data for update tests
-const mockVersion2 = createMockVersion({
-  id: 2,
-  title: 'New International Version',
-  abbreviation: 'NIV',
-  localized_abbreviation: 'NIV',
-  localized_title: 'New International Version',
-  youversion_deep_link: 'https://www.bible.com/versions/2',
-});
-
-const mockBook2 = createMockBook({
-  id: 'JHN',
-  title: 'John',
-  full_title: 'The Gospel According to John',
-  abbreviation: 'Jn',
-  canon: 'new_testament',
-});
-
-const mockChapter2 = createMockChapter({
-  id: '3',
-  passage_id: 'JHN.3',
-  title: '3',
-});
-
-const mockVerse2 = createMockVerse({
-  id: '16',
-  passage_id: 'JHN.3.16',
-  title: '16',
-});
-
-// Test wrappers
-const wrapper = ({ children }: { children: React.ReactNode }) => (
-  <ReaderProvider
-    currentVersion={mockVersion}
-    currentBook={mockBook}
-    currentChapter={mockChapter}
-    currentVerse={mockVerse}
-  >
-    {children}
-  </ReaderProvider>
-);
-
-const wrapperWithNullVerse = ({ children }: { children: React.ReactNode }) => (
-  <ReaderProvider
-    currentVersion={mockVersion}
-    currentBook={mockBook}
-    currentChapter={mockChapter}
-    currentVerse={null}
-  >
-    {children}
-  </ReaderProvider>
-);
-
-describe('ReaderProvider', () => {
-  describe('initialization', () => {
-    it('should initialize with provided version', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      expect(result.current.currentVersion).toEqual(mockVersion);
-    });
-
-    it('should initialize with provided book', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      expect(result.current.currentBook).toEqual(mockBook);
-    });
-
-    it('should initialize with provided chapter', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      expect(result.current.currentChapter).toEqual(mockChapter);
-    });
-
-    it('should initialize with provided verse', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      expect(result.current.currentVerse).toEqual(mockVerse);
-    });
-
-    it('should initialize with null verse when provided', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper: wrapperWithNullVerse });
-
-      expect(result.current.currentVerse).toBeNull();
-    });
-
-    it('should throw error when useReaderContext is used outside provider', () => {
-      const consoleError = vi.spyOn(console, 'error').mockImplementation(() => undefined);
-
-      expect(() => renderHook(() => useReaderContext())).toThrow(
-        'useReaderContext() must be used within a ReaderProvider',
-      );
-
-      consoleError.mockRestore();
-    });
-  });
-
-  describe('setVersion', () => {
-    it('should update version when setVersion is called', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      act(() => {
-        result.current.setVersion(mockVersion2);
-      });
-
-      expect(result.current.currentVersion).toEqual(mockVersion2);
-    });
-
-    it('should preserve other state when version changes', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      act(() => {
-        result.current.setVersion(mockVersion2);
-      });
-
-      expect(result.current.currentVersion).toMatchObject({ abbreviation: 'NIV' });
-      expect(result.current.currentBook).toEqual(mockBook);
-      expect(result.current.currentChapter).toEqual(mockChapter);
-      expect(result.current.currentVerse).toEqual(mockVerse);
-    });
-  });
-
-  describe('setBook', () => {
-    it('should update book when setBook is called', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      act(() => {
-        result.current.setBook(mockBook2);
-      });
-
-      expect(result.current.currentBook).toEqual(mockBook2);
-    });
-
-    it('should preserve other state when book changes', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      act(() => {
-        result.current.setBook(mockBook2);
-      });
-
-      expect(result.current.currentBook).toMatchObject({ id: 'JHN' });
-      expect(result.current.currentVersion).toEqual(mockVersion);
-      expect(result.current.currentChapter).toEqual(mockChapter);
-      expect(result.current.currentVerse).toEqual(mockVerse);
-    });
-  });
-
-  describe('setChapter', () => {
-    it('should update chapter when setChapter is called', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      act(() => {
-        result.current.setChapter(mockChapter2);
-      });
-
-      expect(result.current.currentChapter).toEqual(mockChapter2);
-    });
-
-    it('should preserve other state when chapter changes', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      act(() => {
-        result.current.setChapter(mockChapter2);
-      });
-
-      expect(result.current.currentChapter).toMatchObject({ id: '3' });
-      expect(result.current.currentVersion).toEqual(mockVersion);
-      expect(result.current.currentBook).toEqual(mockBook);
-      expect(result.current.currentVerse).toEqual(mockVerse);
-    });
-  });
-
-  describe('setVerse', () => {
-    it('should update verse when setVerse is called', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      act(() => {
-        result.current.setVerse(mockVerse2);
-      });
-
-      expect(result.current.currentVerse).toEqual(mockVerse2);
-    });
-
-    it('should update verse to null when setVerse is called with null', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      act(() => {
-        result.current.setVerse(null);
-      });
-
-      expect(result.current.currentVerse).toBeNull();
-    });
-
-    it('should preserve other state when verse changes', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      act(() => {
-        result.current.setVerse(mockVerse2);
-      });
-
-      expect(result.current.currentVerse).toMatchObject({ id: '16' });
-      expect(result.current.currentVersion).toEqual(mockVersion);
-      expect(result.current.currentBook).toEqual(mockBook);
-      expect(result.current.currentChapter).toEqual(mockChapter);
-    });
-
-    it('should preserve other state when verse changes to null', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      act(() => {
-        result.current.setVerse(null);
-      });
-
-      expect(result.current.currentVerse).toBeNull();
-      expect(result.current.currentVersion).toEqual(mockVersion);
-      expect(result.current.currentBook).toEqual(mockBook);
-      expect(result.current.currentChapter).toEqual(mockChapter);
-    });
-  });
-
-  describe('state persistence', () => {
-    it('should initialize with all provided props', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      expect(result.current.currentVersion).toEqual(mockVersion);
-      expect(result.current.currentBook).toEqual(mockBook);
-      expect(result.current.currentChapter).toEqual(mockChapter);
-      expect(result.current.currentVerse).toEqual(mockVerse);
-    });
-
-    it('should handle rapid successive state updates without corruption', () => {
-      const { result } = renderHook(() => useReaderContext(), { wrapper });
-
-      act(() => {
-        result.current.setVersion(mockVersion2);
-        result.current.setBook(mockBook2);
-        result.current.setChapter(mockChapter2);
-        result.current.setVerse(mockVerse2);
-      });
-
-      expect(result.current.currentVersion).toEqual(mockVersion2);
-      expect(result.current.currentBook).toEqual(mockBook2);
-      expect(result.current.currentChapter).toEqual(mockChapter2);
-      expect(result.current.currentVerse).toEqual(mockVerse2);
-    });
-  });
-});