@youversion/platform-core 0.6.0 → 0.8.0

package/src/__tests__/YouVersionPlatformConfiguration.test.ts

@@ -6,11 +6,23 @@ import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
 // Mock globals before importing the module
 const mockUUID = '550e8400-e29b-41d4-a716-446655440000';
 const mockRandomUUID = vi.fn(() => mockUUID);
-const mockGetItem = vi.fn();
-const mockSetItem = vi.fn();
+
+// Create a working localStorage mock
+const mockStorage: Record<string, string> = {};
+const mockGetItem = vi.fn((key: string) => mockStorage[key] || null);
+const mockSetItem = vi.fn((key: string, value: string) => {
+  mockStorage[key] = value;
+});
+const mockRemoveItem = vi.fn((key: string) => {
+  delete mockStorage[key];
+});
 
 vi.stubGlobal('crypto', { randomUUID: mockRandomUUID });
-vi.stubGlobal('localStorage', { getItem: mockGetItem, setItem: mockSetItem });
+vi.stubGlobal('localStorage', {
+  getItem: mockGetItem,
+  setItem: mockSetItem,
+  removeItem: mockRemoveItem,
+});
 
 import { YouVersionPlatformConfiguration } from '../YouVersionPlatformConfiguration';
 
@@ -23,21 +35,20 @@ if (!envApiHost) {
 
 describe('YouVersionPlatformConfiguration', () => {
   beforeEach(() => {
-    // Reset all static properties
-    YouVersionPlatformConfiguration.appKey = null;
-    YouVersionPlatformConfiguration.installationId = null;
-    YouVersionPlatformConfiguration.setAccessToken(null);
-    YouVersionPlatformConfiguration.apiHost = envApiHost;
-    YouVersionPlatformConfiguration.isPreviewMode = false;
-    YouVersionPlatformConfiguration.previewUserInfo = null;
-
     // Clear call history but keep implementation
     mockRandomUUID.mockClear();
     mockGetItem.mockClear();
     mockSetItem.mockClear();
+    mockRemoveItem.mockClear();
+
+    // Clear mock storage
+    Object.keys(mockStorage).forEach((key) => delete mockStorage[key]);
 
-    // Setup localStorage to return null by default (empty)
-    mockGetItem.mockReturnValue(null);
+    // Reset all static properties
+    YouVersionPlatformConfiguration.appKey = null;
+    YouVersionPlatformConfiguration.installationId = null;
+    YouVersionPlatformConfiguration.saveAuthData(null, null, null, null);
+    YouVersionPlatformConfiguration.apiHost = envApiHost;
   });
 
   afterEach(() => {
@@ -80,7 +91,10 @@ describe('YouVersionPlatformConfiguration', () => {
 
     it('should use existing UUID from localStorage when installationId is null', () => {
       const existingUUID = 'existing-uuid-from-storage';
-      mockGetItem.mockReturnValue(existingUUID);
+      mockStorage['x-yvp-installation-id'] = existingUUID;
+
+      // Clear the call history after setting up localStorage but before the test
+      mockRandomUUID.mockClear();
 
       YouVersionPlatformConfiguration.installationId = null;
 
@@ -96,16 +110,176 @@ describe('YouVersionPlatformConfiguration', () => {
     });
   });
 
-  describe('accessToken', () => {
-    it('should set and get access token', () => {
+  describe('saveAuthData', () => {
+    it('should save and retrieve access token', () => {
       expect(YouVersionPlatformConfiguration.accessToken).toBeNull();
 
       const token = 'test-access-token';
-      YouVersionPlatformConfiguration.setAccessToken(token);
+      YouVersionPlatformConfiguration.saveAuthData(token, null, null, null);
       expect(YouVersionPlatformConfiguration.accessToken).toBe(token);
 
-      YouVersionPlatformConfiguration.setAccessToken(null);
+      YouVersionPlatformConfiguration.saveAuthData(null, null, null, null);
+      expect(YouVersionPlatformConfiguration.accessToken).toBeNull();
+    });
+
+    it('should save and retrieve refresh token', () => {
+      expect(YouVersionPlatformConfiguration.refreshToken).toBeNull();
+
+      const refreshToken = 'test-refresh-token';
+      YouVersionPlatformConfiguration.saveAuthData(null, refreshToken, null, null);
+      expect(YouVersionPlatformConfiguration.refreshToken).toBe(refreshToken);
+
+      YouVersionPlatformConfiguration.saveAuthData(null, null, null, null);
+      expect(YouVersionPlatformConfiguration.refreshToken).toBeNull();
+    });
+
+    it('should save and retrieve expiry date', () => {
+      expect(YouVersionPlatformConfiguration.tokenExpiryDate).toBeNull();
+
+      const expiryDate = new Date('2024-12-31T23:59:59Z');
+      YouVersionPlatformConfiguration.saveAuthData(null, null, null, expiryDate);
+      expect(YouVersionPlatformConfiguration.tokenExpiryDate).toEqual(expiryDate);
+
+      YouVersionPlatformConfiguration.saveAuthData(null, null, null, null);
+      expect(YouVersionPlatformConfiguration.tokenExpiryDate).toBeNull();
+    });
+
+    it('should save all auth data together', () => {
+      const accessToken = 'test-access-token';
+      const refreshToken = 'test-refresh-token';
+      const idToken = 'test-id-token';
+      const expiryDate = new Date('2024-12-31T23:59:59Z');
+
+      YouVersionPlatformConfiguration.saveAuthData(accessToken, refreshToken, idToken, expiryDate);
+
+      expect(YouVersionPlatformConfiguration.accessToken).toBe(accessToken);
+      expect(YouVersionPlatformConfiguration.refreshToken).toBe(refreshToken);
+      expect(YouVersionPlatformConfiguration.idToken).toBe(idToken);
+      expect(YouVersionPlatformConfiguration.tokenExpiryDate).toEqual(expiryDate);
+    });
+
+    it('should handle partial updates without affecting other tokens', () => {
+      // Set up initial state
+      const initialAccess = 'initial-access';
+      const initialRefresh = 'initial-refresh';
+      const initialIdToken = 'initial-id-token';
+      const initialExpiry = new Date('2024-01-01T00:00:00Z');
+      YouVersionPlatformConfiguration.saveAuthData(
+        initialAccess,
+        initialRefresh,
+        initialIdToken,
+        initialExpiry,
+      );
+
+      // Update only access token
+      const newAccess = 'new-access-token';
+      YouVersionPlatformConfiguration.saveAuthData(newAccess, null, null, null);
+
+      expect(YouVersionPlatformConfiguration.accessToken).toBe(newAccess);
+      expect(YouVersionPlatformConfiguration.refreshToken).toBeNull();
+      expect(YouVersionPlatformConfiguration.idToken).toBeNull();
+      expect(YouVersionPlatformConfiguration.tokenExpiryDate).toBeNull();
+    });
+
+    it('should properly serialize and deserialize dates', () => {
+      const originalDate = new Date('2024-06-15T14:30:45.123Z');
+      YouVersionPlatformConfiguration.saveAuthData(null, null, null, originalDate);
+
+      const retrievedDate = YouVersionPlatformConfiguration.tokenExpiryDate;
+      expect(retrievedDate).toEqual(originalDate);
+      expect(retrievedDate?.getTime()).toBe(originalDate.getTime());
+    });
+
+    it('should call localStorage methods correctly', () => {
+      const accessToken = 'test-access';
+      const refreshToken = 'test-refresh';
+      const idToken = 'test-id';
+      const expiryDate = new Date('2024-12-31T23:59:59Z');
+
+      YouVersionPlatformConfiguration.saveAuthData(accessToken, refreshToken, idToken, expiryDate);
+
+      expect(mockSetItem).toHaveBeenCalledWith('accessToken', accessToken);
+      expect(mockSetItem).toHaveBeenCalledWith('refreshToken', refreshToken);
+      expect(mockSetItem).toHaveBeenCalledWith('idToken', idToken);
+      expect(mockSetItem).toHaveBeenCalledWith('expiryDate', expiryDate.toISOString());
+    });
+
+    it('should call removeItem when tokens are null', () => {
+      // First set some values
+      YouVersionPlatformConfiguration.saveAuthData('access', 'refresh', 'id-token', new Date());
+
+      // Clear the mock calls
+      mockRemoveItem.mockClear();
+
+      // Now set to null
+      YouVersionPlatformConfiguration.saveAuthData(null, null, null, null);
+
+      expect(mockRemoveItem).toHaveBeenCalledWith('accessToken');
+      expect(mockRemoveItem).toHaveBeenCalledWith('refreshToken');
+      expect(mockRemoveItem).toHaveBeenCalledWith('idToken');
+      expect(mockRemoveItem).toHaveBeenCalledWith('expiryDate');
+    });
+  });
+
+  describe('clearAuthTokens', () => {
+    it('should clear all auth tokens', () => {
+      // Set up initial auth data
+      const accessToken = 'test-access-token';
+      const refreshToken = 'test-refresh-token';
+      const idToken = 'test-id-token';
+      const expiryDate = new Date('2024-12-31T23:59:59Z');
+      YouVersionPlatformConfiguration.saveAuthData(accessToken, refreshToken, idToken, expiryDate);
+
+      // Verify data is set
+      expect(YouVersionPlatformConfiguration.accessToken).toBe(accessToken);
+      expect(YouVersionPlatformConfiguration.refreshToken).toBe(refreshToken);
+      expect(YouVersionPlatformConfiguration.idToken).toBe(idToken);
+      expect(YouVersionPlatformConfiguration.tokenExpiryDate).toEqual(expiryDate);
+
+      // Clear all tokens
+      YouVersionPlatformConfiguration.clearAuthTokens();
+
+      // Verify all tokens are null
       expect(YouVersionPlatformConfiguration.accessToken).toBeNull();
+      expect(YouVersionPlatformConfiguration.refreshToken).toBeNull();
+      expect(YouVersionPlatformConfiguration.idToken).toBeNull();
+      expect(YouVersionPlatformConfiguration.tokenExpiryDate).toBeNull();
+    });
+
+    it('should call removeItem for all token types', () => {
+      // Set up some auth data first
+      YouVersionPlatformConfiguration.saveAuthData('access', 'refresh', 'id-token', new Date());
+
+      // Clear mock calls
+      mockRemoveItem.mockClear();
+
+      // Clear auth tokens
+      YouVersionPlatformConfiguration.clearAuthTokens();
+
+      // Verify removeItem was called for each token type
+      expect(mockRemoveItem).toHaveBeenCalledWith('accessToken');
+      expect(mockRemoveItem).toHaveBeenCalledWith('refreshToken');
+      expect(mockRemoveItem).toHaveBeenCalledWith('idToken');
+      expect(mockRemoveItem).toHaveBeenCalledWith('expiryDate');
+    });
+
+    it('should work when no tokens are previously set', () => {
+      // Ensure clean state
+      expect(YouVersionPlatformConfiguration.accessToken).toBeNull();
+      expect(YouVersionPlatformConfiguration.refreshToken).toBeNull();
+      expect(YouVersionPlatformConfiguration.idToken).toBeNull();
+      expect(YouVersionPlatformConfiguration.tokenExpiryDate).toBeNull();
+
+      // Should not throw when clearing empty state
+      expect(() => {
+        YouVersionPlatformConfiguration.clearAuthTokens();
+      }).not.toThrow();
+
+      // State should remain null
+      expect(YouVersionPlatformConfiguration.accessToken).toBeNull();
+      expect(YouVersionPlatformConfiguration.refreshToken).toBeNull();
+      expect(YouVersionPlatformConfiguration.idToken).toBeNull();
+      expect(YouVersionPlatformConfiguration.tokenExpiryDate).toBeNull();
     });
   });
 
@@ -120,18 +294,6 @@ describe('YouVersionPlatformConfiguration', () => {
     });
   });
 
-  describe('isPreviewMode', () => {
-    it('should get and set preview mode', () => {
-      expect(YouVersionPlatformConfiguration.isPreviewMode).toBe(false);
-
-      YouVersionPlatformConfiguration.isPreviewMode = true;
-      expect(YouVersionPlatformConfiguration.isPreviewMode).toBe(true);
-
-      YouVersionPlatformConfiguration.isPreviewMode = false;
-      expect(YouVersionPlatformConfiguration.isPreviewMode).toBe(false);
-    });
-  });
-
   describe('UUID generation edge cases', () => {
     it('should generate valid UUID format', () => {
       YouVersionPlatformConfiguration.installationId = null;

package/src/__tests__/YouVersionUserInfo.test.ts

@@ -0,0 +1,347 @@
+import { describe, it, expect } from 'vitest';
+import type { YouVersionUserInfoJSON } from '../YouVersionUserInfo';
+import { YouVersionUserInfo } from '../YouVersionUserInfo';
+
+describe('YouVersionUserInfo', () => {
+  describe('constructor', () => {
+    it('should create instance with valid data', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John Doe',
+        id: 'user123',
+        avatar_url: 'https://example.com/avatar/{width}x{height}.jpg',
+        email: 'john.doe@example.com',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+
+      expect(userInfo.name).toBe('John Doe');
+      expect(userInfo.userId).toBe('user123');
+      expect(userInfo.email).toBe('john.doe@example.com');
+      expect(userInfo.avatarUrlFormat).toBe('https://example.com/avatar/{width}x{height}.jpg');
+    });
+
+    it('should create instance with partial data', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'Jane',
+        id: 'user456',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+
+      expect(userInfo.name).toBe('Jane');
+      expect(userInfo.email).toBeUndefined();
+      expect(userInfo.userId).toBe('user456');
+      expect(userInfo.avatarUrlFormat).toBeUndefined();
+    });
+
+    it('should create instance with empty object', () => {
+      const userData: YouVersionUserInfoJSON = {};
+
+      const userInfo = new YouVersionUserInfo(userData);
+
+      expect(userInfo.name).toBeUndefined();
+      expect(userInfo.email).toBeUndefined();
+      expect(userInfo.userId).toBeUndefined();
+      expect(userInfo.avatarUrlFormat).toBeUndefined();
+    });
+
+    it('should throw error for null data', () => {
+      expect(() => {
+        // @ts-expect-error - Testing invalid input type
+        new YouVersionUserInfo(null);
+      }).toThrow('Invalid user data provided');
+    });
+
+    it('should throw error for undefined data', () => {
+      expect(() => {
+        // @ts-expect-error - Testing invalid input type
+        new YouVersionUserInfo(undefined);
+      }).toThrow('Invalid user data provided');
+    });
+
+    it('should throw error for non-object data', () => {
+      expect(() => {
+        // @ts-expect-error - Testing invalid input type
+        new YouVersionUserInfo('invalid data');
+      }).toThrow('Invalid user data provided');
+
+      expect(() => {
+        // @ts-expect-error - Testing invalid input type
+        new YouVersionUserInfo(123);
+      }).toThrow('Invalid user data provided');
+
+      expect(() => {
+        // @ts-expect-error - Testing invalid input type
+        new YouVersionUserInfo(true);
+      }).toThrow('Invalid user data provided');
+    });
+  });
+
+  describe('getAvatarUrl', () => {
+    it('should return null when avatarUrlFormat is undefined', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        id: 'user123',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl();
+
+      expect(avatarUrl).toBeNull();
+    });
+
+    it('should return null when avatarUrlFormat is empty string', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        id: 'user123',
+        avatar_url: '',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl();
+
+      expect(avatarUrl).toBeNull();
+    });
+
+    it('should replace width and height placeholders with default values', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        avatar_url: 'https://example.com/avatar/{width}x{height}.jpg',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl();
+
+      expect(avatarUrl).toBeInstanceOf(URL);
+      expect(avatarUrl?.toString()).toBe('https://example.com/avatar/200x200.jpg');
+    });
+
+    it('should replace width and height placeholders with custom values', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        avatar_url: 'https://example.com/avatar/{width}x{height}.jpg',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl(100, 150);
+
+      expect(avatarUrl).toBeInstanceOf(URL);
+      expect(avatarUrl?.toString()).toBe('https://example.com/avatar/100x150.jpg');
+    });
+
+    it('should handle URL starting with // by adding https:', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        avatar_url: '//example.com/avatar/{width}x{height}.jpg',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl(50, 75);
+
+      expect(avatarUrl).toBeInstanceOf(URL);
+      expect(avatarUrl?.toString()).toBe('https://example.com/avatar/50x75.jpg');
+    });
+
+    it('should handle URL without placeholders', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        avatar_url: 'https://example.com/static-avatar.jpg',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl(100, 100);
+
+      expect(avatarUrl).toBeInstanceOf(URL);
+      expect(avatarUrl?.toString()).toBe('https://example.com/static-avatar.jpg');
+    });
+
+    it('should handle URL with only width placeholder', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        avatar_url: 'https://example.com/avatar/w{width}.jpg',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl(300, 400);
+
+      expect(avatarUrl).toBeInstanceOf(URL);
+      expect(avatarUrl?.toString()).toBe('https://example.com/avatar/w300.jpg');
+    });
+
+    it('should handle URL with only height placeholder', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        avatar_url: 'https://example.com/avatar/h{height}.jpg',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl(300, 400);
+
+      expect(avatarUrl).toBeInstanceOf(URL);
+      expect(avatarUrl?.toString()).toBe('https://example.com/avatar/h400.jpg');
+    });
+
+    it('should not handle multiple occurrences of placeholders', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        avatar_url: 'https://example.com/avatar/{width}/thumb_{height}_{width}.jpg',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl(120, 80);
+
+      expect(avatarUrl).toBeInstanceOf(URL);
+      // URL constructor encodes curly braces, so {width} becomes %7Bwidth%7D
+      expect(avatarUrl?.toString()).toBe('https://example.com/avatar/120/thumb_80_%7Bwidth%7D.jpg');
+    });
+
+    it('should return null for malformed URLs', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        avatar_url: 'not-a-valid-url-{width}x{height}',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl();
+
+      expect(avatarUrl).toBeNull();
+    });
+
+    it('should handle zero width and height', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        avatar_url: 'https://example.com/avatar/{width}x{height}.jpg',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl(0, 0);
+
+      expect(avatarUrl).toBeInstanceOf(URL);
+      expect(avatarUrl?.toString()).toBe('https://example.com/avatar/0x0.jpg');
+    });
+
+    it('should handle negative width and height', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        avatar_url: 'https://example.com/avatar/{width}x{height}.jpg',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl(-100, -50);
+
+      expect(avatarUrl).toBeInstanceOf(URL);
+      expect(avatarUrl?.toString()).toBe('https://example.com/avatar/-100x-50.jpg');
+    });
+
+    it('should handle large width and height values', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        avatar_url: 'https://example.com/avatar/{width}x{height}.jpg',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl(9999, 8888);
+
+      expect(avatarUrl).toBeInstanceOf(URL);
+      expect(avatarUrl?.toString()).toBe('https://example.com/avatar/9999x8888.jpg');
+    });
+  });
+
+  describe('avatarUrl getter', () => {
+    it('should return same result as getAvatarUrl() with default parameters', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        avatar_url: 'https://example.com/avatar/{width}x{height}.jpg',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const getterResult = userInfo.avatarUrl;
+      const methodResult = userInfo.getAvatarUrl();
+
+      expect(getterResult).toEqual(methodResult);
+      expect(getterResult?.toString()).toBe('https://example.com/avatar/200x200.jpg');
+    });
+
+    it('should return null when avatarUrlFormat is undefined', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        id: 'user123',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+
+      expect(userInfo.avatarUrl).toBeNull();
+    });
+
+    it('should return null for malformed URLs', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'John',
+        avatar_url: 'invalid-url-format',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+
+      expect(userInfo.avatarUrl).toBeNull();
+    });
+  });
+
+  describe('edge cases and real-world scenarios', () => {
+    it('should handle typical YouVersion API response format', () => {
+      const userData: YouVersionUserInfoJSON = {
+        id: '12345',
+        name: 'Sarah Johnson',
+        avatar_url: '//images.youversion.com/users/12345/{width}x{height}/avatar.jpg',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+
+      expect(userInfo.userId).toBe('12345');
+      expect(userInfo.name).toBe('Sarah Johnson');
+
+      const avatarUrl = userInfo.getAvatarUrl(150, 150);
+      expect(avatarUrl?.toString()).toBe(
+        'https://images.youversion.com/users/12345/150x150/avatar.jpg',
+      );
+    });
+
+    it('should handle user with single name', () => {
+      const userData: YouVersionUserInfoJSON = {
+        id: 'user789',
+        name: 'Madonna',
+        avatar_url: 'https://cdn.example.com/{width}/{height}/user.png',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+
+      expect(userInfo.name).toBe('Madonna');
+      expect(userInfo.userId).toBe('user789');
+      expect(userInfo.avatarUrl?.toString()).toBe('https://cdn.example.com/200/200/user.png');
+    });
+
+    it('should handle complex URL with query parameters', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'Alex',
+        avatar_url: 'https://api.service.com/v1/avatar?user=123&w={width}&h={height}&format=jpg',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl(64, 64);
+
+      expect(avatarUrl?.toString()).toBe(
+        'https://api.service.com/v1/avatar?user=123&w=64&h=64&format=jpg',
+      );
+    });
+
+    it('should handle URL with fragment identifier', () => {
+      const userData: YouVersionUserInfoJSON = {
+        name: 'Taylor',
+        avatar_url: 'https://example.com/avatar/{width}x{height}.jpg#section1',
+      };
+
+      const userInfo = new YouVersionUserInfo(userData);
+      const avatarUrl = userInfo.getAvatarUrl(128, 128);
+
+      expect(avatarUrl?.toString()).toBe('https://example.com/avatar/128x128.jpg#section1');
+    });
+  });
+});