ci: Bump version to 0.4.2 [skip ci]

.gitea/workflows/deploy-to-test.yml

@@ -151,6 +151,9 @@ jobs:
             --coverage.exclude='src/db/**' \
             --coverage.exclude='src/lib/**' \
             --coverage.exclude='src/types/**' \
+            --coverage.exclude='**/index.tsx' \
+            --coverage.exclude='**/vite-env.d.ts' \
+            --coverage.exclude='**/vitest.setup.ts' \
             --reporter=verbose --includeTaskLocation --testTimeout=10000 --silent=passed-only --no-file-parallelism || true
 
           echo "--- Running Integration Tests ---"
@@ -162,6 +165,9 @@ jobs:
             --coverage.exclude='src/db/**' \
             --coverage.exclude='src/lib/**' \
             --coverage.exclude='src/types/**' \
+            --coverage.exclude='**/index.tsx' \
+            --coverage.exclude='**/vite-env.d.ts' \
+            --coverage.exclude='**/vitest.setup.ts' \
             --reporter=verbose --includeTaskLocation --testTimeout=10000 --silent=passed-only || true
 
           echo "--- Running E2E Tests ---"
@@ -175,6 +181,9 @@ jobs:
             --coverage.exclude='src/db/**' \
             --coverage.exclude='src/lib/**' \
             --coverage.exclude='src/types/**' \
+            --coverage.exclude='**/index.tsx' \
+            --coverage.exclude='**/vite-env.d.ts' \
+            --coverage.exclude='**/vitest.setup.ts' \
             --reporter=verbose --no-file-parallelism || true
 
           # Re-enable secret masking for subsequent steps.
@@ -246,7 +255,10 @@ jobs:
             --temp-dir "$NYC_SOURCE_DIR" \
             --exclude "**/*.test.ts" \
             --exclude "**/tests/**" \
-            --exclude "**/mocks/**"
+            --exclude "**/mocks/**" \
+            --exclude "**/index.tsx" \
+            --exclude "**/vite-env.d.ts" \
+            --exclude "**/vitest.setup.ts"
 
           # Re-enable secret masking for subsequent steps.
           echo "::secret-masking::"
@@ -259,16 +271,6 @@ jobs:
         if: always() # This step runs even if the previous test or coverage steps failed.
         run: echo "Skipping test artifact cleanup on runner; this is handled on the server."
 
