ci: Bump version to 0.9.21 [skip ci]

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "flyer-crawler",
-  "version": "0.9.20",
+  "version": "0.9.21",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "flyer-crawler",
-      "version": "0.9.20",
+      "version": "0.9.21",
       "dependencies": {
         "@bull-board/api": "^6.14.2",
         "@bull-board/express": "^6.14.2",

package.json

@@ -1,7 +1,7 @@
 {
   "name": "flyer-crawler",
   "private": true,
-  "version": "0.9.20",
+  "version": "0.9.21",
   "type": "module",
   "scripts": {
     "dev": "concurrently \"npm:start:dev\" \"vite\"",

src/App.test.tsx

@@ -20,6 +20,7 @@ import {
   mockUseUserData,
   mockUseFlyerItems,
 } from './tests/setup/mockHooks';
+import './tests/setup/mockUI';
 import { useAppInitialization } from './hooks/useAppInitialization';
 
 // Mock top-level components rendered by App's routes
@@ -61,74 +62,6 @@ vi.mock('./hooks/useAuth', async () => {
   return { useAuth: hooks.mockUseAuth };
 });
 
-vi.mock('./components/Footer', async () => {
-  const { MockFooter } = await import('./tests/utils/componentMocks');
-  return { Footer: MockFooter };
-});
-
-vi.mock('./components/Header', async () => {
-  const { MockHeader } = await import('./tests/utils/componentMocks');
-  return { Header: MockHeader };
-});
-
-vi.mock('./pages/HomePage', () => ({
-  HomePage: (props: any) => (
-    <div data-testid="home-page-mock" data-selected-flyer-id={props.selectedFlyer?.flyer_id}>
-      Mock Home Page
-    </div>
-  ),
-}));
-
-vi.mock('./pages/admin/AdminPage', async () => {
-  const { MockAdminPage } = await import('./tests/utils/componentMocks');
-  return { AdminPage: MockAdminPage };
-});
-
-vi.mock('./pages/admin/CorrectionsPage', async () => {
-  const { MockCorrectionsPage } = await import('./tests/utils/componentMocks');
-  return { CorrectionsPage: MockCorrectionsPage };
-});
-
-vi.mock('./pages/admin/AdminStatsPage', async () => {
-  const { MockAdminStatsPage } = await import('./tests/utils/componentMocks');
-  return { AdminStatsPage: MockAdminStatsPage };
-});
-
-vi.mock('./pages/VoiceLabPage', async () => {
-  const { MockVoiceLabPage } = await import('./tests/utils/componentMocks');
-  return { VoiceLabPage: MockVoiceLabPage };
-});
-
-vi.mock('./pages/ResetPasswordPage', async () => {
-  const { MockResetPasswordPage } = await import('./tests/utils/componentMocks');
-  return { ResetPasswordPage: MockResetPasswordPage };
-});
-
-vi.mock('./pages/admin/components/ProfileManager', async () => {
-  const { MockProfileManager } = await import('./tests/utils/componentMocks');
-  return { ProfileManager: MockProfileManager };
-});
-
-vi.mock('./features/voice-assistant/VoiceAssistant', async () => {
-  const { MockVoiceAssistant } = await import('./tests/utils/componentMocks');
-  return { VoiceAssistant: MockVoiceAssistant };
-});
-
-vi.mock('./components/FlyerCorrectionTool', async () => {
-  const { MockFlyerCorrectionTool } = await import('./tests/utils/componentMocks');
-  return { FlyerCorrectionTool: MockFlyerCorrectionTool };
-});
-
-vi.mock('./components/WhatsNewModal', async () => {
-  const { MockWhatsNewModal } = await import('./tests/utils/componentMocks');
-  return { WhatsNewModal: MockWhatsNewModal };
-});
-
-vi.mock('./layouts/MainLayout', async () => {
-  const { MockMainLayout } = await import('./tests/utils/componentMocks');
-  return { MainLayout: MockMainLayout };
-});
-
 vi.mock('./components/AppGuard', async () => {
   // We need to use the real useModal hook inside our mock AppGuard
   const { useModal } = await vi.importActual<typeof import('./hooks/useModal')>('./hooks/useModal');

src/services/aiService.server.test.ts

@@ -84,9 +84,9 @@ vi.mock('../utils/imageProcessor', () => ({
 }));
 
 vi.mock('./db/admin.db', () => ({
-  AdminRepository: vi.fn().mockImplementation(() => ({
-    logActivity: mockAdminLogActivity,
-  })),
+  AdminRepository: vi.fn().mockImplementation(function () {
+    return { logActivity: mockAdminLogActivity };
+  }),
 }));
 
 // Import mocked modules to assert on them

src/services/authService.test.ts

@@ -19,10 +19,10 @@ const { transactionalUserRepoMocks, transactionalAdminRepoMocks } = vi.hoisted((
 });
 
 vi.mock('./db/user.db', () => ({
-  UserRepository: vi.fn().mockImplementation(() => transactionalUserRepoMocks),
+  UserRepository: vi.fn().mockImplementation(function () { return transactionalUserRepoMocks }),
 }));
 vi.mock('./db/admin.db', () => ({
-  AdminRepository: vi.fn().mockImplementation(() => transactionalAdminRepoMocks),
+  AdminRepository: vi.fn().mockImplementation(function () { return transactionalAdminRepoMocks }),
 }));
 
 describe('AuthService', () => {
@@ -154,7 +154,7 @@ describe('AuthService', () => {
         authService.registerUser('test@example.com', 'password123', undefined, undefined, reqLog),
       ).rejects.toThrow(UniqueConstraintError);
 
-      expect(logger.error).toHaveBeenCalled();
+    expect(logger.error).not.toHaveBeenCalled();
     });
 
     it('should log and re-throw generic errors on registration failure', async () => {
@@ -164,9 +164,9 @@ describe('AuthService', () => {
 
       await expect(
         authService.registerUser('test@example.com', 'password123', undefined, undefined, reqLog),
-      ).rejects.toThrow(error);
+      ).rejects.toThrow(DatabaseError);
 
-      expect(logger.error).toHaveBeenCalledWith({ error, email: 'test@example.com' }, `User registration failed.`);
+      expect(logger.error).toHaveBeenCalledWith({ error, email: 'test@example.com' }, `User registration failed with an unexpected error.`);
     });
   });
 
@@ -321,9 +321,9 @@ describe('AuthService', () => {
       const dbError = new Error('Transaction failed');
       vi.mocked(withTransaction).mockRejectedValue(dbError);
 
-      await expect(authService.updatePassword('valid-token', 'newPassword', reqLog)).rejects.toThrow(dbError);
+      await expect(authService.updatePassword('valid-token', 'newPassword', reqLog)).rejects.toThrow(DatabaseError);
 
-      expect(logger.error).toHaveBeenCalledWith({ error: dbError }, `An error occurred during password update.`);
+      expect(logger.error).toHaveBeenCalledWith({ error: dbError }, `An unexpected error occurred during password update.`);
     });
 
     it('should return null if token is invalid or not found', async () => {

src/services/db/admin.db.test.ts

@@ -715,7 +715,14 @@ describe('Admin DB Service', () => {
       adminRepo.updateUserRole('non-existent-user', 'admin', mockLogger),
     ).rejects.toThrow('The specified user does not exist.');
     expect(mockLogger.error).toHaveBeenCalledWith(
-      { err: dbError, userId: 'non-existent-user', role: 'admin' },
+      {
+        err: dbError,
+        userId: 'non-existent-user',
+        role: 'admin',
+        code: '23503',
+        constraint: undefined,
+        detail: undefined,
+      },
       'Database error in updateUserRole',
     );
   });

src/services/db/flyer.db.test.ts

@@ -184,7 +184,13 @@ describe('Flyer DB Service', () => {
         'A flyer with this checksum already exists.',
       );
       expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError, flyerData },
+        {
+          err: dbError,
+          flyerData,
+          code: '23505',
+          constraint: undefined,
+          detail: undefined,
+        },
         'Database error in insertFlyer',
       );
     });
@@ -331,7 +337,13 @@ describe('Flyer DB Service', () => {
         'The specified flyer, category, master item, or product does not exist.',
       );
       expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError, flyerId: 999 },
+        {
+          err: dbError,
+          flyerId: 999,
+          code: '23503',
+          constraint: undefined,
+          detail: undefined,
+        },
         'Database error in insertFlyerItems',
       );
     });