-      - name: Deploy Coverage Report to Public URL
-        if: always()
-        run: |
-          TARGET_DIR="/var/www/flyer-crawler-test.projectium.com/coverage"
-          echo "Deploying HTML coverage report to $TARGET_DIR..."
-          mkdir -p "$TARGET_DIR"
-          rm -rf "$TARGET_DIR"/*
-          cp -r .coverage/* "$TARGET_DIR/"
-          echo "✅ Coverage report deployed to https://flyer-crawler-test.projectium.com/coverage"
-
       - name: Archive Code Coverage Report
         # This action saves the generated HTML coverage report as a downloadable artifact.
         uses: actions/upload-artifact@v3
@@ -358,6 +360,17 @@ jobs:
           rsync -avz dist/ "$APP_PATH"
           echo "Application deployment complete."
 
+      - name: Deploy Coverage Report to Public URL
+        if: always()
+        run: |
+          TARGET_DIR="/var/www/flyer-crawler-test.projectium.com/coverage"
+          echo "Deploying HTML coverage report to $TARGET_DIR..."
+          mkdir -p "$TARGET_DIR"
+          rm -rf "$TARGET_DIR"/*
+          # The merged nyc report is generated in the .coverage directory. We copy its contents.
+          cp -r .coverage/* "$TARGET_DIR/"
+          echo "✅ Coverage report deployed to https://flyer-crawler-test.projectium.com/coverage"
+
       - name: Install Backend Dependencies and Restart Test Server
         env:
           # --- Test Secrets Injection ---

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "flyer-crawler",
-  "version": "0.2.35",
+  "version": "0.4.2",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "flyer-crawler",
-      "version": "0.2.35",
+      "version": "0.4.2",
       "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.2.35",
+  "version": "0.4.2",
   "type": "module",
   "scripts": {
     "dev": "concurrently \"npm:start:dev\" \"vite\"",

src/features/flyer/FlyerList.test.tsx

@@ -1,7 +1,7 @@
 // src/features/flyer/FlyerList.test.tsx
 import React from 'react';
 import { render, screen, fireEvent, waitFor } from '@testing-library/react';
-import { describe, it, expect, vi, beforeEach, type Mocked } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach, type Mocked } from 'vitest';
 import { FlyerList } from './FlyerList';
 import { formatShortDate } from './dateUtils';
 import type { Flyer, UserProfile } from '../../types';
@@ -257,6 +257,73 @@ describe('FlyerList', () => {
     });
   });
 
+  describe('Expiration Status Logic', () => {
+    beforeEach(() => {
+      vi.useFakeTimers();
+    });
+
+    afterEach(() => {
+      vi.useRealTimers();
+    });
+
+    it('should show "Expired" for past dates', () => {
+      // Flyer 1 valid_to is 2023-10-11
+      vi.setSystemTime(new Date('2023-10-12T12:00:00Z'));
+      render(
+        <FlyerList
+          flyers={[mockFlyers[0]]}
+          onFlyerSelect={mockOnFlyerSelect}
+          selectedFlyerId={null}
+          profile={mockProfile}
+        />,
+      );
+      expect(screen.getByText('• Expired')).toBeInTheDocument();
+      expect(screen.getByText('• Expired')).toHaveClass('text-red-500');
+    });
+
+    it('should show "Expires today" when valid_to is today', () => {
+      vi.setSystemTime(new Date('2023-10-11T12:00:00Z'));
+      render(
+        <FlyerList
+          flyers={[mockFlyers[0]]}
+          onFlyerSelect={mockOnFlyerSelect}
+          selectedFlyerId={null}
+          profile={mockProfile}
+        />,
+      );
+      expect(screen.getByText('• Expires today')).toBeInTheDocument();
+      expect(screen.getByText('• Expires today')).toHaveClass('text-orange-500');
+    });
+
+    it('should show "Expires in X days" (orange) for <= 3 days', () => {
+      vi.setSystemTime(new Date('2023-10-09T12:00:00Z')); // 2 days left
+      render(
+        <FlyerList
+          flyers={[mockFlyers[0]]}
+          onFlyerSelect={mockOnFlyerSelect}
+          selectedFlyerId={null}
+          profile={mockProfile}
+        />,
+      );
+      expect(screen.getByText('• Expires in 2 days')).toBeInTheDocument();
+      expect(screen.getByText('• Expires in 2 days')).toHaveClass('text-orange-500');
+    });
+
+    it('should show "Expires in X days" (green) for > 3 days', () => {
+      vi.setSystemTime(new Date('2023-10-05T12:00:00Z')); // 6 days left
+      render(
+        <FlyerList
+          flyers={[mockFlyers[0]]}
+          onFlyerSelect={mockOnFlyerSelect}
+          selectedFlyerId={null}
+          profile={mockProfile}
+        />,
+      );
+      expect(screen.getByText('• Expires in 6 days')).toBeInTheDocument();
+      expect(screen.getByText('• Expires in 6 days')).toHaveClass('text-green-600');
+    });
+  });
+
   describe('Admin Functionality', () => {
     const adminProfile: UserProfile = createMockUserProfile({
       user: { user_id: 'admin-1', email: 'admin@example.com' },

src/features/flyer/FlyerUploader.test.tsx

@@ -9,12 +9,21 @@ import { useNavigate, MemoryRouter } from 'react-router-dom';
 import { QueryClient, QueryClientProvider, onlineManager } from '@tanstack/react-query';
 
 // Mock dependencies
-vi.mock('../../services/aiApiClient');
+vi.mock('../../services/aiApiClient', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../services/aiApiClient')>();
+  return {
+    ...actual,
+    uploadAndProcessFlyer: vi.fn(),
+    getJobStatus: vi.fn(),
+  };
+});
 vi.mock('../../services/logger.client', () => ({
   // Keep the original logger.info/error but also spy on it for test assertions if needed
   logger: {
     info: vi.fn((...args) => console.log('[LOGGER.INFO]', ...args)),
     error: vi.fn((...args) => console.error('[LOGGER.ERROR]', ...args)),
+    warn: vi.fn((...args) => console.warn('[LOGGER.WARN]', ...args)),
+    debug: vi.fn((...args) => console.debug('[LOGGER.DEBUG]', ...args)),
   },
 }));
 vi.mock('../../utils/checksum', () => ({
@@ -223,14 +232,10 @@ describe('FlyerUploader', () => {
   it('should handle a failed job', async () => {
     console.log('--- [TEST LOG] ---: 1. Setting up mocks for a failed job.');
     mockedAiApiClient.uploadAndProcessFlyer.mockResolvedValue({ jobId: 'job-fail' });
-    mockedAiApiClient.getJobStatus.mockResolvedValue({
-      state: 'failed',
-      progress: {
-        errorCode: 'UNKNOWN_ERROR',
-        message: 'AI model exploded',
-      },
-      failedReason: 'This is the raw error message.', // The UI should prefer the progress message.
-    });
+    // The getJobStatus function throws a specific error when the job fails,
+    // which is then caught by react-query and placed in the `error` state.
+    const jobFailedError = new aiApiClientModule.JobFailedError('AI model exploded', 'UNKNOWN_ERROR');
+    mockedAiApiClient.getJobStatus.mockRejectedValue(jobFailedError);
 
     console.log('--- [TEST LOG] ---: 2. Rendering and uploading.');
     renderComponent();
@@ -243,7 +248,8 @@ describe('FlyerUploader', () => {
 
     try {
       console.log('--- [TEST LOG] ---: 4. AWAITING failure message...');
-      expect(await screen.findByText(/Processing failed: AI model exploded/i)).toBeInTheDocument();
+      // The UI should now display the error from the `pollError` state, which includes the "Polling failed" prefix.
+      expect(await screen.findByText(/Polling failed: AI model exploded/i)).toBeInTheDocument();
       console.log('--- [TEST LOG] ---: 5. SUCCESS: Failure message found.');
     } catch (error) {
       console.error('--- [TEST LOG] ---: 5. ERROR: findByText for failure message timed out.');
@@ -262,13 +268,10 @@ describe('FlyerUploader', () => {
     mockedAiApiClient.uploadAndProcessFlyer.mockResolvedValue({ jobId: 'job-fail-timeout' });
 
     // We need at least one 'active' response to establish a timeout loop so we have something to clear
+    // The second call should be a rejection, as this is how getJobStatus signals a failure.
     mockedAiApiClient.getJobStatus
       .mockResolvedValueOnce({ state: 'active', progress: { message: 'Working...' } })
-      .mockResolvedValueOnce({
-        state: 'failed',
-        progress: { errorCode: 'UNKNOWN_ERROR', message: 'Fatal Error' },
-        failedReason: 'Fatal Error',
-      });
+      .mockRejectedValueOnce(new aiApiClientModule.JobFailedError('Fatal Error', 'UNKNOWN_ERROR'));
 
     renderComponent();
     const file = new File(['content'], 'flyer.pdf', { type: 'application/pdf' });
@@ -280,7 +283,7 @@ describe('FlyerUploader', () => {
     await screen.findByText('Working...');
 
     // Wait for the failure UI
-    await waitFor(() => expect(screen.getByText(/Processing failed: Fatal Error/i)).toBeInTheDocument(), { timeout: 4000 });
+    await waitFor(() => expect(screen.getByText(/Polling failed: Fatal Error/i)).toBeInTheDocument(), { timeout: 4000 });
 
     // Verify clearTimeout was called
     expect(clearTimeoutSpy).toHaveBeenCalled();

src/features/shopping/ShoppingList.test.tsx

@@ -236,6 +236,24 @@ describe('ShoppingListComponent (in shopping feature)', () => {
     alertSpy.mockRestore();
   });
 
+  it('should show a generic alert if reading aloud fails with a non-Error object', async () => {
+    const alertSpy = vi.spyOn(window, 'alert').mockImplementation(() => {});
+    vi.spyOn(aiApiClient, 'generateSpeechFromText').mockRejectedValue('A string error');
+
+    render(<ShoppingListComponent {...defaultProps} />);
+    const readAloudButton = screen.getByTitle(/read list aloud/i);
+
+    fireEvent.click(readAloudButton);
+
+    await waitFor(() => {
+      expect(alertSpy).toHaveBeenCalledWith(
+        'Could not read list aloud: An unknown error occurred while generating audio.',
+      );
+    });
+
+    alertSpy.mockRestore();
+  });
+
   it('should handle interactions with purchased items', () => {
     render(<ShoppingListComponent {...defaultProps} />);
 

src/features/shopping/ShoppingList.tsx

@@ -1,5 +1,5 @@
 // src/features/shopping/ShoppingList.tsx
-import React, { useState, useMemo, useCallback, useEffect } from 'react';
+import React, { useState, useMemo, useCallback } from 'react';
 import type { ShoppingList, ShoppingListItem, User } from '../../types';
 import { UserIcon } from '../../components/icons/UserIcon';
 import { ListBulletIcon } from '../../components/icons/ListBulletIcon';
@@ -56,28 +56,6 @@ export const ShoppingListComponent: React.FC<ShoppingListComponentProps> = ({
     return { neededItems, purchasedItems };
   }, [activeList]);
 
-  useEffect(() => {
-    if (activeList) {
-      console.log('ShoppingList Debug: Active List:', activeList.name);
-      console.log(
-        'ShoppingList Debug: Needed Items:',
-        neededItems.map((i) => ({
-          id: i.shopping_list_item_id,
-          name: i.custom_item_name || i.master_item?.name,
-          raw: i,
-        })),
-      );
-      console.log(
-        'ShoppingList Debug: Purchased Items:',
-        purchasedItems.map((i) => ({
-          id: i.shopping_list_item_id,
-          name: i.custom_item_name || i.master_item?.name,
-          raw: i,
-        })),
-      );
-    }
-  }, [activeList, neededItems, purchasedItems]);
-
   const handleCreateList = async () => {
     const name = prompt('Enter a name for your new shopping list:');
     if (name && name.trim()) {

src/features/shopping/WatchedItemsList.test.tsx

@@ -164,6 +164,15 @@ describe('WatchedItemsList (in shopping feature)', () => {
     expect(itemsDesc[1]).toHaveTextContent('Eggs');
     expect(itemsDesc[2]).toHaveTextContent('Bread');
     expect(itemsDesc[3]).toHaveTextContent('Apples');
+
+    // Click again to sort ascending
+    fireEvent.click(sortButton);
+
+    const itemsAscAgain = screen.getAllByRole('listitem');
+    expect(itemsAscAgain[0]).toHaveTextContent('Apples');
+    expect(itemsAscAgain[1]).toHaveTextContent('Bread');
+    expect(itemsAscAgain[2]).toHaveTextContent('Eggs');
+    expect(itemsAscAgain[3]).toHaveTextContent('Milk');
   });
 
   it('should call onAddItemToList when plus icon is clicked', () => {
@@ -222,6 +231,18 @@ describe('WatchedItemsList (in shopping feature)', () => {
       fireEvent.change(nameInput, { target: { value: 'Grapes' } });
       expect(addButton).toBeDisabled();
     });
+
+    it('should not submit if form is submitted with invalid data', () => {
+      render(<WatchedItemsList {...defaultProps} />);
+      const nameInput = screen.getByPlaceholderText(/add item/i);
+      const form = nameInput.closest('form')!;
+      const categorySelect = screen.getByDisplayValue('Select a category');
+      fireEvent.change(categorySelect, { target: { value: 'Dairy & Eggs' } });
+
+      fireEvent.change(nameInput, { target: { value: '   ' } });
+      fireEvent.submit(form);
+      expect(mockOnAddItem).not.toHaveBeenCalled();
+    });
   });
 
   describe('Error Handling', () => {

src/hooks/useFlyerUploader.ts

@@ -44,11 +44,16 @@ export const useFlyerUploader = () => {
     enabled: !!jobId,
     // Polling logic: react-query handles the interval
     refetchInterval: (query) => {
-      const data = query.state.data;
+      const data = query.state.data as JobStatus | undefined;
       // Stop polling if the job is completed or has failed
       if (data?.state === 'completed' || data?.state === 'failed') {
         return false;
       }
+      // Also stop polling if the query itself has errored (e.g. network error, or JobFailedError thrown from getJobStatus)
+      if (query.state.status === 'error') {
+        logger.warn('[useFlyerUploader] Polling stopped due to query error state.');
+        return false;
+      }
       // Otherwise, poll every 3 seconds
       return 3000;
     },

src/hooks/useShoppingLists.test.tsx

@@ -495,6 +495,22 @@ describe('useShoppingLists Hook', () => {
       expect(currentLists[0].items).toHaveLength(1); // Length should remain 1
       console.log('  LOG: SUCCESS! Duplicate was not added and API was not called.');
     });
+
+    it('should log an error and not call the API if the listId does not exist', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const { result } = renderHook(() => useShoppingLists());
+
+      await act(async () => {
+        // Call with a non-existent list ID (mock lists have IDs 1 and 2)
+        await result.current.addItemToList(999, { customItemName: 'Wont be added' });
+      });
+
+      // The API should not have been called because the list was not found.
+      expect(mockAddItemApi).not.toHaveBeenCalled();
+      expect(consoleErrorSpy).toHaveBeenCalledWith('useShoppingLists: List with ID 999 not found.');
+
+      consoleErrorSpy.mockRestore();
+    });
   });
 
   describe('updateItemInList', () => {
@@ -656,24 +672,14 @@ describe('useShoppingLists Hook', () => {
       },
       {
         name: 'updateItemInList',
-        action: (hook: any) => {
-          act(() => {
-            hook.setActiveListId(1);
-          });
-          return hook.updateItemInList(101, { is_purchased: true });
-        },
+        action: (hook: any) => hook.updateItemInList(101, { is_purchased: true }),
         apiMock: mockUpdateItemApi,
         mockIndex: 3,
         errorMessage: 'Update failed',
       },
       {
         name: 'removeItemFromList',
-        action: (hook: any) => {
-          act(() => {
-            hook.setActiveListId(1);
-          });
-          return hook.removeItemFromList(101);
-        },
+        action: (hook: any) => hook.removeItemFromList(101),
         apiMock: mockRemoveItemApi,
         mockIndex: 4,
         errorMessage: 'Removal failed',
@@ -681,6 +687,17 @@ describe('useShoppingLists Hook', () => {
     ])(
       'should set an error for $name if the API call fails',
       async ({ action, apiMock, mockIndex, errorMessage }) => {
+        // Setup a default list so activeListId is set automatically
+        const mockList = createMockShoppingList({ shopping_list_id: 1, name: 'List 1' });
+        mockedUseUserData.mockReturnValue({
+          shoppingLists: [mockList],
+          setShoppingLists: mockSetShoppingLists,
+          watchedItems: [],
+          setWatchedItems: vi.fn(),
+          isLoading: false,
+          error: null,
+        });
+
         const apiMocksWithError = [...defaultApiMocks];
         apiMocksWithError[mockIndex] = {
           ...apiMocksWithError[mockIndex],
@@ -689,11 +706,25 @@ describe('useShoppingLists Hook', () => {
         setupApiMocks(apiMocksWithError);
         apiMock.mockRejectedValue(new Error(errorMessage));
 
+        // Spy on console.error to ensure the catch block is executed for logging
+        const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
         const { result } = renderHook(() => useShoppingLists());
+
+        // Wait for the effect to set the active list ID
+        await waitFor(() => expect(result.current.activeListId).toBe(1));
+
         await act(async () => {
           await action(result.current);
         });
-        await waitFor(() => expect(result.current.error).toBe(errorMessage));
+
+        await waitFor(() => {
+          expect(result.current.error).toBe(errorMessage);
+          // Verify that our custom logging within the catch block was called
+          expect(consoleErrorSpy).toHaveBeenCalled();
+        });
+
+        consoleErrorSpy.mockRestore();
       },
     );
   });

src/middleware/multer.middleware.test.ts

@@ -1,5 +1,9 @@
 // src/middleware/multer.middleware.test.ts
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import multer from 'multer';
+import type { Request, Response, NextFunction } from 'express';
+import { createUploadMiddleware, handleMulterError } from './multer.middleware';
+import { createMockUserProfile } from '../tests/utils/mockFactories';
 
 // 1. Hoist the mocks so they can be referenced inside vi.mock factories.
 const mocks = vi.hoisted(() => ({
@@ -26,13 +30,26 @@ vi.mock('../services/logger.server', () => ({
 }));
 
 // 4. Mock multer to prevent it from doing anything during import.
-vi.mock('multer', () => ({
-  default: vi.fn(() => ({
-    single: vi.fn(),
-    array: vi.fn(),
-  })),
-  diskStorage: vi.fn(),
-}));
+vi.mock('multer', () => {
+  const diskStorage = vi.fn((options) => options);
+  class MulterError extends Error {
+    constructor(public code: string) {
+      super(code);
+      this.name = 'MulterError';
+    }
+  }
+  const multer = vi.fn(() => ({
+    single: vi.fn().mockImplementation(() => (req: any, res: any, next: any) => next()),
+    array: vi.fn().mockImplementation(() => (req: any, res: any, next: any) => next()),
+  }));
+  (multer as any).diskStorage = diskStorage;
+  (multer as any).MulterError = MulterError;
+  return {
+    default: multer,
+    diskStorage,
+    MulterError,
+  };
+});
 
 describe('Multer Middleware Directory Creation', () => {
   beforeEach(() => {
@@ -71,4 +88,163 @@ describe('Multer Middleware Directory Creation', () => {
       'Failed to create multer storage directories on startup.',
     );
   });
+});
+
+describe('createUploadMiddleware', () => {
+  const mockFile = { originalname: 'test.png' } as Express.Multer.File;
+  const mockUser = createMockUserProfile({ user: { user_id: 'user-123', email: 'test@user.com' } });
+  let originalNodeEnv: string | undefined;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    originalNodeEnv = process.env.NODE_ENV;
+  });
+
+  afterEach(() => {
+    process.env.NODE_ENV = originalNodeEnv;
+  });
+
+  describe('Avatar Storage', () => {
+    it('should generate a unique filename for an authenticated user', () => {
+      createUploadMiddleware({ storageType: 'avatar' });
+      const storageOptions = vi.mocked(multer.diskStorage).mock.calls[0][0];
+      const cb = vi.fn();
+      const mockReq = { user: mockUser } as unknown as Request;
+
+      storageOptions.filename!(mockReq, mockFile, cb);
+
+      expect(cb).toHaveBeenCalledWith(null, expect.stringContaining('user-123-'));
+      expect(cb).toHaveBeenCalledWith(null, expect.stringContaining('.png'));
+    });
+
+    it('should call the callback with an error for an unauthenticated user', () => {
+      // This test covers line 37
+      createUploadMiddleware({ storageType: 'avatar' });
+      const storageOptions = vi.mocked(multer.diskStorage).mock.calls[0][0];
+      const cb = vi.fn();
+      const mockReq = {} as Request; // No user on request
+
+      storageOptions.filename!(mockReq, mockFile, cb);
+
+      expect(cb).toHaveBeenCalledWith(
+        new Error('User not authenticated for avatar upload'),
+        expect.any(String),
+      );
+    });
+
+    it('should use a predictable filename in test environment', () => {
+      process.env.NODE_ENV = 'test';
+      createUploadMiddleware({ storageType: 'avatar' });
+      const storageOptions = vi.mocked(multer.diskStorage).mock.calls[0][0];
+      const cb = vi.fn();
+      const mockReq = { user: mockUser } as unknown as Request;
+
+      storageOptions.filename!(mockReq, mockFile, cb);
+
+      expect(cb).toHaveBeenCalledWith(null, 'test-avatar.png');
+    });
+  });
+
+  describe('Flyer Storage', () => {
+    it('should generate a unique, sanitized filename in production environment', () => {
+      process.env.NODE_ENV = 'production';
+      const mockFlyerFile = {
+        fieldname: 'flyerFile',
+        originalname: 'My Flyer (Special!).pdf',
+      } as Express.Multer.File;
+      createUploadMiddleware({ storageType: 'flyer' });
+      const storageOptions = vi.mocked(multer.diskStorage).mock.calls[0][0];
+      const cb = vi.fn();
+      const mockReq = {} as Request;
+
+      storageOptions.filename!(mockReq, mockFlyerFile, cb);
+
+      expect(cb).toHaveBeenCalledWith(
+        null,
+        expect.stringMatching(/^flyerFile-\d+-\d+-my-flyer-special.pdf$/),
+      );
+    });
+
+    it('should generate a predictable filename in test environment', () => {
+      // This test covers lines 43-46
+      process.env.NODE_ENV = 'test';
+      const mockFlyerFile = {
+        fieldname: 'flyerFile',
+        originalname: 'test-flyer.jpg',
+      } as Express.Multer.File;
+      createUploadMiddleware({ storageType: 'flyer' });
+      const storageOptions = vi.mocked(multer.diskStorage).mock.calls[0][0];
+      const cb = vi.fn();
+      const mockReq = {} as Request;
+
+      storageOptions.filename!(mockReq, mockFlyerFile, cb);
+
+      expect(cb).toHaveBeenCalledWith(null, 'flyerFile-test-flyer-image.jpg');
+    });
+  });
+
+  describe('Image File Filter', () => {
+    it('should accept files with an image mimetype', () => {
+      createUploadMiddleware({ storageType: 'flyer', fileFilter: 'image' });
+      const multerOptions = vi.mocked(multer).mock.calls[0][0];
+      const cb = vi.fn();
+      const mockImageFile = { mimetype: 'image/png' } as Express.Multer.File;
+
+      multerOptions!.fileFilter!({} as Request, mockImageFile, cb);
+
+      expect(cb).toHaveBeenCalledWith(null, true);
+    });
+
+    it('should reject files without an image mimetype', () => {
+      createUploadMiddleware({ storageType: 'flyer', fileFilter: 'image' });
+      const multerOptions = vi.mocked(multer).mock.calls[0][0];
+      const cb = vi.fn();
+      const mockTextFile = { mimetype: 'text/plain' } as Express.Multer.File;
+
+      multerOptions!.fileFilter!({} as Request, mockTextFile, cb);
+
+      expect(cb).toHaveBeenCalledWith(new Error('Only image files are allowed!'));
+    });
+  });
+});
+
+describe('handleMulterError Middleware', () => {
+  let mockRequest: Partial<Request>;
+  let mockResponse: Partial<Response>;
+  let mockNext: NextFunction;
+
+  beforeEach(() => {
+    mockRequest = {};
+    mockResponse = {
+      status: vi.fn().mockReturnThis(),
+      json: vi.fn(),
+    };
+    mockNext = vi.fn();
+  });
+
+  it('should handle a MulterError (e.g., file too large)', () => {
+    const err = new multer.MulterError('LIMIT_FILE_SIZE');
+    handleMulterError(err, mockRequest as Request, mockResponse as Response, mockNext);
+    expect(mockResponse.status).toHaveBeenCalledWith(400);
+    expect(mockResponse.json).toHaveBeenCalledWith({
+      message: 'File upload error: File too large',
+    });
+    expect(mockNext).not.toHaveBeenCalled();
+  });
+
+  it('should handle the custom image file filter error', () => {
+    // This test covers lines 59-61
+    const err = new Error('Only image files are allowed!');
+    handleMulterError(err, mockRequest as Request, mockResponse as Response, mockNext);
+    expect(mockResponse.status).toHaveBeenCalledWith(400);
+    expect(mockResponse.json).toHaveBeenCalledWith({ message: 'Only image files are allowed!' });
+    expect(mockNext).not.toHaveBeenCalled();
+  });
+
+  it('should pass on non-multer errors to the next error handler', () => {
+    const err = new Error('A generic error');
+    handleMulterError(err, mockRequest as Request, mockResponse as Response, mockNext);
+    expect(mockNext).toHaveBeenCalledWith(err);
+    expect(mockResponse.status).not.toHaveBeenCalled();
+  });
 });

src/pages/admin/FlyerReviewPage.test.tsx

@@ -1,4 +1,5 @@
-import { render, screen, waitFor } from '@testing-library/react';
+// src/pages/admin/FlyerReviewPage.test.tsx
+import { render, screen, waitFor, within } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { FlyerReviewPage } from './FlyerReviewPage';
 import { MemoryRouter } from 'react-router-dom';
@@ -74,6 +75,13 @@ describe('FlyerReviewPage', () => {
         store: { name: 'Store B' },
         icon_url: 'icon2.jpg',
       },
+      {
+        flyer_id: 3,
+        file_name: 'flyer3.jpg',
+        created_at: '2023-01-03T00:00:00Z',
+        store: null,
+        icon_url: null,
+      },
     ];
 
     vi.mocked(apiClient.getFlyersForReview).mockResolvedValue({
@@ -95,6 +103,14 @@ describe('FlyerReviewPage', () => {
     expect(screen.getByText('flyer1.jpg')).toBeInTheDocument();
     expect(screen.getByText('Store B')).toBeInTheDocument();
     expect(screen.getByText('flyer2.jpg')).toBeInTheDocument();
+
+    // Test fallback for null store and icon_url
+    expect(screen.getByText('Unknown Store')).toBeInTheDocument();
+    expect(screen.getByText('flyer3.jpg')).toBeInTheDocument();
+    const unknownStoreItem = screen.getByText('Unknown Store').closest('li');
+    const unknownStoreImage = within(unknownStoreItem!).getByRole('img');
+    expect(unknownStoreImage).not.toHaveAttribute('src');
+    expect(unknownStoreImage).not.toHaveAttribute('alt');
   });
 
   it('renders error message when API response is not ok', async () => {
@@ -140,4 +156,24 @@ describe('FlyerReviewPage', () => {
       'Failed to fetch flyers for review'
     );
   });
+
+  it('renders a generic error for non-Error rejections', async () => {
+    const nonErrorRejection = { message: 'This is not an Error object' };
+    vi.mocked(apiClient.getFlyersForReview).mockRejectedValue(nonErrorRejection);
+
+    render(
+      <MemoryRouter>
+        <FlyerReviewPage />
+      </MemoryRouter>,
+    );
+
+    await waitFor(() => {
+      expect(screen.getByText('An unknown error occurred while fetching data.')).toBeInTheDocument();
+    });
+
+    expect(logger.error).toHaveBeenCalledWith(
+      { err: nonErrorRejection },
+      'Failed to fetch flyers for review',
+    );
+  });
 });

src/pages/admin/FlyerReviewPage.tsx

@@ -73,7 +73,7 @@ export const FlyerReviewPage: React.FC = () => {
               flyers.map((flyer) => (
                 <li key={flyer.flyer_id} className="p-4 hover:bg-gray-50 dark:hover:bg-gray-700/50">
                   <Link to={`/flyers/${flyer.flyer_id}`} className="flex items-center space-x-4">
-                    <img src={flyer.icon_url || ''} alt={flyer.store?.name} className="w-12 h-12 rounded-md object-cover" />
+                    <img src={flyer.icon_url || undefined} alt={flyer.store?.name} className="w-12 h-12 rounded-md object-cover" />
                     <div className="flex-1">
                       <p className="font-semibold text-gray-800 dark:text-white">{flyer.store?.name || 'Unknown Store'}</p>
                       <p className="text-sm text-gray-500 dark:text-gray-400">{flyer.file_name}</p>

src/routes/admin.content.routes.test.ts

@@ -7,6 +7,7 @@ import {
   createMockSuggestedCorrection,
   createMockBrand,
   createMockRecipe,
+  createMockFlyer,
   createMockRecipeComment,
   createMockUnmatchedFlyerItem,
 } from '../tests/utils/mockFactories';
@@ -38,9 +39,11 @@ const { mockedDb } = vi.hoisted(() => {
         rejectCorrection: vi.fn(),
         updateSuggestedCorrection: vi.fn(),
         getUnmatchedFlyerItems: vi.fn(),
+        getFlyersForReview: vi.fn(), // Added for flyer review tests
         updateRecipeStatus: vi.fn(),
         updateRecipeCommentStatus: vi.fn(),
         updateBrandLogo: vi.fn(),
+        getApplicationStats: vi.fn(),
       },
       flyerRepo: {
         getAllBrands: vi.fn(),
@@ -73,10 +76,12 @@ vi.mock('node:fs/promises', () => ({
   // Named exports
   writeFile: vi.fn().mockResolvedValue(undefined),
   unlink: vi.fn().mockResolvedValue(undefined),
+  mkdir: vi.fn().mockResolvedValue(undefined),
   // FIX: Add default export to handle `import fs from ...` syntax.
   default: {
     writeFile: vi.fn().mockResolvedValue(undefined),
     unlink: vi.fn().mockResolvedValue(undefined),
+    mkdir: vi.fn().mockResolvedValue(undefined),
   },
 }));
 vi.mock('../services/backgroundJobService');
@@ -225,6 +230,39 @@ describe('Admin Content Management Routes (/api/admin)', () => {
     });
   });
 
+  describe('Flyer Review Routes', () => {
+    it('GET /review/flyers should return flyers for review', async () => {
+      const mockFlyers = [
+        createMockFlyer({ flyer_id: 1, status: 'needs_review' }),
+        createMockFlyer({ flyer_id: 2, status: 'needs_review' }),
+      ];
+      vi.mocked(mockedDb.adminRepo.getFlyersForReview).mockResolvedValue(mockFlyers);
+      const response = await supertest(app).get('/api/admin/review/flyers');
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual(mockFlyers);
+      expect(vi.mocked(mockedDb.adminRepo.getFlyersForReview)).toHaveBeenCalledWith(
+        expect.anything(),
+      );
+    });
+
+    it('GET /review/flyers should return 500 on DB error', async () => {
+      vi.mocked(mockedDb.adminRepo.getFlyersForReview).mockRejectedValue(new Error('DB Error'));
+      const response = await supertest(app).get('/api/admin/review/flyers');
+      expect(response.status).toBe(500);
+      expect(response.body.message).toBe('DB Error');
+    });
+  });
+
+  describe('Stats Routes', () => {
+    // This test covers the error path for GET /stats
+    it('GET /stats should return 500 on DB error', async () => {
+      vi.mocked(mockedDb.adminRepo.getApplicationStats).mockRejectedValue(new Error('DB Error'));
+      const response = await supertest(app).get('/api/admin/stats');
+      expect(response.status).toBe(500);
+      expect(response.body.message).toBe('DB Error');
+    });
+  });
+
   describe('Brand Routes', () => {
     it('GET /brands should return a list of all brands', async () => {
       const mockBrands: Brand[] = [createMockBrand({ brand_id: 1, name: 'Brand A' })];
@@ -282,6 +320,16 @@ describe('Admin Content Management Routes (/api/admin)', () => {
       expect(fs.unlink).toHaveBeenCalledWith(expect.stringContaining('logoImage-'));
     });
 
+    it('POST /brands/:id/logo should return 400 if a non-image file is uploaded', async () => {
+      const brandId = 55;
+      const response = await supertest(app)
+        .post(`/api/admin/brands/${brandId}/logo`)
+        .attach('logoImage', Buffer.from('this is not an image'), 'document.txt');
+      expect(response.status).toBe(400);
+      // This message comes from the handleMulterError middleware for the imageFileFilter
+      expect(response.body.message).toBe('Only image files are allowed!');
+    });
+
     it('POST /brands/:id/logo should return 400 for an invalid brand ID', async () => {
       const response = await supertest(app)
         .post('/api/admin/brands/abc/logo')

src/routes/admin.users.routes.test.ts

@@ -4,7 +4,7 @@ import supertest from 'supertest';
 import type { Request, Response, NextFunction } from 'express';
 import { createMockUserProfile, createMockAdminUserView } from '../tests/utils/mockFactories';
 import type { UserProfile, Profile } from '../types';
-import { NotFoundError } from '../services/db/errors.db';
+import { NotFoundError, ValidationError } from '../services/db/errors.db';
 import { createTestApp } from '../tests/utils/createTestApp';
 
 vi.mock('../services/db/index.db', () => ({
@@ -22,6 +22,12 @@ vi.mock('../services/db/index.db', () => ({
   notificationRepo: {},
 }));
 
+vi.mock('../services/userService', () => ({
+  userService: {
+    deleteUserAsAdmin: vi.fn(),
+  },
+}));
+
 // Mock other dependencies that are not directly tested but are part of the adminRouter setup
 vi.mock('../services/db/flyer.db');
 vi.mock('../services/db/recipe.db');
@@ -53,6 +59,7 @@ import adminRouter from './admin.routes';
 
 // Import the mocked repos to control them in tests
 import { adminRepo, userRepo } from '../services/db/index.db';
+import { userService } from '../services/userService';
 
 // Mock the passport middleware
 vi.mock('./passport.routes', () => ({
@@ -191,22 +198,27 @@ describe('Admin User Management Routes (/api/admin/users)', () => {
     it('should successfully delete a user', async () => {
       const targetId = '123e4567-e89b-12d3-a456-426614174999';
       vi.mocked(userRepo.deleteUserById).mockResolvedValue(undefined);
+      vi.mocked(userService.deleteUserAsAdmin).mockResolvedValue(undefined);
       const response = await supertest(app).delete(`/api/admin/users/${targetId}`);
       expect(response.status).toBe(204);
-      expect(userRepo.deleteUserById).toHaveBeenCalledWith(targetId, expect.any(Object));
+      expect(userService.deleteUserAsAdmin).toHaveBeenCalledWith(adminId, targetId, expect.any(Object));
     });
 
     it('should prevent an admin from deleting their own account', async () => {
+      const validationError = new ValidationError([], 'Admins cannot delete their own account.');
+      vi.mocked(userService.deleteUserAsAdmin).mockRejectedValue(validationError);
       const response = await supertest(app).delete(`/api/admin/users/${adminId}`);
       expect(response.status).toBe(400);
       expect(response.body.message).toMatch(/Admins cannot delete their own account/);
       expect(userRepo.deleteUserById).not.toHaveBeenCalled();
+      expect(userService.deleteUserAsAdmin).toHaveBeenCalledWith(adminId, adminId, expect.any(Object));
     });
 
     it('should return 500 on a generic database error', async () => {
       const targetId = '123e4567-e89b-12d3-a456-426614174999';
       const dbError = new Error('DB Error');
       vi.mocked(userRepo.deleteUserById).mockRejectedValue(dbError);
+      vi.mocked(userService.deleteUserAsAdmin).mockRejectedValue(dbError);
       const response = await supertest(app).delete(`/api/admin/users/${targetId}`);
       expect(response.status).toBe(500);
     });

src/services/aiService.server.test.ts

@@ -167,7 +167,7 @@ describe('AI Service (Server)', () => {
       await adapter.generateContent(request);
 
       expect(mockGenerateContent).toHaveBeenCalledWith({
-        model: 'gemini-2.5-flash',
+        model: 'gemini-3-flash-preview',
         ...request,
       });
     });
@@ -221,14 +221,14 @@ describe('AI Service (Server)', () => {
       expect(mockGenerateContent).toHaveBeenCalledTimes(2);
 
       // Check first call
-      expect(mockGenerateContent).toHaveBeenNthCalledWith(1, {
-        model: 'gemini-2.5-flash',
+      expect(mockGenerateContent).toHaveBeenNthCalledWith(1, { // The first model in the list is now 'gemini-3-flash-preview'
+        model: 'gemini-3-flash-preview',
         ...request,
       });
 
       // Check second call
-      expect(mockGenerateContent).toHaveBeenNthCalledWith(2, {
-        model: 'gemini-3-flash',
+      expect(mockGenerateContent).toHaveBeenNthCalledWith(2, { // The second model in the list is 'gemini-2.5-flash'
+        model: 'gemini-2.5-flash',
         ...request,
       });
 
@@ -258,8 +258,8 @@ describe('AI Service (Server)', () => {
 
       expect(mockGenerateContent).toHaveBeenCalledTimes(1);
       expect(logger.error).toHaveBeenCalledWith(
-        { error: nonRetriableError },
-        `[AIService Adapter] Model 'gemini-2.5-flash' failed with a non-retriable error.`,
+        { error: nonRetriableError }, // The first model in the list is now 'gemini-3-flash-preview'
+        `[AIService Adapter] Model 'gemini-3-flash-preview' failed with a non-retriable error.`,
       );
     });
 
@@ -286,15 +286,15 @@ describe('AI Service (Server)', () => {
       );
 
       expect(mockGenerateContent).toHaveBeenCalledTimes(3);
-      expect(mockGenerateContent).toHaveBeenNthCalledWith(1, {
+      expect(mockGenerateContent).toHaveBeenNthCalledWith(1, { // The first model in the list is now 'gemini-3-flash-preview'
+        model: 'gemini-3-flash-preview',
+        ...request,
+      });
+      expect(mockGenerateContent).toHaveBeenNthCalledWith(2, { // The second model in the list is 'gemini-2.5-flash'
         model: 'gemini-2.5-flash',
         ...request,
       });
-      expect(mockGenerateContent).toHaveBeenNthCalledWith(2, {
-        model: 'gemini-3-flash',
-        ...request,
-      });
-      expect(mockGenerateContent).toHaveBeenNthCalledWith(3, {
+      expect(mockGenerateContent).toHaveBeenNthCalledWith(3, { // The third model in the list is 'gemini-2.5-flash-lite'
         model: 'gemini-2.5-flash-lite',
         ...request,
       });

src/services/aiService.server.ts

@@ -109,7 +109,10 @@ export class AIService {
   private fs: IFileSystem;
   private rateLimiter: <T>(fn: () => Promise<T>) => Promise<T>;
   private logger: Logger;
-  private readonly models = ['gemini-2.5-flash', 'gemini-3-flash', 'gemini-2.5-flash-lite'];
+  // The fallback list is ordered by preference (speed/cost vs. power).
+  // We try the fastest models first, then the more powerful 'pro' model as a high-quality fallback,
+  // and finally the 'lite' model as a last resort.
+  private readonly models = [ 'gemini-3-flash-preview', 'gemini-2.5-flash', 'gemini-2.5-flash-lite'];
 
   constructor(logger: Logger, aiClient?: IAiClient, fs?: IFileSystem) {
     this.logger = logger;
@@ -230,7 +233,8 @@ export class AIService {
           errorMessage.includes('quota') ||
           errorMessage.includes('429') || // HTTP 429 Too Many Requests
           errorMessage.includes('resource_exhausted') || // Make case-insensitive
-          errorMessage.includes('model is overloaded')
+          errorMessage.includes('model is overloaded') ||
+          errorMessage.includes('not found') // Also retry if model is not found (e.g., regional availability or API version issue)
         ) {
           this.logger.warn(
             `[AIService Adapter] Model '${modelName}' failed due to quota/rate limit. Trying next model. Error: ${errorMessage}`,

src/services/db/address.db.test.ts

@@ -92,5 +92,37 @@ describe('Address DB Service', () => {
       expect(query).toContain('ON CONFLICT (address_id) DO UPDATE');
       expect(values).toEqual([1, '789 Old Rd', 'Oldtown']);
     });
+
+    it('should throw UniqueConstraintError on unique constraint violation', async () => {
+      const addressData = { address_line_1: '123 Duplicate St' };
+      const dbError = new Error('duplicate key value violates unique constraint');
+      (dbError as any).code = '23505';
+      mockDb.query.mockRejectedValue(dbError);
+
+      await expect(addressRepo.upsertAddress(addressData, mockLogger)).rejects.toThrow(
+        UniqueConstraintError,
+      );
+      await expect(addressRepo.upsertAddress(addressData, mockLogger)).rejects.toThrow(
+        'An identical address already exists.',
+      );
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        { err: dbError, address: addressData },
+        'Database error in upsertAddress',
+      );
+    });
+
+    it('should throw a generic error if the database query fails for other reasons', async () => {
+      const addressData = { address_line_1: '789 Failure Rd' };
+      const dbError = new Error('DB Connection Error');
+      mockDb.query.mockRejectedValue(dbError);
+
+      await expect(addressRepo.upsertAddress(addressData, mockLogger)).rejects.toThrow(
+        'Failed to upsert address.',
+      );
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        { err: dbError, address: addressData },
+        'Database error in upsertAddress',
+      );
+    });
   });
 });

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

@@ -3,11 +3,12 @@ import { describe, it, expect, vi, beforeEach, Mock } from 'vitest';
 import type { Pool, PoolClient } from 'pg';
 import { ForeignKeyConstraintError, NotFoundError } from './errors.db';
 import { AdminRepository } from './admin.db';
-import type { SuggestedCorrection, AdminUserView, Profile } from '../../types';
+import type { SuggestedCorrection, AdminUserView, Profile, Flyer } from '../../types';
 import {
   createMockSuggestedCorrection,
   createMockAdminUserView,
   createMockProfile,
+  createMockFlyer,
 } from '../../tests/utils/mockFactories';
 // Un-mock the module we are testing
 vi.unmock('./admin.db');
@@ -712,4 +713,28 @@ describe('Admin DB Service', () => {
       'Database error in updateUserRole',
     );
   });
+
+  describe('getFlyersForReview', () => {
+    it('should retrieve flyers with "needs_review" status', async () => {
+      const mockFlyers: Flyer[] = [createMockFlyer({ status: 'needs_review' })];
+      mockDb.query.mockResolvedValue({ rows: mockFlyers });
+
+      const result = await adminRepo.getFlyersForReview(mockLogger);
+
+      expect(mockDb.query).toHaveBeenCalledWith(
+        expect.stringContaining("WHERE f.status = 'needs_review'"),
+      );
+      expect(result).toEqual(mockFlyers);
+    });
+
+    it('should throw an error if the database query fails', async () => {
+      const dbError = new Error('DB Error');
+      mockDb.query.mockRejectedValue(dbError);
+
+      await expect(adminRepo.getFlyersForReview(mockLogger)).rejects.toThrow(
+        'Failed to retrieve flyers for review.',
+      );
+      expect(mockLogger.error).toHaveBeenCalledWith({ err: dbError }, 'Database error in getFlyersForReview');
+    });
+  });
 });

src/services/emailService.server.test.ts

@@ -29,6 +29,7 @@ vi.mock('./logger.server', () => ({
     info: vi.fn(),
     debug: vi.fn(),
     error: vi.fn(),
+    child: vi.fn().mockReturnThis(),
   },
 }));
 
@@ -37,10 +38,13 @@ import {
   sendPasswordResetEmail,
   sendWelcomeEmail,
   sendDealNotificationEmail,
+  processEmailJob,
 } from './emailService.server';
 import type { WatchedItemDeal } from '../types';
 import { createMockWatchedItemDeal } from '../tests/utils/mockFactories';
 import { logger } from './logger.server';
+import type { Job } from 'bullmq';
+import type { EmailJobData } from '../types/job-data';
 
 describe('Email Service (Server)', () => {
   beforeEach(async () => {
@@ -219,4 +223,51 @@ describe('Email Service (Server)', () => {
       );
     });
   });
+
+  describe('processEmailJob', () => {
+    const mockJobData: EmailJobData = {
+      to: 'job@example.com',
+      subject: 'Job Email',
+      html: '<p>Job</p>',
+      text: 'Job',
+    };
+
+    const createMockJob = (data: EmailJobData): Job<EmailJobData> =>
+      ({
+        id: 'job-123',
+        name: 'email-job',
+        data,
+        attemptsMade: 1,
+      } as unknown as Job<EmailJobData>);
+
+    it('should call sendMail with job data and log success', async () => {
+      const job = createMockJob(mockJobData);
+      mocks.sendMail.mockResolvedValue({ messageId: 'job-test-id' });
+
+      await processEmailJob(job);
+
+      expect(mocks.sendMail).toHaveBeenCalledTimes(1);
+      const mailOptions = mocks.sendMail.mock.calls[0][0];
+      expect(mailOptions.to).toBe(mockJobData.to);
+      expect(mailOptions.subject).toBe(mockJobData.subject);
+      expect(logger.info).toHaveBeenCalledWith('Picked up email job.');
+      expect(logger.info).toHaveBeenCalledWith(
+        { to: 'job@example.com', subject: 'Job Email', messageId: 'job-test-id' },
+        'Email sent successfully.',
+      );
+    });
+
+    it('should log an error and re-throw if sendMail fails', async () => {
+      const job = createMockJob(mockJobData);
+      const emailError = new Error('SMTP Connection Failed');
+      mocks.sendMail.mockRejectedValue(emailError);
+
+      await expect(processEmailJob(job)).rejects.toThrow(emailError);
+
+      expect(logger.error).toHaveBeenCalledWith(
+        { err: emailError, jobData: mockJobData, attemptsMade: 1 },
+        'Email job failed.',
+      );
+    });
+  });
 });

src/services/systemService.test.ts

@@ -29,13 +29,10 @@ describe('SystemService', () => {
 
   describe('getPm2Status', () => {
     it('should return success: true when process is online', async () => {
-      const stdout = `
-        ┌────┬──────────────────────┬──────────┐
-        │ id │ name                 │ status   │
-        ├────┼──────────────────────┼──────────┤
-        │ 0  │ flyer-crawler-api    │ online   │
-        └────┴──────────────────────┴──────────┘
-      `;
+      // This stdout mimics the output of `pm2 describe <app_name>`
+      const stdout = `Describing process with id 0 - name flyer-crawler-api
+      │ status            │ online                                      │
+      │ name              │ flyer-crawler-api                           │`;
       mockExecAsync.mockResolvedValue({ stdout, stderr: '' });
 
       const result = await systemService.getPm2Status();
@@ -47,13 +44,9 @@ describe('SystemService', () => {
     });
 
     it('should return success: false when process is stopped', async () => {
-      const stdout = `
-        ┌────┬──────────────────────┬──────────┐
-        │ id │ name                 │ status   │
-        ├────┼──────────────────────┼──────────┤
-        │ 0  │ flyer-crawler-api    │ stopped  │
-        └────┴──────────────────────┴──────────┘
-      `;
+      const stdout = `Describing process with id 0 - name flyer-crawler-api
+      │ status            │ stopped                                     │
+      │ name              │ flyer-crawler-api                           │`;
       mockExecAsync.mockResolvedValue({ stdout, stderr: '' });
 
       const result = await systemService.getPm2Status();