src/services/db/gamification.db.test.ts

@@ -130,7 +130,14 @@ describe('Gamification DB Service', () => {
         ),
       ).rejects.toThrow('The specified user or achievement does not exist.');
       expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError, userId: 'non-existent-user', achievementName: 'Non-existent Achievement' },
+        {
+          err: dbError,
+          userId: 'non-existent-user',
+          achievementName: 'Non-existent Achievement',
+          code: '23503',
+          constraint: undefined,
+          detail: undefined,
+        },
         'Database error in awardAchievement',
       );
     });

src/services/db/index.db.test.ts

@@ -0,0 +1,64 @@
+// src/services/db/index.db.test.ts
+import { describe, it, expect, vi } from 'vitest';
+
+// Mock all the repository classes to be simple classes/functions
+// This prevents their constructors from running real database connection logic.
+vi.mock('./user.db', () => ({ UserRepository: class UserRepository {} }));
+vi.mock('./flyer.db', () => ({ FlyerRepository: class FlyerRepository {} }));
+vi.mock('./address.db', () => ({ AddressRepository: class AddressRepository {} }));
+vi.mock('./shopping.db', () => ({ ShoppingRepository: class ShoppingRepository {} }));
+vi.mock('./personalization.db', () => ({
+  PersonalizationRepository: class PersonalizationRepository {},
+}));
+vi.mock('./recipe.db', () => ({ RecipeRepository: class RecipeRepository {} }));
+vi.mock('./notification.db', () => ({
+  NotificationRepository: class NotificationRepository {},
+}));
+vi.mock('./budget.db', () => ({ BudgetRepository: class BudgetRepository {} }));
+vi.mock('./gamification.db', () => ({
+  GamificationRepository: class GamificationRepository {},
+}));
+vi.mock('./admin.db', () => ({ AdminRepository: class AdminRepository {} }));
+
+// These modules export an already-instantiated object, so we mock the object.
+vi.mock('./reaction.db', () => ({ reactionRepo: {} }));
+vi.mock('./conversion.db', () => ({ conversionRepo: {} }));
+
+// Mock the re-exported function.
+vi.mock('./connection.db', () => ({ withTransaction: vi.fn() }));
+
+// We must un-mock the file we are testing so we get the actual implementation.
+vi.unmock('./index.db');
+
+// Import the module to be tested AFTER setting up the mocks.
+import * as db from './index.db';
+
+// Import the mocked classes to check `instanceof`.
+import { UserRepository } from './user.db';
+import { FlyerRepository } from './flyer.db';
+import { AddressRepository } from './address.db';
+import { ShoppingRepository } from './shopping.db';
+import { PersonalizationRepository } from './personalization.db';
+import { RecipeRepository } from './recipe.db';
+import { NotificationRepository } from './notification.db';
+import { BudgetRepository } from './budget.db';
+import { GamificationRepository } from './gamification.db';
+import { AdminRepository } from './admin.db';
+
+describe('DB Index', () => {
+  it('should instantiate and export all repositories and functions', () => {
+    expect(db.userRepo).toBeInstanceOf(UserRepository);
+    expect(db.flyerRepo).toBeInstanceOf(FlyerRepository);
+    expect(db.addressRepo).toBeInstanceOf(AddressRepository);
+    expect(db.shoppingRepo).toBeInstanceOf(ShoppingRepository);
+    expect(db.personalizationRepo).toBeInstanceOf(PersonalizationRepository);
+    expect(db.recipeRepo).toBeInstanceOf(RecipeRepository);
+    expect(db.notificationRepo).toBeInstanceOf(NotificationRepository);
+    expect(db.budgetRepo).toBeInstanceOf(BudgetRepository);
+    expect(db.gamificationRepo).toBeInstanceOf(GamificationRepository);
+    expect(db.adminRepo).toBeInstanceOf(AdminRepository);
+    expect(db.reactionRepo).toBeDefined();
+    expect(db.conversionRepo).toBeDefined();
+    expect(db.withTransaction).toBeDefined();
+  });
+});

src/services/db/notification.db.test.ts

@@ -150,7 +150,15 @@ describe('Notification DB Service', () => {
         notificationRepo.createNotification('non-existent-user', 'Test', mockLogger),
       ).rejects.toThrow('The specified user does not exist.');
       expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError, userId: 'non-existent-user', content: 'Test', linkUrl: undefined },
+        {
+          err: dbError,
+          userId: 'non-existent-user',
+          content: 'Test',
+          linkUrl: undefined,
+          code: '23503',
+          constraint: undefined,
+          detail: undefined,
+        },
         'Database error in createNotification',
       );
     });
@@ -195,7 +203,13 @@ describe('Notification DB Service', () => {
         notificationRepo.createBulkNotifications(notificationsToCreate, mockLogger),
       ).rejects.toThrow(ForeignKeyConstraintError);
       expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError, notifications: notificationsToCreate },
+        {
+          err: dbError,
+          notifications: notificationsToCreate,
+          code: '23503',
+          constraint: undefined,
+          detail: undefined,
+        },
         'Database error in createBulkNotifications',
       );
     });

src/services/db/recipe.db.test.ts

@@ -173,7 +173,14 @@ describe('Recipe DB Service', () => {
         'The specified user or recipe does not exist.',
       );
       expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError, userId: 'user-123', recipeId: 999 },
+        {
+          err: dbError,
+          userId: 'user-123',
+          recipeId: 999,
+          code: '23503',
+          constraint: undefined,
+          detail: undefined,
+        },
         'Database error in addFavoriteRecipe',
       );
     });
@@ -414,7 +421,15 @@ describe('Recipe DB Service', () => {
         recipeRepo.addRecipeComment(999, 'user-123', 'Fail', mockLogger),
       ).rejects.toThrow('The specified recipe, user, or parent comment does not exist.');
       expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError, recipeId: 999, userId: 'user-123', parentCommentId: undefined },
+        {
+          err: dbError,
+          recipeId: 999,
+          userId: 'user-123',
+          parentCommentId: undefined,
+          code: '23503',
+          constraint: undefined,
+          detail: undefined,
+        },
         'Database error in addRecipeComment',
       );
     });

src/services/db/user.db.test.ts

@@ -173,6 +173,41 @@ describe('User DB Service', () => {
       expect(result).toEqual(expect.objectContaining(expectedProfile));
     });
 
+    it('should create a user with a null password hash (e.g. OAuth)', async () => {
+      const mockUser = {
+        user_id: 'oauth-user-id',
+        email: 'oauth@example.com',
+      };
+      const mockDbProfile = {
+        user_id: 'oauth-user-id',
+        email: 'oauth@example.com',
+        role: 'user',
+        full_name: 'OAuth User',
+        user_created_at: new Date().toISOString(),
+        user_updated_at: new Date().toISOString(),
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+      };
+
+      (mockPoolInstance.query as Mock)
+        .mockResolvedValueOnce({ rows: [] }) // set_config
+        .mockResolvedValueOnce({ rows: [mockUser] }) // INSERT user
+        .mockResolvedValueOnce({ rows: [mockDbProfile] }); // SELECT profile
+
+      const result = await userRepo.createUser(
+        'oauth@example.com',
+        null, // Pass null for passwordHash
+        { full_name: 'OAuth User' },
+        mockLogger,
+      );
+
+      expect(result.user.email).toBe('oauth@example.com');
+      expect(mockPoolInstance.query).toHaveBeenCalledWith(
+        'INSERT INTO public.users (email, password_hash) VALUES ($1, $2) RETURNING user_id, email',
+        ['oauth@example.com', null],
+      );
+    });
+
     it('should throw an error if creating the user fails', async () => {
       const dbError = new Error('User insert failed');
       mockPoolInstance.query.mockRejectedValue(dbError);
@@ -207,20 +242,26 @@ describe('User DB Service', () => {
       const dbError = new Error('duplicate key value violates unique constraint');
       (dbError as Error & { code: string }).code = '23505';
 
-      mockPoolInstance.query.mockRejectedValue(dbError);
+      (mockPoolInstance.query as Mock).mockRejectedValue(dbError);
 
-      try {
-        await userRepo.createUser('exists@example.com', 'pass', {}, mockLogger);
-        expect.fail('Expected createUser to throw UniqueConstraintError');
-      } catch (error: unknown) {
-        expect(error).toBeInstanceOf(UniqueConstraintError);
-        // After confirming the error type, we can safely access its properties.
-        // This satisfies TypeScript's type checker for the 'unknown' type.
-        if (error instanceof Error) {
-          expect(error.message).toBe('A user with this email address already exists.'); // This message comes from the options in handleDbError
-        }
-      }
-      expect(mockLogger.warn).toHaveBeenCalledWith(`Attempted to create a user with an existing email: exists@example.com`);
+      await expect(
+        userRepo.createUser('exists@example.com', 'pass', {}, mockLogger),
+      ).rejects.toThrow(UniqueConstraintError);
+
+      await expect(
+        userRepo.createUser('exists@example.com', 'pass', {}, mockLogger),
+      ).rejects.toThrow('A user with this email address already exists.');
+
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        {
+          err: dbError,
+          email: 'exists@example.com',
+          code: '23505',
+          constraint: undefined,
+          detail: undefined,
+        },
+        'Error during createUser',
+      );
     });
 
     it('should throw an error if profile is not found after user creation', async () => {
@@ -963,6 +1004,32 @@ describe('User DB Service', () => {
       ]);
     });
 
+    it('should throw ForeignKeyConstraintError if the user_id does not exist', async () => {
+      const dbError = new Error('violates foreign key constraint');
+      (dbError as Error & { code: string }).code = '23503';
+      mockPoolInstance.query.mockRejectedValue(dbError);
+
+      const queryData = {
+        user_id: 'non-existent-user',
+        query_text: 'search text',
+        result_count: 0,
+        was_successful: false,
+      };
+
+      await expect(userRepo.logSearchQuery(queryData, mockLogger)).rejects.toThrow(
+        ForeignKeyConstraintError,
+      );
+
+      await expect(userRepo.logSearchQuery(queryData, mockLogger)).rejects.toThrow(
+        'The specified user does not exist.',
+      );
+
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        expect.objectContaining({ err: dbError, queryData }),
+        'Database error in logSearchQuery',
+      );
+    });
+
     it('should throw a generic error if the database query fails', async () => {
       const dbError = new Error('DB Error');
       mockPoolInstance.query.mockRejectedValue(dbError);

src/services/flyerProcessingService.server.test.ts

@@ -10,6 +10,7 @@ const mocks = vi.hoisted(() => ({
   unlink: vi.fn(),
   readdir: vi.fn(),
   execAsync: vi.fn(),
+  mockAdminLogActivity: vi.fn(),
 }));
 
 // 2. Mock modules using the hoisted variables
@@ -57,6 +58,11 @@ vi.mock('./db/index.db', () => ({
   flyerRepo: { getFlyerById: vi.fn() },
   withTransaction: vi.fn(),
 }));
+vi.mock('./db/admin.db', () => ({
+  AdminRepository: vi.fn().mockImplementation(function () {
+    return { logActivity: mocks.mockAdminLogActivity };
+  }),
+}));
 vi.mock('./logger.server', () => ({
   logger: {
     info: vi.fn(),
@@ -205,7 +211,7 @@ describe('FlyerProcessingService', () => {
       expect(mockedDb.withTransaction).toHaveBeenCalledTimes(1);
       // Verify that the functions inside the transaction were called.
       expect(createFlyerAndItems).toHaveBeenCalledTimes(1);
-      expect(mockedDb.adminRepo.logActivity).toHaveBeenCalledTimes(1);
+      expect(mocks.mockAdminLogActivity).toHaveBeenCalledTimes(1);
       expect(mockCleanupQueue.add).toHaveBeenCalledWith(
         'cleanup-flyer-files',
         { flyerId: 1, paths: ['/tmp/flyer.jpg'] },

src/services/flyerProcessingService.server.ts

@@ -197,9 +197,10 @@ export class FlyerProcessingService {
       } catch (error) {
         if (error instanceof NotFoundError) {
           logger.error({ flyerId }, 'Cannot derive cleanup paths because flyer was not found in DB.');
-          throw new UnrecoverableError(`Cleanup failed: Flyer with ID ${flyerId} not found.`);
+          // Do not throw. Allow the job to be marked as skipped if no paths are found.
+        } else {
+          throw error; // Re-throw other DB errors to allow for retries.
         }
-        throw error; // Re-throw other DB errors to allow for retries.
       }
     }
 

src/services/userService.test.ts

@@ -232,7 +232,7 @@ describe('UserService', () => {
       await expect(userService.processTokenCleanupJob(job)).rejects.toThrow('DB Error');
       expect(logger.error).toHaveBeenCalledWith(
         expect.objectContaining({ err: error }),
-        'Expired token cleanup job failed.',
+        `Expired token cleanup job failed: ${error.message}`,
       );
     });
   });

src/tests/setup/mockUI.ts

@@ -0,0 +1,75 @@
+// src/tests/setup/mockUI.ts
+import { vi } from 'vitest';
+
+/**
+ * This setup file centralizes the mocking of common UI components for high-level tests like App.test.tsx.
+ * By importing this single file into a test, all standard UI components are replaced with their mock implementations
+ * from `src/tests/utils/componentMocks.tsx`, reducing boilerplate in the test files.
+ *
+ * Note: Mocks that require special logic (e.g., using `vi.importActual`) should remain in the test file itself.
+ */
+
+vi.mock('../../components/Footer', async () => {
+  const { MockFooter } = await import('../utils/componentMocks');
+  return { Footer: MockFooter };
+});
+
+vi.mock('../../components/Header', async () => {
+  const { MockHeader } = await import('../utils/componentMocks');
+  return { Header: MockHeader };
+});
+
+vi.mock('../../pages/HomePage', async () => {
+  const { MockHomePage } = await import('../utils/componentMocks');
+  return { HomePage: MockHomePage };
+});
+
+vi.mock('../../pages/admin/AdminPage', async () => {
+  const { MockAdminPage } = await import('../utils/componentMocks');
+  return { AdminPage: MockAdminPage };
+});
+
+vi.mock('../../pages/admin/CorrectionsPage', async () => {
+  const { MockCorrectionsPage } = await import('../utils/componentMocks');
+  return { CorrectionsPage: MockCorrectionsPage };
+});
+
+vi.mock('../../pages/admin/AdminStatsPage', async () => {
+  const { MockAdminStatsPage } = await import('../utils/componentMocks');
+  return { AdminStatsPage: MockAdminStatsPage };
+});
+
+vi.mock('../../pages/VoiceLabPage', async () => {
+  const { MockVoiceLabPage } = await import('../utils/componentMocks');
+  return { VoiceLabPage: MockVoiceLabPage };
+});
+
+vi.mock('../../pages/ResetPasswordPage', async () => {
+  const { MockResetPasswordPage } = await import('../utils/componentMocks');
+  return { ResetPasswordPage: MockResetPasswordPage };
+});
+
+vi.mock('../../pages/admin/components/ProfileManager', async () => {
+  const { MockProfileManager } = await import('../utils/componentMocks');
+  return { ProfileManager: MockProfileManager };
+});
+
+vi.mock('../../features/voice-assistant/VoiceAssistant', async () => {
+  const { MockVoiceAssistant } = await import('../utils/componentMocks');
+  return { VoiceAssistant: MockVoiceAssistant };
+});
+
+vi.mock('../../components/FlyerCorrectionTool', async () => {
+  const { MockFlyerCorrectionTool } = await import('../utils/componentMocks');
+  return { FlyerCorrectionTool: MockFlyerCorrectionTool };
+});
+
+vi.mock('../../components/WhatsNewModal', async () => {
+  const { MockWhatsNewModal } = await import('../utils/componentMocks');
+  return { WhatsNewModal: MockWhatsNewModal };
+});
+
+vi.mock('../../layouts/MainLayout', async () => {
+  const { MockMainLayout } = await import('../utils/componentMocks');
+  return { MainLayout: MockMainLayout };
+});

src/tests/utils/componentMocks.tsx

@@ -107,8 +107,9 @@ export const MockMainLayout: React.FC<Partial<MainLayoutProps>> = () => (
     <Outlet />
   </div>
 );
-export const MockHomePage: React.FC<Partial<HomePageProps>> = ({ onOpenCorrectionTool }) => (
-  <div data-testid="home-page-mock">
+export const MockHomePage: React.FC<Partial<HomePageProps>> = ({ selectedFlyer, onOpenCorrectionTool }) => (
+  <div data-testid="home-page-mock" data-selected-flyer-id={selectedFlyer?.flyer_id}>
+    Mock Home Page
     <button onClick={onOpenCorrectionTool}>Open Correction Tool</button>
   </div>
 );

src/utils/pdfConverter.test.ts

@@ -180,15 +180,26 @@ describe('pdfConverter', () => {
     });
   });
 
-  it('should throw an error if getContext returns null', async () => {
+  it('should return partial results if one page fails to get a canvas context', async () => {
     const pdfFile = new File(['pdf-content'], 'flyer.pdf', { type: 'application/pdf' });
     // Mock getContext to fail for the first page
     mockGetContext.mockReturnValueOnce(null);
+    const mockedLogger = logger as Mocked<typeof logger>;
 
-    await expect(convertPdfToImageFiles(pdfFile)).rejects.toThrow('Could not get canvas context'); // This was a duplicate, fixed.
+    const { imageFiles, pageCount } = await convertPdfToImageFiles(pdfFile);
+
+    // Should still report 3 total pages
+    expect(pageCount).toBe(3);
+    // But only 2 images should be successfully created
+    expect(imageFiles).toHaveLength(2);
+    // And a warning should be logged for the failed page
+    expect(mockedLogger.warn).toHaveBeenCalledWith(
+      { error: new Error('Could not get canvas context') },
+      'A page failed to convert during PDF processing.',
+    );
   });
 
-  it('should throw an error if canvas.toBlob fails', async () => {
+  it('should throw an error if canvas.toBlob fails for the only page', async () => {
     const pdfFile = new File(['pdf-content'], 'flyer.pdf', { type: 'application/pdf' });
     mockPdfDocument.numPages = 1;
 
@@ -197,8 +208,9 @@ describe('pdfConverter', () => {
       callback(null);
     });
 
+    // The function should throw the generic "zero images" error because the only page failed.
     await expect(convertPdfToImageFiles(pdfFile)).rejects.toThrow(
-      'Failed to convert page 1 of PDF to blob.',
+      'PDF conversion resulted in zero images, though the PDF has pages. It might be corrupted or contain non-standard content.',
     );
   });