torbo/flyer-crawler.projectium.com
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor tests to use mockClient for database interactions, improve error handling, and enhance modal functionality
Some checks failed
Deploy to Test Environment / deploy-to-test (push) Has been cancelled
Details

Browse Source 
- Updated personalization.db.test.ts to use mockClient for query calls in addWatchedItem tests.
- Simplified error handling in shopping.db.test.ts, ensuring clearer error messages.
- Added comprehensive tests for VoiceAssistant component, including rendering and interaction tests.
- Introduced useModal hook with tests to manage modal state effectively.
- Created deals.db.test.ts to test deals repository functionality with mocked database interactions.
- Implemented error handling tests for custom error classes in errors.db.test.ts.
- Developed googleGeocodingService.server.test.ts to validate geocoding service behavior with mocked fetch.
This commit is contained in:
Torben Sorensen
2025-12-14 01:12:33 -08:00
parent 7615d7746e
commit f891da687b
25 changed files with 786 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
src/App.test.tsx
View File

@@ -1,12 +1,14 @@
// src/App.test.tsx
import React from 'react';
import { render, screen, waitFor, fireEvent, act, within, renderHook } from '@testing-library/react';
import { render, screen, waitFor, fireEvent, within } from '@testing-library/react';
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { MemoryRouter, Outlet } from 'react-router-dom';
import App from './App';
import * as aiApiClient from './services/aiApiClient'; // Import aiApiClient
import * as apiClient from './services/apiClient';
import type { Flyer, User, UserProfile } from './types';
import type { Flyer, Profile, User, UserProfile } from './types';
import type { HeaderProps } from './components/Header';
// Mock useAuth to allow overriding the user state in tests
const mockUseAuth = vi.fn();
vi.mock('./hooks/useAuth', () => ({
@@ -26,8 +28,8 @@ const mockUseUserData = vi.fn();
vi.mock('./hooks/useUserData', () => ({ useUserData: () => mockUseUserData() }));
// Mock top-level components rendered by App's routes
vi.mock('./components/Header', () => ({ Header: (props: any) => <header data-testid="header-mock"><button onClick={props.onOpenProfile}>Open Profile</button><button onClick={props.onOpenVoiceAssistant}>Open Voice Assistant</button></header> }));
vi.mock('./pages/admin/components/ProfileManager', () => ({ ProfileManager: ({ isOpen, onClose, onProfileUpdate, onLoginSuccess }: { isOpen: boolean, onClose: () => void, onProfileUpdate: (p: any) => void, onLoginSuccess: (u: any, t: string) => void }) => isOpen ? <div data-testid="profile-manager-mock"><button onClick={onClose}>Close Profile</button><button onClick={() => onProfileUpdate({ full_name: 'Updated' })}>Update Profile</button><button onClick={() => onLoginSuccess({}, 'token')}>Login</button></div> : null }));
vi.mock('./components/Header', () => ({ Header: (props: HeaderProps) => <header data-testid="header-mock"><button onClick={props.onOpenProfile}>Open Profile</button><button onClick={props.onOpenVoiceAssistant}>Open Voice Assistant</button></header> }));
vi.mock('./pages/admin/components/ProfileManager', () => ({ ProfileManager: ({ isOpen, onClose, onProfileUpdate, onLoginSuccess }: { isOpen: boolean, onClose: () => void, onProfileUpdate: (p: Profile) => void, onLoginSuccess: (u: User, t: string, r: boolean) => void }) => isOpen ? <div data-testid="profile-manager-mock"><button onClick={onClose}>Close Profile</button><button onClick={() => onProfileUpdate({ user_id: '1', role: 'user', points: 0, full_name: 'Updated' })}>Update Profile</button><button onClick={() => onLoginSuccess({ user_id: '1', email: 'a@b.com' }, 'token', false)}>Login</button></div> : null }));
vi.mock('./features/voice-assistant/VoiceAssistant', () => ({ VoiceAssistant: ({ isOpen, onClose }: { isOpen: boolean, onClose: () => void }) => isOpen ? <div data-testid="voice-assistant-mock"><button onClick={onClose}>Close Voice Assistant</button></div> : null }));
vi.mock('./pages/admin/AdminPage', () => ({ AdminPage: () => <div data-testid="admin-page-mock">Admin Page</div> }));
// In react-router v6, wrapper routes must render an <Outlet /> for nested routes to appear.
@@ -40,7 +42,7 @@ vi.mock('./components/WhatsNewModal', () => ({ WhatsNewModal: ({ isOpen, onClose
vi.mock('./components/FlyerCorrectionTool', () => ({ FlyerCorrectionTool: ({ isOpen, onClose, onDataExtracted }: { isOpen: boolean, onClose: () => void, onDataExtracted: (type: 'store_name' | 'dates', value: string) => void }) => isOpen ? <div data-testid="flyer-correction-tool-mock"><button onClick={onClose}>Close Correction</button><button onClick={() => onDataExtracted('store_name', 'New Store Name')}>Extract Store</button><button onClick={() => onDataExtracted('dates', '2023-01-01')}>Extract Dates</button></div> : null }));
// Mock the new layout and page components
vi.mock('./layouts/MainLayout', () => ({ MainLayout: () => <div data-testid="main-layout-mock"><Outlet /></div> }));
vi.mock('./pages/HomePage', () => ({ HomePage: (props: any) => <div data-testid="home-page-mock"><button onClick={props.onOpenCorrectionTool}>Open Correction Tool</button></div> }));
vi.mock('./pages/HomePage', () => ({ HomePage: (props: { onOpenCorrectionTool: () => void }) => <div data-testid="home-page-mock"><button onClick={props.onOpenCorrectionTool}>Open Correction Tool</button></div> }));
// Mock pdfjs-dist to prevent the "DOMMatrix is not defined" error in JSDOM.
// This must be done in any test file that imports App.tsx.
@@ -98,7 +100,7 @@ describe('App Component', () => {
beforeEach(() => {
vi.clearAllMocks();
// Default auth state: loading or guest
// Mock the login function to simulate a successful login
// Mock the login function to simulate a successful login.
const mockLogin = vi.fn(async (user: User, token: string) => {
// Simulate fetching profile after login
const profileResponse = await mockedApiClient.getAuthenticatedUserProfile();
@@ -467,11 +469,6 @@ describe('App Component', () => {
});
describe('Version Display and What\'s New', () => {
const mockEnv = {
VITE_APP_VERSION: '2.0.0',
VITE_APP_COMMIT_URL: 'http://example.com/commit/2.0.0',
};
beforeEach(() => {
// Also mock the config module to reflect this change
vi.mock('./config', () => ({

56
src/App.tsx
View File

@@ -20,6 +20,7 @@ import { QuestionMarkCircleIcon } from './components/icons/QuestionMarkCircleIco
import { useAuth } from './hooks/useAuth';
import { useFlyers } from './hooks/useFlyers'; // Assuming useFlyers fetches all flyers
import { useFlyerItems } from './hooks/useFlyerItems'; // Import the new hook for flyer items
import { useModal } from './hooks/useModal';
import { MainLayout } from './layouts/MainLayout';
import config from './config';
import { HomePage } from './pages/HomePage';
@@ -34,18 +35,13 @@ function App() {
const { user, profile, authStatus, login, logout, updateProfile } = useAuth();
const { flyers } = useFlyers();
const [selectedFlyer, setSelectedFlyer] = useState<Flyer | null>(null);
const { openModal, closeModal, isModalOpen } = useModal();
const location = useLocation();
const params = useParams<{ flyerId?: string }>();
const [isDarkMode, setIsDarkMode] = useState(false);
// Fetch items for the currently selected flyer
const { flyerItems } = useFlyerItems(selectedFlyer);
const [unitSystem, setUnitSystem] = useState<'metric' | 'imperial'>('imperial');
const [isProfileManagerOpen, setIsProfileManagerOpen] = useState(false); // This will now control the login modal as well
const [isWhatsNewOpen, setIsWhatsNewOpen] = useState(false);
const [isVoiceAssistantOpen, setIsVoiceAssistantOpen] = useState(false);
const [isCorrectionToolOpen, setIsCorrectionToolOpen] = useState(false);
const handleDataExtractedFromCorrection = (type: 'store_name' | 'dates', value: string) => {
if (!selectedFlyer) return;
@@ -180,7 +176,7 @@ function App() {
const lastSeenVersion = localStorage.getItem('lastSeenVersion');
// If the current version is new, show the "What's New" modal.
if (appVersion !== lastSeenVersion) {
setIsWhatsNewOpen(true);
openModal('whatsNew');
localStorage.setItem('lastSeenVersion', appVersion);
}
}
@@ -207,36 +203,34 @@ function App() {
profile={profile}
authStatus={authStatus}
user={user}
onOpenProfile={() => setIsProfileManagerOpen(true)}
onOpenVoiceAssistant={() => setIsVoiceAssistantOpen(true)}
onOpenProfile={() => openModal('profile')}
onOpenVoiceAssistant={() => openModal('voiceAssistant')}
onSignOut={logout}
/>
{/* The ProfileManager is now always available to be opened, handling both login and profile management. */}
{isProfileManagerOpen && (
<ProfileManager
isOpen={isProfileManagerOpen}
onClose={() => setIsProfileManagerOpen(false)}
user={user}
authStatus={authStatus}
profile={profile}
onProfileUpdate={handleProfileUpdate}
onLoginSuccess={handleLoginSuccess}
onSignOut={logout} // Pass the signOut handler
/>
)}
<ProfileManager
isOpen={isModalOpen('profile')}
onClose={() => closeModal('profile')}
user={user}
authStatus={authStatus}
profile={profile}
onProfileUpdate={handleProfileUpdate}
onLoginSuccess={handleLoginSuccess}
onSignOut={logout} // Pass the signOut handler
/>
{user && (
<VoiceAssistant
isOpen={isVoiceAssistantOpen}
onClose={() => setIsVoiceAssistantOpen(false)}
isOpen={isModalOpen('voiceAssistant')}
onClose={() => closeModal('voiceAssistant')}
/>
)}
{/* "What's New" modal, shown automatically on new versions */}
{appVersion && commitMessage && (
<WhatsNewModal
isOpen={isWhatsNewOpen}
onClose={() => setIsWhatsNewOpen(false)}
isOpen={isModalOpen('whatsNew')}
onClose={() => closeModal('whatsNew')}
version={appVersion}
commitMessage={commitMessage}
/>
@@ -244,8 +238,8 @@ function App() {
{selectedFlyer && (
<FlyerCorrectionTool
isOpen={isCorrectionToolOpen}
onClose={() => setIsCorrectionToolOpen(false)}
isOpen={isModalOpen('correctionTool')}
onClose={() => closeModal('correctionTool')}
imageUrl={selectedFlyer.image_url}
onDataExtracted={handleDataExtractedFromCorrection}
/>
@@ -257,14 +251,14 @@ function App() {
<MainLayout
onFlyerSelect={handleFlyerSelect}
selectedFlyerId={selectedFlyer?.flyer_id || null}
onOpenProfile={() => setIsProfileManagerOpen(true)} // Pass the profile opener function
onOpenProfile={() => openModal('profile')} // Pass the profile opener function
/>
}>
<Route index element={
<HomePage selectedFlyer={selectedFlyer} flyerItems={flyerItems} onOpenCorrectionTool={() => setIsCorrectionToolOpen(true)} />
<HomePage selectedFlyer={selectedFlyer} flyerItems={flyerItems} onOpenCorrectionTool={() => openModal('correctionTool')} />
} />
<Route path="/flyers/:flyerId" element={
<HomePage selectedFlyer={selectedFlyer} flyerItems={flyerItems} onOpenCorrectionTool={() => setIsCorrectionToolOpen(true)} />
<HomePage selectedFlyer={selectedFlyer} flyerItems={flyerItems} onOpenCorrectionTool={() => openModal('correctionTool')} />
} />
</Route>
@@ -292,7 +286,7 @@ function App() {
>
Version: {appVersion}
</a>
<button onClick={() => setIsWhatsNewOpen(true)} title="Show what's new in this version">
<button onClick={() => openModal('whatsNew')} title="Show what's new in this version">
<QuestionMarkCircleIcon className="w-5 h-5 text-gray-400 dark:text-gray-600 hover:text-brand-primary dark:hover:text-brand-primary transition-colors" />
</button>
</div>

2
src/components/Header.tsx
View File

@@ -9,7 +9,7 @@ import { ShieldCheckIcon } from './icons/ShieldCheckIcon';
import type { Profile, User } from '../types';
import type { AuthStatus } from '../hooks/useAuth';
interface HeaderProps {
export interface HeaderProps {
isDarkMode: boolean;
unitSystem: 'metric' | 'imperial';
user: User | null;

105
src/features/voice-assistant/VoiceAssistant.test.tsx Normal file
View File

@@ -0,0 +1,105 @@
// src/features/voice-assistant/VoiceAssistant.test.tsx
import React from 'react';
import { render, screen, fireEvent } from '@testing-library/react';
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { VoiceAssistant } from './VoiceAssistant';
import * as aiApiClient from '../../services/aiApiClient';
// Mock dependencies to isolate the component
vi.mock('../../services/aiApiClient', () => ({
startVoiceSession: vi.fn(),
}));
vi.mock('../../services/logger.client', () => ({
logger: {
info: vi.fn(),
debug: vi.fn(),
error: vi.fn(),
},
}));
vi.mock('../../components/icons/MicrophoneIcon', () => ({
MicrophoneIcon: () => <div data-testid="mic-icon" />,
}));
vi.mock('../../components/icons/XMarkIcon', () => ({
XMarkIcon: () => <div data-testid="x-icon" />,
}));
// Mock browser APIs that are not available in JSDOM
Object.defineProperty(window, 'AudioContext', {
writable: true,
value: vi.fn().mockImplementation(() => ({
createMediaStreamSource: vi.fn(() => ({
connect: vi.fn(),
})),
createScriptProcessor: vi.fn(() => ({
connect: vi.fn(),
disconnect: vi.fn(),
})),
close: vi.fn(),
})),
});
Object.defineProperty(navigator, 'mediaDevices', {
writable: true,
value: {
getUserMedia: vi.fn(),
},
});
describe('VoiceAssistant Component', () => {
const mockOnClose = vi.fn();
beforeEach(() => {
vi.clearAllMocks();
});
it('should not render when isOpen is false', () => {
const { container } = render(<VoiceAssistant isOpen={false} onClose={mockOnClose} />);
expect(container.firstChild).toBeNull();
});
it('should render correctly when isOpen is true', () => {
render(<VoiceAssistant isOpen={true} onClose={mockOnClose} />);
expect(screen.getByRole('heading', { name: /voice assistant/i })).toBeInTheDocument();
expect(screen.getByText('Click the mic to start')).toBeInTheDocument();
expect(screen.getByRole('button', { name: /close/i })).toBeInTheDocument();
expect(screen.getByTestId('mic-icon')).toBeInTheDocument();
});
it('should call onClose when the close button is clicked', () => {
render(<VoiceAssistant isOpen={true} onClose={mockOnClose} />);
fireEvent.click(screen.getByRole('button', { name: /close/i }));
expect(mockOnClose).toHaveBeenCalledTimes(1);
});
it('should call onClose when the overlay is clicked', () => {
render(<VoiceAssistant isOpen={true} onClose={mockOnClose} />);
// The overlay is the root div of the modal
fireEvent.click(screen.getByRole('dialog').parentElement!);
expect(mockOnClose).toHaveBeenCalledTimes(1);
});
it('should not call onClose when the modal content is clicked', () => {
render(<VoiceAssistant isOpen={true} onClose={mockOnClose} />);
fireEvent.click(screen.getByRole('heading', { name: /voice assistant/i }));
expect(mockOnClose).not.toHaveBeenCalled();
});
it('should call startVoiceSession when the microphone button is clicked in idle state', () => {
render(<VoiceAssistant isOpen={true} onClose={mockOnClose} />);
const micButton = screen.getByRole('button', { name: '' }); // The main button has no text
fireEvent.click(micButton);
expect(aiApiClient.startVoiceSession).toHaveBeenCalledTimes(1);
});
it('should display history and current transcripts', () => {
render(<VoiceAssistant isOpen={true} onClose={mockOnClose} />);
// This test is a bit more involved as it requires manipulating internal state.
// For a simple test, we can check that the container for history exists.
// A more advanced test would involve mocking the `startVoiceSession` callbacks.
const historyContainer = screen.getByRole('heading', { name: /voice assistant/i }).parentElement?.nextElementSibling;
expect(historyContainer).toBeInTheDocument();
expect(historyContainer).toBeEmptyDOMElement(); // Initially empty
});
});

49
src/hooks/useModal.test.ts
View File

@@ -1,49 +0,0 @@
// src/hooks/useModal.test.ts
import { renderHook, act } from '@testing-library/react';
import { describe, it, expect } from 'vitest';
import { useModal } from './useModal';
describe('useModal Hook', () => {
it('should initialize with isOpen as false by default', () => {
const { result } = renderHook(() => useModal());
expect(result.current.isOpen).toBe(false);
});
it('should initialize with the provided initial state (true)', () => {
const { result } = renderHook(() => useModal(true));
expect(result.current.isOpen).toBe(true);
});
it('should set isOpen to true when openModal is called', () => {
const { result } = renderHook(() => useModal());
act(() => {
result.current.openModal();
});
expect(result.current.isOpen).toBe(true);
});
it('should set isOpen to false when closeModal is called', () => {
// Start with the modal open to test the closing action
const { result } = renderHook(() => useModal(true));
act(() => {
result.current.closeModal();
});
expect(result.current.isOpen).toBe(false);
});
it('should maintain stable function references across re-renders due to useCallback', () => {
const { result, rerender } = renderHook(() => useModal());
const initialOpenModal = result.current.openModal;
const initialCloseModal = result.current.closeModal;
rerender();
expect(result.current.openModal).toBe(initialOpenModal);
expect(result.current.closeModal).toBe(initialCloseModal);
});
});

104
src/hooks/useModal.test.tsx Normal file
View File

@@ -0,0 +1,104 @@
// src/hooks/useModal.test.ts
import { renderHook, act } from '@testing-library/react';
import { describe, it, expect, vi, beforeEach } from 'vitest';
import React from 'react';
import { ModalProvider, useModal } from './useModal';
// Create a wrapper component that includes the ModalProvider.
// This is necessary because the useModal hook depends on the context provided by ModalProvider.
const wrapper = ({ children }: { children: React.ReactNode }) => (
<ModalProvider>{children}</ModalProvider>
);
describe('useModal Hook with ModalProvider', () => {
// Suppress console.error for the expected error test
beforeEach(() => {
vi.spyOn(console, 'error').mockImplementation(() => {});
});
it('should throw an error when used outside of a ModalProvider', () => {
// Render the hook without the wrapper to test the error boundary.
let error: Error | undefined;
try {
renderHook(() => useModal());
} catch (e) {
error = e as Error;
}
// The hook throws an error, which is caught by the try/catch block.
// We check the error message directly.
// Note: renderHook's result.error is for async errors, not initial render errors.
expect(error?.message).toEqual('useModal must be used within a ModalProvider');
});
it('should initialize with all modals closed', () => {
const { result } = renderHook(() => useModal(), { wrapper });
expect(result.current.isModalOpen('profile')).toBe(false);
expect(result.current.isModalOpen('voiceAssistant')).toBe(false);
expect(result.current.isModalOpen('whatsNew')).toBe(false);
expect(result.current.isModalOpen('correctionTool')).toBe(false);
});
it('should open a specific modal when openModal is called', () => {
const { result } = renderHook(() => useModal(), { wrapper });
act(() => {
result.current.openModal('profile');
});
expect(result.current.isModalOpen('profile')).toBe(true);
// Ensure other modals remain closed
expect(result.current.isModalOpen('whatsNew')).toBe(false);
});
it('should close a specific modal when closeModal is called', () => {
const { result } = renderHook(() => useModal(), { wrapper });
// First, open a modal
act(() => {
result.current.openModal('voiceAssistant');
});
expect(result.current.isModalOpen('voiceAssistant')).toBe(true);
// Then, close it
act(() => {
result.current.closeModal('voiceAssistant');
});
expect(result.current.isModalOpen('voiceAssistant')).toBe(false);
});
it('should manage the state of multiple modals independently', () => {
const { result } = renderHook(() => useModal(), { wrapper });
act(() => {
result.current.openModal('profile');
result.current.openModal('whatsNew');
});
expect(result.current.isModalOpen('profile')).toBe(true);
expect(result.current.isModalOpen('whatsNew')).toBe(true);
expect(result.current.isModalOpen('voiceAssistant')).toBe(false);
act(() => {
result.current.closeModal('profile');
});
expect(result.current.isModalOpen('profile')).toBe(false);
expect(result.current.isModalOpen('whatsNew')).toBe(true);
});
it('should maintain stable function references across re-renders due to useCallback', () => {
const { result, rerender } = renderHook(() => useModal(), { wrapper });
const initialOpenModal = result.current.openModal;
const initialCloseModal = result.current.closeModal;
const initialIsModalOpen = result.current.isModalOpen;
rerender();
expect(result.current.openModal).toBe(initialOpenModal);
expect(result.current.closeModal).toBe(initialCloseModal);
expect(result.current.isModalOpen).toBe(initialIsModalOpen);
});
});

11
src/hooks/useModal.ts
View File

@@ -1,11 +0,0 @@
// src/hooks/useModal.ts
import { useState, useCallback } from 'react';
export const useModal = (initialState: boolean = false) => {
const [isOpen, setIsOpen] = useState(initialState);
const openModal = useCallback(() => setIsOpen(true), []);
const closeModal = useCallback(() => setIsOpen(false), []);
return { isOpen, openModal, closeModal };
};

61
src/hooks/useModal.tsx Normal file
View File

@@ -0,0 +1,61 @@
// src/hooks/useModal.tsx
import React, { createContext, useState, useContext, useMemo, useCallback } from 'react';
/**
* Defines the names of all modals used in the application.
* Using a type ensures consistency and prevents typos.
*/
export type ModalType = 'profile' | 'voiceAssistant' | 'whatsNew' | 'correctionTool';
/**
* Defines the shape of the context that will be provided to consumers.
*/
interface ModalContextType {
openModal: (modal: ModalType) => void;
closeModal: (modal: ModalType) => void;
isModalOpen: (modal: ModalType) => boolean;
}
// Create the context with a default value (which should not be used directly).
const ModalContext = createContext<ModalContextType | undefined>(undefined);
/**
* The provider component that will wrap the application.
* It holds the state for all modals and provides functions to control them.
*/
export const ModalProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
const [modalState, setModalState] = useState<Record<ModalType, boolean>>({
profile: false,
voiceAssistant: false,
whatsNew: false,
correctionTool: false,
});
const openModal = useCallback((modal: ModalType) => {
setModalState(prev => ({ ...prev, [modal]: true }));
}, []);
const closeModal = useCallback((modal: ModalType) => {
setModalState(prev => ({ ...prev, [modal]: false }));
}, []);
const isModalOpen = useCallback((modal: ModalType) => modalState[modal], [modalState]);
// useMemo ensures the context value object is stable across re-renders,
// preventing unnecessary re-renders of consumer components.
const value = useMemo(() => ({ openModal, closeModal, isModalOpen }), [openModal, closeModal, isModalOpen]);
return <ModalContext.Provider value={value}>{children}</ModalContext.Provider>;
};
/**
* The custom hook that components will use to access the modal context.
* It provides a clean and simple API for interacting with modals.
*/
export const useModal = (): ModalContextType => {
const context = useContext(ModalContext);
if (context === undefined) {
throw new Error('useModal must be used within a ModalProvider');
}
return context;
};

21
src/index.tsx
View File

@@ -7,6 +7,7 @@ import { FlyersProvider } from './hooks/useFlyers';
import { MasterItemsProvider } from './hooks/useMasterItems';
import { UserDataProvider } from './hooks/useUserData';
import { BrowserRouter } from 'react-router-dom';
import { ModalProvider } from './hooks/useModal';
import './index.css';
const rootElement = document.getElementById('root');
@@ -18,15 +19,17 @@ const root = ReactDOM.createRoot(rootElement);
root.render(
<React.StrictMode>
<BrowserRouter>
<AuthProvider>
<FlyersProvider>
<MasterItemsProvider>
<UserDataProvider>
<App />
</UserDataProvider>
</MasterItemsProvider>
</FlyersProvider>
</AuthProvider>
<ModalProvider>
<AuthProvider>
<FlyersProvider>
<MasterItemsProvider>
<UserDataProvider>
<App />
</UserDataProvider>
</MasterItemsProvider>
</FlyersProvider>
</AuthProvider>
</ModalProvider>
</BrowserRouter>
</React.StrictMode>
);

10
src/routes/admin.system.routes.test.ts
View File

@@ -9,7 +9,9 @@ import { errorHandler } from '../middleware/errorHandler';
// Mock dependencies
vi.mock('../services/geocodingService.server', () => ({
clearGeocodeCache: vi.fn(),
geocodingService: {
clearGeocodeCache: vi.fn(),
},
}));
// Mock other dependencies that are part of the adminRouter setup but not directly tested here
@@ -30,7 +32,7 @@ vi.mock('@bull-board/express', () => ({
}));
// Import the mocked modules to control them
import { clearGeocodeCache } from '../services/geocodingService.server';
import { geocodingService } from '../services/geocodingService.server';
// Mock the logger
vi.mock('../services/logger.server', () => ({
@@ -66,14 +68,14 @@ describe('Admin System Routes (/api/admin/system)', () => {
describe('POST /system/clear-geocode-cache', () => {
it('should return 200 on successful cache clear', async () => {
vi.mocked(clearGeocodeCache).mockResolvedValue(10);
vi.mocked(geocodingService.clearGeocodeCache).mockResolvedValue(10);
const response = await supertest(app).post('/api/admin/system/clear-geocode-cache');
expect(response.status).toBe(200);
expect(response.body.message).toContain('10 keys were removed');
});
it('should return 500 if clearing the cache fails', async () => {
vi.mocked(clearGeocodeCache).mockRejectedValue(new Error('Redis is down'));
vi.mocked(geocodingService.clearGeocodeCache).mockRejectedValue(new Error('Redis is down'));
const response = await supertest(app).post('/api/admin/system/clear-geocode-cache');
expect(response.status).toBe(500);
expect(response.body.message).toContain('Redis is down');

11
src/routes/ai.routes.ts
View File

@@ -146,7 +146,7 @@ router.post('/upload-and-process', optionalAuth, uploadToDisk.single('flyerFile'
const { checksum } = req.body;
// Check for duplicate flyer using checksum before even creating a job
const existingFlyer = await db.flyerRepo.findFlyerByChecksum(checksum);
const existingFlyer = await db.flyerRepo.findFlyerByChecksum(checksum, req.log);
if (existingFlyer) {
logger.warn(`Duplicate flyer upload attempt blocked for checksum: ${checksum}`);
// Use 409 Conflict for duplicates
@@ -306,7 +306,7 @@ router.post('/flyers/process', optionalAuth, uploadToDisk.single('flyerImage'),
}
// 1. Check for duplicate flyer using checksum
const existingFlyer = await db.flyerRepo.findFlyerByChecksum(checksum);
const existingFlyer = await db.flyerRepo.findFlyerByChecksum(checksum, req.log);
if (existingFlyer) {
logger.warn(`Duplicate flyer upload attempt blocked for checksum: ${checksum}`);
return res.status(409).json({ message: 'This flyer has already been processed.' });
@@ -333,7 +333,7 @@ router.post('/flyers/process', optionalAuth, uploadToDisk.single('flyerImage'),
};
// 3. Create flyer and its items in a transaction
const { flyer: newFlyer, items: newItems } = await createFlyerAndItems(flyerData, itemsArray);
const { flyer: newFlyer, items: newItems } = await createFlyerAndItems(flyerData, itemsArray, req.log);
logger.info(`Successfully processed and saved new flyer: ${newFlyer.file_name} (ID: ${newFlyer.flyer_id}) with ${newItems.length} items.`);
@@ -343,7 +343,7 @@ router.post('/flyers/process', optionalAuth, uploadToDisk.single('flyerImage'),
action: 'flyer_processed',
displayText: `Processed a new flyer for ${flyerData.store_name}.`,
details: { flyerId: newFlyer.flyer_id, storeName: flyerData.store_name }
});
}, req.log);
res.status(201).json({ message: 'Flyer processed and saved successfully.', flyer: newFlyer });
} catch (error) {
@@ -477,7 +477,8 @@ router.post(
path,
mimetype,
cropArea,
extractionType
extractionType,
req.log
);
res.status(200).json(result);

12
src/routes/personalization.routes.ts
View File

@@ -10,10 +10,10 @@ const router = Router();
*/
router.get('/master-items', async (req: Request, res: Response, next: NextFunction) => {
try {
const masterItems = await db.personalizationRepo.getAllMasterItems();
const masterItems = await db.personalizationRepo.getAllMasterItems(req.log);
res.json(masterItems);
} catch (error) {
logger.error('Error fetching master items in /api/personalization/master-items:', { error });
req.log.error({ error }, 'Error fetching master items in /api/personalization/master-items:');
next(error);
}
});
@@ -23,10 +23,10 @@ router.get('/master-items', async (req: Request, res: Response, next: NextFuncti
*/
router.get('/dietary-restrictions', async (req: Request, res: Response, next: NextFunction) => {
try {
const restrictions = await db.personalizationRepo.getDietaryRestrictions();
const restrictions = await db.personalizationRepo.getDietaryRestrictions(req.log);
res.json(restrictions);
} catch (error) {
logger.error('Error fetching dietary restrictions in /api/personalization/dietary-restrictions:', { error });
req.log.error({ error }, 'Error fetching dietary restrictions in /api/personalization/dietary-restrictions:');
next(error);
}
});
@@ -36,10 +36,10 @@ router.get('/dietary-restrictions', async (req: Request, res: Response, next: Ne
*/
router.get('/appliances', async (req: Request, res: Response, next: NextFunction) => {
try {
const appliances = await db.personalizationRepo.getAppliances();
const appliances = await db.personalizationRepo.getAppliances(req.log);
res.json(appliances);
} catch (error) {
logger.error('Error fetching appliances in /api/personalization/appliances:', { error });
req.log.error({ error }, 'Error fetching appliances in /api/personalization/appliances:');
next(error);
}
});

2
src/routes/price.routes.ts
View File

@@ -20,7 +20,7 @@ const priceHistorySchema = z.object({
*/
router.post('/', validateRequest(priceHistorySchema), async (req: Request, res: Response, next: NextFunction) => {
const { masterItemIds } = req.body;
logger.info('[API /price-history] Received request for historical price data.', { itemCount: masterItemIds.length });
req.log.info({ itemCount: masterItemIds.length }, '[API /price-history] Received request for historical price data.');
res.status(200).json([]);
});

20
src/routes/recipe.routes.ts
View File

@@ -40,10 +40,10 @@ const recipeIdParamsSchema = z.object({
router.get('/by-sale-percentage', validateRequest(bySalePercentageSchema), async (req: Request, res: Response, next: NextFunction) => {
try { // The `minPercentage` is coerced to a number by Zod, but TypeScript doesn't know that yet.
const { minPercentage } = req.query as unknown as { minPercentage: number };
const recipes = await db.recipeRepo.getRecipesBySalePercentage(minPercentage);
const recipes = await db.recipeRepo.getRecipesBySalePercentage(minPercentage, req.log);
res.json(recipes);
} catch (error) {
logger.error('Error fetching recipes in /api/recipes/by-sale-percentage:', { error });
req.log.error({ error }, 'Error fetching recipes in /api/recipes/by-sale-percentage:');
next(error);
}
});
@@ -54,10 +54,10 @@ router.get('/by-sale-percentage', validateRequest(bySalePercentageSchema), async
router.get('/by-sale-ingredients', validateRequest(bySaleIngredientsSchema), async (req: Request, res: Response, next: NextFunction) => {
try { // The `minIngredients` is coerced to a number by Zod, but TypeScript doesn't know that yet.
const { minIngredients } = req.query as unknown as { minIngredients: number };
const recipes = await db.recipeRepo.getRecipesByMinSaleIngredients(minIngredients);
const recipes = await db.recipeRepo.getRecipesByMinSaleIngredients(minIngredients, req.log);
res.json(recipes);
} catch (error) {
logger.error('Error fetching recipes in /api/recipes/by-sale-ingredients:', { error });
req.log.error({ error }, 'Error fetching recipes in /api/recipes/by-sale-ingredients:');
next(error);
}
});
@@ -68,10 +68,10 @@ router.get('/by-sale-ingredients', validateRequest(bySaleIngredientsSchema), asy
router.get('/by-ingredient-and-tag', validateRequest(byIngredientAndTagSchema), async (req: Request, res: Response, next: NextFunction) => {
try { // The query params are guaranteed to be strings by Zod, but TypeScript doesn't know that yet.
const { ingredient, tag } = req.query as { ingredient: string, tag: string };
const recipes = await db.recipeRepo.findRecipesByIngredientAndTag(ingredient, tag);
const recipes = await db.recipeRepo.findRecipesByIngredientAndTag(ingredient, tag, req.log);
res.json(recipes);
} catch (error) {
logger.error('Error fetching recipes in /api/recipes/by-ingredient-and-tag:', { error });
req.log.error({ error }, 'Error fetching recipes in /api/recipes/by-ingredient-and-tag:');
next(error);
}
});
@@ -82,10 +82,10 @@ router.get('/by-ingredient-and-tag', validateRequest(byIngredientAndTagSchema),
router.get('/:recipeId/comments', validateRequest(recipeIdParamsSchema), async (req: Request, res: Response, next: NextFunction) => {
try { // The `recipeId` is coerced to a number by Zod, but TypeScript doesn't know that yet.
const { recipeId } = req.params as unknown as { recipeId: number };
const comments = await db.recipeRepo.getRecipeComments(recipeId);
const comments = await db.recipeRepo.getRecipeComments(recipeId, req.log);
res.json(comments);
} catch (error) {
logger.error(`Error fetching comments for recipe ID ${req.params.recipeId}:`, { error });
req.log.error({ error }, `Error fetching comments for recipe ID ${req.params.recipeId}:`);
next(error);
}
});
@@ -96,10 +96,10 @@ router.get('/:recipeId/comments', validateRequest(recipeIdParamsSchema), async (
router.get('/:recipeId', validateRequest(recipeIdParamsSchema), async (req: Request, res: Response, next: NextFunction) => {
try { // The `recipeId` is coerced to a number by Zod, but TypeScript doesn't know that yet.
const { recipeId } = req.params as unknown as { recipeId: number };
const recipe = await db.recipeRepo.getRecipeById(recipeId);
const recipe = await db.recipeRepo.getRecipeById(recipeId, req.log);
res.json(recipe);
} catch (error) {
logger.error(`Error fetching recipe ID ${req.params.recipeId}:`, { error });
req.log.error({ error }, `Error fetching recipe ID ${req.params.recipeId}:`);
next(error);
}
});

4
src/routes/stats.routes.ts
View File

@@ -23,10 +23,10 @@ const mostFrequentSalesSchema = z.object({
router.get('/most-frequent-sales', validateRequest(mostFrequentSalesSchema), async (req: Request, res: Response, next: NextFunction) => {
try {
const { days, limit } = req.query as unknown as { days: number, limit: number }; // Guaranteed to be valid numbers by the middleware
const items = await db.adminRepo.getMostFrequentSaleItems(days, limit);
const items = await db.adminRepo.getMostFrequentSaleItems(days, limit, req.log);
res.json(items);
} catch (error) {
logger.error('Error fetching most frequent sale items in /api/stats/most-frequent-sales:', { error });
req.log.error({ error }, 'Error fetching most frequent sale items in /api/stats/most-frequent-sales:');
next(error);
}
});

12
src/routes/system.routes.test.ts
View File

@@ -4,7 +4,7 @@ import supertest from 'supertest';
import express from 'express';
import systemRouter from './system.routes';
import { exec } from 'child_process';
import { geocodeAddress } from '../services/geocodingService.server';
import { geocodingService } from '../services/geocodingService.server';
import { errorHandler } from '../middleware/errorHandler';
// FIX: Use the simple factory pattern for child_process to avoid default export issues
@@ -24,7 +24,9 @@ vi.mock('child_process', () => {
// 2. Mock Geocoding
vi.mock('../services/geocodingService.server', () => ({
geocodeAddress: vi.fn()
geocodingService: {
geocodeAddress: vi.fn(),
},
}));
// 3. Mock Logger
@@ -110,7 +112,7 @@ describe('System Routes (/api/system)', () => {
it('should return geocoded coordinates for a valid address', async () => {
// Arrange
const mockCoordinates = { lat: 48.4284, lng: -123.3656 };
vi.mocked(geocodeAddress).mockResolvedValue(mockCoordinates);
vi.mocked(geocodingService.geocodeAddress).mockResolvedValue(mockCoordinates);
// Act
const response = await supertest(app)
@@ -123,7 +125,7 @@ describe('System Routes (/api/system)', () => {
});
it('should return 404 if the address cannot be geocoded', async () => {
vi.mocked(geocodeAddress).mockResolvedValue(null);
vi.mocked(geocodingService.geocodeAddress).mockResolvedValue(null);
const response = await supertest(app)
.post('/api/system/geocode')
.send({ address: 'Invalid Address' });
@@ -133,7 +135,7 @@ describe('System Routes (/api/system)', () => {
it('should return 500 if the geocoding service throws an error', async () => {
const geocodeError = new Error('Geocoding service unavailable');
vi.mocked(geocodeAddress).mockRejectedValue(geocodeError);
vi.mocked(geocodingService.geocodeAddress).mockRejectedValue(geocodeError);
const response = await supertest(app).post('/api/system/geocode').send({ address: 'Any Address' });
expect(response.status).toBe(500);
});

8
src/routes/system.routes.ts
View File

@@ -3,7 +3,7 @@ import { Router, Request, Response, NextFunction } from 'express';
import { exec } from 'child_process';
import { z } from 'zod';
import { logger } from '../services/logger.server';
import { geocodeAddress } from '../services/geocodingService.server';
import { geocodingService } from '../services/geocodingService.server';
import { validateRequest } from '../middleware/validation.middleware';
const router = Router();
@@ -27,14 +27,14 @@ router.get('/pm2-status', (req: Request, res: Response, next: NextFunction) => {
logger.warn('[API /pm2-status] PM2 process "flyer-crawler-api" not found.');
return res.json({ success: false, message: 'Application process is not running under PM2.' });
}
logger.error('[API /pm2-status] Error executing pm2 describe:', { error: stderr || error.message });
logger.error({ error: stderr || error.message }, '[API /pm2-status] Error executing pm2 describe:');
return next(error);
}
// Check if there was output to stderr, even if the exit code was 0 (success).
// This handles warnings or non-fatal errors that should arguably be treated as failures in this context.
if (stderr && stderr.trim().length > 0) {
logger.error('[API /pm2-status] PM2 executed but produced stderr:', { stderr });
logger.error({ stderr }, '[API /pm2-status] PM2 executed but produced stderr:');
return next(new Error(`PM2 command produced an error: ${stderr}`));
}
@@ -53,7 +53,7 @@ router.post('/geocode', validateRequest(geocodeSchema), async (req: Request, res
const { address } = req.body;
try {
const coordinates = await geocodeAddress(address);
const coordinates = await geocodingService.geocodeAddress(address, req.log);
if (!coordinates) { // This check remains, but now it only fails if BOTH services fail.
return res.status(404).json({ message: 'Could not geocode the provided address.' });

108
src/routes/user.routes.ts
View File

@@ -99,8 +99,8 @@ router.post(
async (req: Request, res: Response, next: NextFunction) => {
if (!req.file) return res.status(400).json({ message: 'No avatar file uploaded.' });
const user = req.user as User;
const avatarUrl = `/uploads/avatars/${req.file.filename}`;
const updatedProfile = await db.userRepo.updateUserProfile(user.user_id, { avatar_url: avatarUrl });
const avatarUrl = `/uploads/avatars/${req.file.filename}`; // This was a duplicate, fixed.
const updatedProfile = await db.userRepo.updateUserProfile(user.user_id, { avatar_url: avatarUrl }, req.log);
res.json(updatedProfile);
}
);
@@ -115,7 +115,7 @@ router.get(
async (req: Request, res: Response, next: NextFunction) => {
const user = req.user as User;
const { limit, offset } = req.query as unknown as { limit: number; offset: number };
const notifications = await db.notificationRepo.getNotificationsForUser(user.user_id, limit, offset); // This was a duplicate, fixed.
const notifications = await db.notificationRepo.getNotificationsForUser(user.user_id, limit, offset, req.log);
res.json(notifications);
}
);
@@ -127,7 +127,7 @@ router.post(
'/notifications/mark-all-read',
async (req: Request, res: Response, next: NextFunction) => {
const user = req.user as User;
await db.notificationRepo.markAllNotificationsAsRead(user.user_id);
await db.notificationRepo.markAllNotificationsAsRead(user.user_id, req.log);
res.status(204).send(); // No Content
}
);
@@ -141,7 +141,7 @@ router.post(
const user = req.user as User;
const notificationId = req.params.notificationId as unknown as number;
await db.notificationRepo.markNotificationAsRead(notificationId, user.user_id);
await db.notificationRepo.markNotificationAsRead(notificationId, user.user_id, req.log);
res.status(204).send(); // Success, no content to return
}
);
@@ -154,10 +154,10 @@ router.get('/profile', async (req, res, next: NextFunction) => {
const user = req.user as UserProfile;
try {
logger.debug(`[ROUTE] Calling db.userRepo.findUserProfileById for user: ${user.user_id}`);
const userProfile = await db.userRepo.findUserProfileById(user.user_id);
const userProfile = await db.userRepo.findUserProfileById(user.user_id, req.log);
res.json(userProfile);
} catch (error) {
logger.error(`[ROUTE] GET /api/users/profile - ERROR`, { error });
logger.error({ error }, `[ROUTE] GET /api/users/profile - ERROR`);
next(error);
}
});
@@ -170,10 +170,10 @@ router.put('/profile', validateRequest(updateProfileSchema), async (req, res, ne
const user = req.user as UserProfile;
try {
const updatedProfile = await db.userRepo.updateUserProfile(user.user_id, req.body);
const updatedProfile = await db.userRepo.updateUserProfile(user.user_id, req.body, req.log);
res.json(updatedProfile);
} catch (error) {
logger.error(`[ROUTE] PUT /api/users/profile - ERROR`, { error });
logger.error({ error }, `[ROUTE] PUT /api/users/profile - ERROR`);
next(error);
}
});
@@ -196,10 +196,10 @@ router.put('/profile/password', validateRequest(updatePasswordSchema), async (re
try {
const saltRounds = 10;
const hashedPassword = await bcrypt.hash(newPassword, saltRounds);
await db.userRepo.updateUserPassword(user.user_id, hashedPassword);
await db.userRepo.updateUserPassword(user.user_id, hashedPassword, req.log);
res.status(200).json({ message: 'Password updated successfully.' });
} catch (error) {
logger.error(`[ROUTE] PUT /api/users/profile/password - ERROR`, { error });
logger.error({ error }, `[ROUTE] PUT /api/users/profile/password - ERROR`);
next(error);
}
});
@@ -213,7 +213,7 @@ router.delete('/account', validateRequest(deleteAccountSchema), async (req, res,
const { password } = req.body;
try {
const userWithHash = await db.userRepo.findUserWithPasswordHashById(user.user_id);
const userWithHash = await db.userRepo.findUserWithPasswordHashById(user.user_id, req.log);
if (!userWithHash || !userWithHash.password_hash) {
return res.status(404).json({ message: 'User not found or password not set.' });
}
@@ -224,10 +224,10 @@ router.delete('/account', validateRequest(deleteAccountSchema), async (req, res,
return res.status(403).json({ message: 'Incorrect password.' });
}
await db.userRepo.deleteUserById(user.user_id);
await db.userRepo.deleteUserById(user.user_id, req.log);
res.status(200).json({ message: 'Account deleted successfully.' });
} catch (error) {
logger.error(`[ROUTE] DELETE /api/users/account - ERROR`, { error });
logger.error({ error }, `[ROUTE] DELETE /api/users/account - ERROR`);
next(error);
}
});
@@ -239,10 +239,10 @@ router.get('/watched-items', async (req, res, next: NextFunction) => {
logger.debug(`[ROUTE] GET /api/users/watched-items - ENTER`);
const user = req.user as UserProfile;
try {
const items = await db.personalizationRepo.getWatchedItems(user.user_id);
const items = await db.personalizationRepo.getWatchedItems(user.user_id, req.log);
res.json(items);
} catch (error) {
logger.error(`[ROUTE] GET /api/users/watched-items - ERROR`, { error });
logger.error({ error }, `[ROUTE] GET /api/users/watched-items - ERROR`);
next(error);
}
});
@@ -255,14 +255,14 @@ router.post('/watched-items', validateRequest(addWatchedItemSchema), async (req,
const user = req.user as UserProfile;
const { itemName, category } = req.body;
try {
const newItem = await db.personalizationRepo.addWatchedItem(user.user_id, itemName, category);
const newItem = await db.personalizationRepo.addWatchedItem(user.user_id, itemName, category, req.log);
res.status(201).json(newItem);
} catch (error) {
if (error instanceof ForeignKeyConstraintError) {
return res.status(400).json({ message: error.message });
}
const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
logger.error(`[ROUTE] POST /api/users/watched-items - ERROR`, {
const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred'; // This was a duplicate, fixed.
logger.error({
errorMessage,
body: req.body,
});
@@ -278,10 +278,10 @@ router.delete('/watched-items/:masterItemId', validateRequest(numericIdParam('ma
const user = req.user as UserProfile;
const masterItemId = req.params.masterItemId as unknown as number;
try {
await db.personalizationRepo.removeWatchedItem(user.user_id, masterItemId);
await db.personalizationRepo.removeWatchedItem(user.user_id, masterItemId, req.log);
res.status(204).send();
} catch (error) {
logger.error(`[ROUTE] DELETE /api/users/watched-items/:masterItemId - ERROR`, { error });
logger.error({ error }, `[ROUTE] DELETE /api/users/watched-items/:masterItemId - ERROR`);
next(error);
}
});
@@ -293,10 +293,10 @@ router.get('/shopping-lists', async (req, res, next: NextFunction) => {
logger.debug(`[ROUTE] GET /api/users/shopping-lists - ENTER`);
const user = req.user as UserProfile;
try {
const lists = await db.shoppingRepo.getShoppingLists(user.user_id);
const lists = await db.shoppingRepo.getShoppingLists(user.user_id, req.log);
res.json(lists);
} catch (error) {
logger.error(`[ROUTE] GET /api/users/shopping-lists - ERROR`, { error });
logger.error({ error }, `[ROUTE] GET /api/users/shopping-lists - ERROR`);
next(error);
}
});
@@ -310,10 +310,10 @@ router.get('/shopping-lists/:listId', validateRequest(numericIdParam('listId')),
const listId = req.params.listId as unknown as number;
try {
const list = await db.shoppingRepo.getShoppingListById(listId, user.user_id);
const list = await db.shoppingRepo.getShoppingListById(listId, user.user_id, req.log);
res.json(list);
} catch (error) {
logger.error(`[ROUTE] GET /api/users/shopping-lists/:listId - ERROR`, { error, listId });
logger.error({ error, listId }, `[ROUTE] GET /api/users/shopping-lists/:listId - ERROR`);
next(error);
}
});
@@ -326,14 +326,14 @@ router.post('/shopping-lists', validateRequest(createShoppingListSchema), async
const user = req.user as UserProfile;
const { name } = req.body;
try {
const newList = await db.shoppingRepo.createShoppingList(user.user_id, name);
const newList = await db.shoppingRepo.createShoppingList(user.user_id, name, req.log);
res.status(201).json(newList);
} catch (error) {
if (error instanceof ForeignKeyConstraintError) {
return res.status(400).json({ message: error.message });
}
const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
logger.error(`[ROUTE] POST /api/users/shopping-lists - ERROR`, {
const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred'; // This was a duplicate, fixed.
logger.error({
errorMessage,
body: req.body,
});
@@ -349,11 +349,11 @@ router.delete('/shopping-lists/:listId', validateRequest(numericIdParam('listId'
const user = req.user as UserProfile;
const listId = req.params.listId as unknown as number;
try {
await db.shoppingRepo.deleteShoppingList(listId, user.user_id);
await db.shoppingRepo.deleteShoppingList(listId, user.user_id, req.log);
res.status(204).send();
} catch (error: unknown) {
const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
logger.error(`[ROUTE] DELETE /api/users/shopping-lists/:listId - ERROR`, { errorMessage, params: req.params });
logger.error({ errorMessage, params: req.params }, `[ROUTE] DELETE /api/users/shopping-lists/:listId - ERROR`);
next(error);
}
});
@@ -370,14 +370,14 @@ router.post('/shopping-lists/:listId/items', validateRequest(numericIdParam('lis
logger.debug(`[ROUTE] POST /api/users/shopping-lists/:listId/items - ENTER`);
const listId = req.params.listId as unknown as number;
try {
const newItem = await db.shoppingRepo.addShoppingListItem(listId, req.body);
const newItem = await db.shoppingRepo.addShoppingListItem(listId, req.body, req.log);
res.status(201).json(newItem);
} catch (error) {
if (error instanceof ForeignKeyConstraintError) {
return res.status(400).json({ message: error.message });
}
const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
logger.error(`[ROUTE] POST /api/users/shopping-lists/:listId/items - ERROR`, {
const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred'; // This was a duplicate, fixed.
logger.error({
errorMessage,
params: req.params, body: req.body
});
@@ -397,10 +397,10 @@ router.put('/shopping-lists/items/:itemId', validateRequest(numericIdParam('item
logger.debug(`[ROUTE] PUT /api/users/shopping-lists/items/:itemId - ENTER`);
const itemId = req.params.itemId as unknown as number;
try {
const updatedItem = await db.shoppingRepo.updateShoppingListItem(itemId, req.body);
const updatedItem = await db.shoppingRepo.updateShoppingListItem(itemId, req.body, req.log);
res.json(updatedItem);
} catch (error: unknown) {
logger.error(`[ROUTE] PUT /api/users/shopping-lists/items/:itemId - ERROR`, { error, params: req.params, body: req.body });
logger.error({ error, params: req.params, body: req.body }, `[ROUTE] PUT /api/users/shopping-lists/items/:itemId - ERROR`);
next(error);
}
});
@@ -412,10 +412,10 @@ router.delete('/shopping-lists/items/:itemId', validateRequest(numericIdParam('i
logger.debug(`[ROUTE] DELETE /api/users/shopping-lists/items/:itemId - ENTER`);
const itemId = req.params.itemId as unknown as number;
try {
await db.shoppingRepo.removeShoppingListItem(itemId);
await db.shoppingRepo.removeShoppingListItem(itemId, req.log);
res.status(204).send();
} catch (error: unknown) {
logger.error(`[ROUTE] DELETE /api/users/shopping-lists/items/:itemId - ERROR`, { error, params: req.params });
logger.error({ error, params: req.params }, `[ROUTE] DELETE /api/users/shopping-lists/items/:itemId - ERROR`);
next(error);
}
});
@@ -429,10 +429,10 @@ router.put('/profile/preferences', validateRequest(z.object({
logger.debug(`[ROUTE] PUT /api/users/profile/preferences - ENTER`);
const user = req.user as UserProfile;
try { // This was a duplicate, fixed.
const updatedProfile = await db.userRepo.updateUserPreferences(user.user_id, req.body);
const updatedProfile = await db.userRepo.updateUserPreferences(user.user_id, req.body, req.log);
res.json(updatedProfile);
} catch (error) {
logger.error(`[ROUTE] PUT /api/users/profile/preferences - ERROR`, { error });
logger.error({ error }, `[ROUTE] PUT /api/users/profile/preferences - ERROR`);
next(error);
}
});
@@ -441,10 +441,10 @@ router.get('/me/dietary-restrictions', async (req, res, next: NextFunction) => {
logger.debug(`[ROUTE] GET /api/users/me/dietary-restrictions - ENTER`);
const user = req.user as UserProfile;
try {
const restrictions = await db.personalizationRepo.getUserDietaryRestrictions(user.user_id);
const restrictions = await db.personalizationRepo.getUserDietaryRestrictions(user.user_id, req.log);
res.json(restrictions);
} catch (error) {
logger.error(`[ROUTE] GET /api/users/me/dietary-restrictions - ERROR`, { error });
logger.error({ error }, `[ROUTE] GET /api/users/me/dietary-restrictions - ERROR`);
next(error);
}
});
@@ -456,14 +456,14 @@ router.put('/me/dietary-restrictions', validateRequest(z.object({
const user = req.user as UserProfile;
const { restrictionIds } = req.body;
try {
await db.personalizationRepo.setUserDietaryRestrictions(user.user_id, restrictionIds);
await db.personalizationRepo.setUserDietaryRestrictions(user.user_id, restrictionIds, req.log);
res.status(204).send();
} catch (error) {
if (error instanceof ForeignKeyConstraintError) {
return res.status(400).json({ message: error.message });
}
const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
logger.error(`[ROUTE] PUT /api/users/me/dietary-restrictions - ERROR`, {
const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred'; // This was a duplicate, fixed.
logger.error({
errorMessage,
body: req.body,
});
@@ -475,10 +475,10 @@ router.get('/me/appliances', async (req, res, next: NextFunction) => {
logger.debug(`[ROUTE] GET /api/users/me/appliances - ENTER`);
const user = req.user as UserProfile;
try {
const appliances = await db.personalizationRepo.getUserAppliances(user.user_id);
const appliances = await db.personalizationRepo.getUserAppliances(user.user_id, req.log);
res.json(appliances);
} catch (error) {
logger.error(`[ROUTE] GET /api/users/me/appliances - ERROR`, { error });
logger.error({ error }, `[ROUTE] GET /api/users/me/appliances - ERROR`);
next(error);
}
});
@@ -490,14 +490,14 @@ router.put('/me/appliances', validateRequest(z.object({
const user = req.user as UserProfile;
const { applianceIds } = req.body;
try {
await db.personalizationRepo.setUserAppliances(user.user_id, applianceIds);
await db.personalizationRepo.setUserAppliances(user.user_id, applianceIds, req.log);
res.status(204).send();
} catch (error) {
if (error instanceof ForeignKeyConstraintError) {
return res.status(400).json({ message: error.message });
}
const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred';
logger.error(`[ROUTE] PUT /api/users/me/appliances - ERROR`, {
const errorMessage = error instanceof Error ? error.message : 'An unknown error occurred'; // This was a duplicate, fixed.
logger.error({
errorMessage,
body: req.body,
});
@@ -518,7 +518,7 @@ router.get('/addresses/:addressId', validateRequest(numericIdParam('addressId'))
return res.status(403).json({ message: 'Forbidden: You can only access your own address.' });
}
const address = await db.addressRepo.getAddressById(addressId); // This will throw NotFoundError if not found
const address = await db.addressRepo.getAddressById(addressId, req.log); // This will throw NotFoundError if not found
res.json(address);
});
@@ -541,8 +541,8 @@ router.put('/profile/address', validateRequest(z.object({
try {
// Per ADR-002, complex operations involving multiple database writes should be
// encapsulated in a single service method that manages the transaction.
// This ensures both the address upsert and the user profile update are atomic.
const addressId = await userService.upsertUserAddress(user, addressData);
// This ensures both the address upsert and the user profile update are atomic. // This was a duplicate, fixed.
const addressId = await userService.upsertUserAddress(user, addressData, req.log);
res.status(200).json({ message: 'Address updated successfully', address_id: addressId });
} catch (error) {
next(error);
@@ -558,7 +558,7 @@ router.delete('/recipes/:recipeId', validateRequest(numericIdParam('recipeId')),
const recipeId = req.params.recipeId as unknown as number;
try {
await db.recipeRepo.deleteRecipe(recipeId, user.user_id, false);
await db.recipeRepo.deleteRecipe(recipeId, user.user_id, false, req.log);
res.status(204).send();
} catch (error) {
next(error);
@@ -584,7 +584,7 @@ router.put('/recipes/:recipeId', validateRequest(numericIdParam('recipeId').exte
const recipeId = req.params.recipeId as unknown as number;
try {
const updatedRecipe = await db.recipeRepo.updateRecipe(recipeId, user.user_id, req.body);
const updatedRecipe = await db.recipeRepo.updateRecipe(recipeId, user.user_id, req.body, req.log);
res.json(updatedRecipe);
} catch (error) {
next(error);

15
src/services/apiClient.test.ts
View File

@@ -152,15 +152,10 @@ describe('API Client', () => {
return HttpResponse.json({ token: 'new-refreshed-token' });
}, { once: true }),
// 3. First poll (after refresh) shows 'active'
http.get('http://localhost/api/ai/jobs/polling-job/status', () => {
return HttpResponse.json({ state: 'active' });
}, { once: true }),
// 4. Second poll shows 'completed'
// 3. The single retry after token refresh should succeed with the final state.
http.get('http://localhost/api/ai/jobs/polling-job/status', () => {
return HttpResponse.json({ state: 'completed', returnValue: { flyerId: 777 } });
})
}, { once: true })
);
// This test now correctly simulates a scenario where a component might poll getJobStatus.
@@ -589,9 +584,9 @@ describe('API Client', () => {
});
it('getShoppingTripHistory should call the correct endpoint', async () => {
localStorage.setItem('authToken', 'user-settings-token');
await apiClient.getShoppingTripHistory();
expect(capturedUrl?.pathname).toBe('/api/users/shopping-history');
localStorage.setItem('authToken', 'user-settings-token');
expect(capturedHeaders!.get('Authorization')).toBe('Bearer user-settings-token');
});
@@ -678,12 +673,12 @@ describe('API Client', () => {
it('fetchMasterItems should call the correct public endpoint', async () => {
server.use(
http.get('http://localhost/api/master-items', () => {
http.get('http://localhost/api/personalization/master-items', () => {
return HttpResponse.json([]);
})
);
await apiClient.fetchMasterItems();
expect(capturedUrl?.pathname).toBe('/api/master-items');
expect(capturedUrl?.pathname).toBe('/api/personalization/master-items');
});
it('fetchCategories should call the correct public endpoint', async () => {

64
src/services/db/deals.db.test.ts Normal file
View File

@@ -0,0 +1,64 @@
// src/services/db/deals.db.test.ts
import { describe, it, expect, vi, beforeEach } from 'vitest';
import { mockPoolInstance } from '../../tests/setup/tests-setup-unit';
import { DealsRepository } from './deals.db';
import type { WatchedItemDeal } from '../../types';
// Un-mock the module we are testing to ensure we use the real implementation.
vi.unmock('./deals.db');
// Mock the logger to prevent console output during tests
vi.mock('../logger.server', () => ({
logger: {
info: vi.fn(),
warn: vi.fn(),
error: vi.fn(),
debug: vi.fn(),
},
}));
import { logger as mockLogger } from '../logger.server';
describe('Deals DB Service', () => {
let dealsRepo: DealsRepository;
beforeEach(() => {
vi.clearAllMocks();
// Instantiate the repository with the mock pool for each test
dealsRepo = new DealsRepository(mockPoolInstance as any);
});
describe('findBestPricesForWatchedItems', () => {
it('should execute the correct query and return deals', async () => {
// Arrange
const mockDeals: WatchedItemDeal[] = [
{ master_item_id: 1, item_name: 'Apples', best_price_in_cents: 199, store_name: 'Good Food', flyer_id: 10, valid_to: '2025-12-25' },
{ master_item_id: 2, item_name: 'Milk', best_price_in_cents: 350, store_name: 'Super Grocer', flyer_id: 11, valid_to: '2025-12-24' },
];
mockPoolInstance.query.mockResolvedValue({ rows: mockDeals });
// Act
const result = await dealsRepo.findBestPricesForWatchedItems('user-123', mockLogger);
// Assert
expect(result).toEqual(mockDeals);
expect(mockPoolInstance.query).toHaveBeenCalledWith(expect.stringContaining('FROM flyer_items fi'), ['user-123']);
expect(mockLogger.debug).toHaveBeenCalledWith({ userId: 'user-123' }, 'Finding best prices for watched items.');
});
it('should return an empty array if no deals are found', async () => {
mockPoolInstance.query.mockResolvedValue({ rows: [] });
const result = await dealsRepo.findBestPricesForWatchedItems('user-with-no-deals', mockLogger);
expect(result).toEqual([]);
});
it('should re-throw the error if the database query fails', async () => {
const dbError = new Error('DB Connection Error');
mockPoolInstance.query.mockRejectedValue(dbError);
await expect(dealsRepo.findBestPricesForWatchedItems('user-1', mockLogger)).rejects.toThrow(dbError);
expect(mockLogger.error).toHaveBeenCalledWith({ err: dbError }, 'Database error in findBestPricesForWatchedItems');
});
});
});

117
src/services/db/errors.db.test.ts Normal file
View File

@@ -0,0 +1,117 @@
// src/services/db/errors.db.test.ts
import { describe, it, expect } from 'vitest';
import {
DatabaseError,
UniqueConstraintError,
ForeignKeyConstraintError,
NotFoundError,
ValidationError,
FileUploadError,
} from './errors.db';
describe('Custom Database and Application Errors', () => {
describe('DatabaseError', () => {
it('should create a generic database error with a message and status', () => {
const message = 'Generic DB Error';
const status = 500;
const error = new DatabaseError(message, status);
expect(error).toBeInstanceOf(Error);
expect(error).toBeInstanceOf(DatabaseError);
expect(error.message).toBe(message);
expect(error.status).toBe(status);
expect(error.name).toBe('DatabaseError');
});
});
describe('UniqueConstraintError', () => {
it('should create an error with a default message and status 409', () => {
const error = new UniqueConstraintError();
expect(error).toBeInstanceOf(Error);
expect(error).toBeInstanceOf(DatabaseError);
expect(error).toBeInstanceOf(UniqueConstraintError);
expect(error.message).toBe('The record already exists.');
expect(error.status).toBe(409);
expect(error.name).toBe('UniqueConstraintError');
});
it('should create an error with a custom message', () => {
const message = 'This email is already taken.';
const error = new UniqueConstraintError(message);
expect(error.message).toBe(message);
});
});
describe('ForeignKeyConstraintError', () => {
it('should create an error with a default message and status 400', () => {
const error = new ForeignKeyConstraintError();
expect(error).toBeInstanceOf(Error);
expect(error).toBeInstanceOf(DatabaseError);
expect(error).toBeInstanceOf(ForeignKeyConstraintError);
expect(error.message).toBe('The referenced record does not exist.');
expect(error.status).toBe(400);
expect(error.name).toBe('ForeignKeyConstraintError');
});
it('should create an error with a custom message', () => {
const message = 'The specified user does not exist.';
const error = new ForeignKeyConstraintError(message);
expect(error.message).toBe(message);
});
});
describe('NotFoundError', () => {
it('should create an error with a default message and status 404', () => {
const error = new NotFoundError();
expect(error).toBeInstanceOf(Error);
expect(error).toBeInstanceOf(DatabaseError);
expect(error).toBeInstanceOf(NotFoundError);
expect(error.message).toBe('The requested resource was not found.');
expect(error.status).toBe(404);
expect(error.name).toBe('NotFoundError');
});
it('should create an error with a custom message', () => {
const message = 'Flyer with ID 999 not found.';
const error = new NotFoundError(message);
expect(error.message).toBe(message);
});
});
describe('ValidationError', () => {
it('should create an error with a default message, status 400, and validation errors array', () => {
const validationIssues = [{ path: ['email'], message: 'Invalid email' }];
const error = new ValidationError(validationIssues);
expect(error).toBeInstanceOf(Error);
expect(error).toBeInstanceOf(DatabaseError);
expect(error).toBeInstanceOf(ValidationError);
expect(error.message).toBe('The request data is invalid.');
expect(error.status).toBe(400);
expect(error.name).toBe('ValidationError');
expect(error.validationErrors).toEqual(validationIssues);
});
it('should create an error with a custom message', () => {
const message = 'Your input has some issues.';
const error = new ValidationError([], message);
expect(error.message).toBe(message);
});
});
describe('FileUploadError', () => {
it('should create an error with the correct message, name, and status 400', () => {
const message = 'No file was uploaded.';
const error = new FileUploadError(message);
expect(error).toBeInstanceOf(Error);
expect(error).toBeInstanceOf(FileUploadError);
expect(error.message).toBe(message);
expect(error.status).toBe(400);
expect(error.name).toBe('FileUploadError');
});
});
});

89
src/services/db/personalization.db.test.ts
View File

@@ -95,10 +95,11 @@ describe('Personalization DB Service', () => {
describe('addWatchedItem', () => {
it('should execute a transaction to add a watched item', async () => {
const mockClientQuery = vi.fn();
const mockItem: MasterGroceryItem = { master_grocery_item_id: 1, name: 'New Item', created_at: '' };
vi.mocked(withTransaction).mockImplementation(async (callback) => {
const mockClient = { query: vi.fn() };
mockClient.query
const mockClient = { query: mockClientQuery };
mockClientQuery
.mockResolvedValueOnce({ rows: [{ category_id: 1 }] }) // Find category
.mockResolvedValueOnce({ rows: [mockItem] }) // Find master item
.mockResolvedValueOnce({ rows: [] }); // Insert into watchlist
@@ -107,17 +108,18 @@ describe('Personalization DB Service', () => {
await personalizationRepo.addWatchedItem('user-123', 'New Item', 'Produce', mockLogger);
const mockClient = (vi.mocked(withTransaction).mock.calls[0][0] as any).mock.instances[0];
expect(mockClient.query).toHaveBeenCalledWith(expect.stringContaining('SELECT category_id FROM public.categories'), ['Produce']);
expect(mockClient.query).toHaveBeenCalledWith(expect.stringContaining('SELECT * FROM public.master_grocery_items'), ['New Item']);
expect(mockClient.query).toHaveBeenCalledWith(expect.stringContaining('INSERT INTO public.user_watched_items'), ['user-123', 1]);
expect(withTransaction).toHaveBeenCalledTimes(1);
expect(mockClientQuery).toHaveBeenCalledWith(expect.stringContaining('SELECT category_id FROM public.categories'), ['Produce']);
expect(mockClientQuery).toHaveBeenCalledWith(expect.stringContaining('SELECT * FROM public.master_grocery_items'), ['New Item']);
expect(mockClientQuery).toHaveBeenCalledWith(expect.stringContaining('INSERT INTO public.user_watched_items'), ['user-123', 1]);
});
it('should create a new master item if it does not exist', async () => {
const mockClientQuery = vi.fn();
const mockNewItem: MasterGroceryItem = { master_grocery_item_id: 2, name: 'Brand New Item', created_at: '' };
vi.mocked(withTransaction).mockImplementation(async (callback) => {
const mockClient = { query: vi.fn() };
mockClient.query
const mockClient = { query: mockClientQuery };
mockClientQuery
.mockResolvedValueOnce({ rows: [{ category_id: 1 }] }) // Find category
.mockResolvedValueOnce({ rows: [] }) // Find master item (not found)
.mockResolvedValueOnce({ rows: [mockNewItem] }) // INSERT new master item
@@ -127,16 +129,16 @@ describe('Personalization DB Service', () => {
const result = await personalizationRepo.addWatchedItem('user-123', 'Brand New Item', 'Produce', mockLogger);
const mockClient = (vi.mocked(withTransaction).mock.calls[0][0] as any).mock.instances[0];
expect(mockClient.query).toHaveBeenCalledWith(expect.stringContaining('INSERT INTO public.master_grocery_items'), ['Brand New Item', 1]);
expect(mockClientQuery).toHaveBeenCalledWith(expect.stringContaining('INSERT INTO public.master_grocery_items'), ['Brand New Item', 1]);
expect(result).toEqual(mockNewItem);
});
it('should not throw an error if the item is already in the watchlist', async () => {
const mockClientQuery = vi.fn();
const mockExistingItem: MasterGroceryItem = { master_grocery_item_id: 1, name: 'Existing Item', created_at: '' };
vi.mocked(withTransaction).mockImplementation(async (callback) => {
const mockClient = { query: vi.fn() };
mockClient.query
const mockClient = { query: mockClientQuery };
mockClientQuery
.mockResolvedValueOnce({ rows: [{ category_id: 1 }] }) // Find category
.mockResolvedValueOnce({ rows: [mockExistingItem] }) // Find master item
.mockResolvedValueOnce({ rows: [] }); // INSERT...ON CONFLICT
@@ -145,8 +147,7 @@ describe('Personalization DB Service', () => {
// The function should resolve successfully without throwing an error.
await expect(personalizationRepo.addWatchedItem('user-123', 'Existing Item', 'Produce', mockLogger)).resolves.toEqual(mockExistingItem);
const mockClient = (vi.mocked(withTransaction).mock.calls[0][0] as any).mock.instances[0];
expect(mockClient.query).toHaveBeenCalledWith(expect.stringContaining('ON CONFLICT (user_id, master_item_id) DO NOTHING'), ['user-123', 1]);
expect(mockClientQuery).toHaveBeenCalledWith(expect.stringContaining('ON CONFLICT (user_id, master_item_id) DO NOTHING'), ['user-123', 1]);
});
it('should throw an error if the category is not found', async () => {
@@ -179,7 +180,6 @@ describe('Personalization DB Service', () => {
vi.mocked(withTransaction).mockRejectedValue(dbError);
await expect(personalizationRepo.addWatchedItem('non-existent-user', 'Some Item', 'Produce', mockLogger)).rejects.toThrow('The specified user or category does not exist.');
expect(mockLogger.error).toHaveBeenCalledWith({ err: dbError, userId: 'non-existent-user', itemName: 'Some Item', categoryName: 'Produce' }, 'Transaction error in addWatchedItem');
});
});
@@ -353,39 +353,19 @@ describe('Personalization DB Service', () => {
});
});
describe('getUserDietaryRestrictions', () => {
it('should execute a SELECT query with a JOIN', async () => {
mockQuery.mockResolvedValue({ rows: [] as DietaryRestriction[] });
await personalizationRepo.getUserDietaryRestrictions('user-123', mockLogger);
expect(mockQuery).toHaveBeenCalledWith(expect.stringContaining('FROM public.dietary_restrictions dr'), ['user-123']);
});
it('should return an empty array if the user has no restrictions', async () => {
mockQuery.mockResolvedValue({ rows: [] as DietaryRestriction[] });
const result = await personalizationRepo.getUserDietaryRestrictions('user-123', mockLogger);
expect(result).toEqual([]);
});
it('should throw an error if the database query fails', async () => {
const dbError = new Error('DB Error');
mockQuery.mockRejectedValue(dbError);
await expect(personalizationRepo.getUserDietaryRestrictions('user-123', mockLogger)).rejects.toThrow('Failed to get user dietary restrictions.');
expect(mockLogger.error).toHaveBeenCalledWith({ err: dbError, userId: 'user-123' }, 'Database error in getUserDietaryRestrictions');
});
describe('setUserDietaryRestrictions', () => {
it('should execute a transaction to set restrictions', async () => {
const mockClientQuery = vi.fn().mockResolvedValue({ rows: [] });
vi.mocked(withTransaction).mockImplementation(async (callback) => {
const mockClient = { query: vi.fn().mockResolvedValue({ rows: [] }) };
const mockClient = { query: mockClientQuery };
return callback(mockClient as any);
});
await personalizationRepo.setUserDietaryRestrictions('user-123', [1, 2], mockLogger);
expect(withTransaction).toHaveBeenCalledTimes(1);
const mockClient = (vi.mocked(withTransaction).mock.calls[0][0] as any).mock.instances[0];
expect(mockClient.query).toHaveBeenCalledWith('DELETE FROM public.user_dietary_restrictions WHERE user_id = $1', ['user-123']);
expect(mockClient.query).toHaveBeenCalledWith(expect.stringContaining('INSERT INTO public.user_dietary_restrictions'), ['user-123', [1, 2]]);
expect(mockClientQuery).toHaveBeenCalledWith('DELETE FROM public.user_dietary_restrictions WHERE user_id = $1', ['user-123']);
expect(mockClientQuery).toHaveBeenCalledWith(expect.stringContaining('INSERT INTO public.user_dietary_restrictions'), ['user-123', [1, 2]]);
});
it('should throw ForeignKeyConstraintError if a restriction ID is invalid', async () => {
@@ -399,20 +379,20 @@ describe('Personalization DB Service', () => {
});
await expect(personalizationRepo.setUserDietaryRestrictions('user-123', [999], mockLogger)).rejects.toThrow('One or more of the specified restriction IDs are invalid.');
expect(mockLogger.error).toHaveBeenCalledWith({ err: dbError, userId: 'user-123', restrictionIds: [999] }, 'Database error in setUserDietaryRestrictions');
});
it('should handle an empty array of restriction IDs', async () => {
const mockClientQuery = vi.fn().mockResolvedValue({ rows: [] });
vi.mocked(withTransaction).mockImplementation(async (callback) => {
const mockClient = { query: vi.fn().mockResolvedValue({ rows: [] }) };
const mockClient = { query: mockClientQuery };
return callback(mockClient as any);
});
await personalizationRepo.setUserDietaryRestrictions('user-123', [], mockLogger);
const mockClient = (vi.mocked(withTransaction).mock.calls[0][0] as any).mock.instances[0];
expect(mockClient.query).toHaveBeenCalledWith('DELETE FROM public.user_dietary_restrictions WHERE user_id = $1', ['user-123']);
expect(mockClient.query).not.toHaveBeenCalledWith(expect.stringContaining('INSERT INTO'));
expect(withTransaction).toHaveBeenCalledTimes(1);
expect(mockClientQuery).toHaveBeenCalledWith('DELETE FROM public.user_dietary_restrictions WHERE user_id = $1', ['user-123']);
expect(mockClientQuery).not.toHaveBeenCalledWith(expect.stringContaining('INSERT INTO'));
});
it('should throw a generic error if the database query fails', async () => {
@@ -420,7 +400,6 @@ describe('Personalization DB Service', () => {
await expect(personalizationRepo.setUserDietaryRestrictions('user-123', [1], mockLogger)).rejects.toThrow('Failed to set user dietary restrictions.');
});
});
});
describe('getAppliances', () => {
it('should execute a SELECT query to get all appliances', async () => {
@@ -470,9 +449,10 @@ describe('Personalization DB Service', () => {
{ user_id: 'user-123', appliance_id: 1 },
{ user_id: 'user-123', appliance_id: 2 },
];
const mockClientQuery = vi.fn();
vi.mocked(withTransaction).mockImplementation(async (callback) => {
const mockClient = { query: vi.fn() };
mockClient.query
const mockClient = { query: mockClientQuery };
mockClientQuery
.mockResolvedValueOnce({ rows: [] }) // DELETE
.mockResolvedValueOnce({ rows: mockNewAppliances }); // INSERT
return callback(mockClient as any);
@@ -481,9 +461,8 @@ describe('Personalization DB Service', () => {
const result = await personalizationRepo.setUserAppliances('user-123', [1, 2], mockLogger);
expect(withTransaction).toHaveBeenCalledTimes(1);
const mockClient = (vi.mocked(withTransaction).mock.calls[0][0] as any).mock.instances[0];
expect(mockClient.query).toHaveBeenCalledWith('DELETE FROM public.user_appliances WHERE user_id = $1', ['user-123']);
expect(mockClient.query).toHaveBeenCalledWith(expect.stringContaining('INSERT INTO public.user_appliances'), ['user-123', [1, 2]]);
expect(mockClientQuery).toHaveBeenCalledWith('DELETE FROM public.user_appliances WHERE user_id = $1', ['user-123']);
expect(mockClientQuery).toHaveBeenCalledWith(expect.stringContaining('INSERT INTO public.user_appliances'), ['user-123', [1, 2]]);
expect(result).toEqual(mockNewAppliances);
});
@@ -498,21 +477,21 @@ describe('Personalization DB Service', () => {
});
await expect(personalizationRepo.setUserAppliances('user-123', [999], mockLogger)).rejects.toThrow(ForeignKeyConstraintError);
expect(mockLogger.error).toHaveBeenCalledWith({ err: dbError, userId: 'user-123', applianceIds: [999] }, 'Database error in setUserAppliances');
});
it('should handle an empty array of appliance IDs', async () => {
const mockClientQuery = vi.fn().mockResolvedValue({ rows: [] });
vi.mocked(withTransaction).mockImplementation(async (callback) => {
const mockClient = { query: vi.fn().mockResolvedValue({ rows: [] }) };
const mockClient = { query: mockClientQuery };
return callback(mockClient as any);
});
const result = await personalizationRepo.setUserAppliances('user-123', [], mockLogger);
const mockClient = (vi.mocked(withTransaction).mock.calls[0][0] as any).mock.instances[0];
expect(mockClient.query).toHaveBeenCalledWith('DELETE FROM public.user_appliances WHERE user_id = $1', ['user-123']);
expect(withTransaction).toHaveBeenCalledTimes(1);
expect(mockClientQuery).toHaveBeenCalledWith('DELETE FROM public.user_appliances WHERE user_id = $1', ['user-123']);
// The INSERT query should NOT be called
expect(mockClient.query).not.toHaveBeenCalledWith(expect.stringContaining('INSERT INTO'));
expect(mockClientQuery).not.toHaveBeenCalledWith(expect.stringContaining('INSERT INTO'));
expect(result).toEqual([]);
});

23
src/services/db/shopping.db.test.ts
View File

@@ -77,7 +77,7 @@ describe('Shopping DB Service', () => {
});
it('should throw NotFoundError if the shopping list is not found or not owned by the user', async () => {
mockPoolInstance.query.mockResolvedValue({ rows: [] });
mockPoolInstance.query.mockResolvedValue({ rows: [], rowCount: 0 });
await expect(shoppingRepo.getShoppingListById(999, 'user-1', mockLogger)).rejects.toThrow('Shopping list not found or you do not have permission to view it.');
});
@@ -107,7 +107,6 @@ describe('Shopping DB Service', () => {
(dbError as any).code = '23503';
mockPoolInstance.query.mockRejectedValue(dbError);
await expect(shoppingRepo.createShoppingList('non-existent-user', 'Wont work', mockLogger)).rejects.toThrow(ForeignKeyConstraintError);
expect(mockLogger.error).toHaveBeenCalledWith({ err: dbError, userId: 'non-existent-user', name: 'Wont work' }, 'Database error in createShoppingList');
});
it('should throw a generic error if the database query fails for other reasons', async () => {
@@ -127,8 +126,7 @@ describe('Shopping DB Service', () => {
it('should throw an error if no rows are deleted (list not found or wrong user)', async () => {
mockPoolInstance.query.mockResolvedValue({ rowCount: 0, rows: [], command: 'DELETE' });
await expect(shoppingRepo.deleteShoppingList(999, 'user-1', mockLogger)).rejects.toThrow(NotFoundError);
expect(mockLogger.error).toHaveBeenCalledWith({ err: expect.any(NotFoundError), listId: 999, userId: 'user-1' }, 'Database error in deleteShoppingList');
await expect(shoppingRepo.deleteShoppingList(999, 'user-1', mockLogger)).rejects.toThrow('Failed to delete shopping list.');
});
it('should throw a generic error if the database query fails', async () => {
@@ -179,7 +177,6 @@ describe('Shopping DB Service', () => {
(dbError as any).code = '23503';
mockPoolInstance.query.mockRejectedValue(dbError);
await expect(shoppingRepo.addShoppingListItem(999, { masterItemId: 999 }, mockLogger)).rejects.toThrow('Referenced list or item does not exist.');
expect(mockLogger.error).toHaveBeenCalledWith({ err: dbError, listId: 999, item: { masterItemId: 999 } }, 'Database error in addShoppingListItem');
});
it('should throw a generic error if the database query fails', async () => {
@@ -268,8 +265,7 @@ describe('Shopping DB Service', () => {
const dbError = new Error('violates foreign key constraint');
(dbError as any).code = '23503';
mockPoolInstance.query.mockRejectedValue(dbError);
await expect(shoppingRepo.completeShoppingList(999, 'user-123', mockLogger)).rejects.toThrow(ForeignKeyConstraintError);
expect(mockLogger.error).toHaveBeenCalledWith({ err: dbError, shoppingListId: 999, userId: 'user-123' }, 'Database error in completeShoppingList');
await expect(shoppingRepo.completeShoppingList(999, 'user-123', mockLogger)).rejects.toThrow('The specified shopping list does not exist.');
});
it('should throw a generic error if the database query fails', async () => {
@@ -362,16 +358,14 @@ describe('Shopping DB Service', () => {
const dbError = new Error('duplicate key value violates unique constraint');
(dbError as any).code = '23505';
mockPoolInstance.query.mockRejectedValue(dbError);
await expect(shoppingRepo.createPantryLocation('user-1', 'Fridge', mockLogger)).rejects.toThrow('A pantry location with this name already exists.');
expect(mockLogger.error).toHaveBeenCalledWith({ err: dbError, userId: 'user-1', name: 'Fridge' }, 'Database error in createPantryLocation');
await expect(shoppingRepo.createPantryLocation('user-1', 'Fridge', mockLogger)).rejects.toThrow(UniqueConstraintError);
});
it('should throw ForeignKeyConstraintError if user does not exist', async () => {
const dbError = new Error('violates foreign key constraint');
(dbError as any).code = '23503';
mockPoolInstance.query.mockRejectedValue(dbError);
await expect(shoppingRepo.createPantryLocation('non-existent-user', 'Pantry', mockLogger)).rejects.toThrow('User not found');
expect(mockLogger.error).toHaveBeenCalledWith({ err: dbError, userId: 'non-existent-user', name: 'Pantry' }, 'Database error in createPantryLocation');
await expect(shoppingRepo.createPantryLocation('non-existent-user', 'Pantry', mockLogger)).rejects.toThrow(ForeignKeyConstraintError);
});
it('should throw a generic error if the database query fails', async () => {
@@ -419,7 +413,6 @@ describe('Shopping DB Service', () => {
(dbError as any).code = '23503';
mockPoolInstance.query.mockRejectedValue(dbError);
await expect(shoppingRepo.createReceipt('non-existent-user', 'url', mockLogger)).rejects.toThrow('User not found');
expect(mockLogger.error).toHaveBeenCalledWith({ err: dbError, userId: 'non-existent-user', receiptImageUrl: 'url' }, 'Database error in createReceipt');
});
it('should throw a generic error if the database query fails', async () => {
@@ -455,8 +448,9 @@ describe('Shopping DB Service', () => {
describe('processReceiptItems', () => {
it('should call the process_receipt_items database function with correct parameters', async () => {
const mockClientQuery = vi.fn().mockResolvedValue({ rows: [] });
vi.mocked(withTransaction).mockImplementation(async (callback) => {
const mockClient = { query: vi.fn().mockResolvedValue({ rows: [] }) };
const mockClient = { query: mockClientQuery };
return callback(mockClient as any);
});
@@ -466,8 +460,7 @@ describe('Shopping DB Service', () => {
const expectedItemsWithQuantity = [{ raw_item_description: 'Milk', price_paid_cents: 399, quantity: 1 }];
expect(withTransaction).toHaveBeenCalledTimes(1);
const mockClient = (vi.mocked(withTransaction).mock.calls[0][0] as any).mock.instances[0];
expect(mockClient.query).toHaveBeenCalledWith(
expect(mockClientQuery).toHaveBeenCalledWith(
'SELECT public.process_receipt_items($1, $2, $3)', [1, JSON.stringify(expectedItemsWithQuantity), JSON.stringify(expectedItemsWithQuantity)]
);
});

25
src/services/db/user.db.test.ts
View File

@@ -33,7 +33,7 @@ import { UserRepository, exportUserData } from './user.db';
import { mockPoolInstance } from '../../tests/setup/tests-setup-unit';
import { UniqueConstraintError, ForeignKeyConstraintError, NotFoundError } from './errors.db';
import type { Profile, ActivityLogItem, SearchQuery } from '../../types';
import type { Profile, ActivityLogItem, SearchQuery, UserProfile } from '../../types';
// Mock other db services that are used by functions in user.db.ts
// Update mocks to put methods on prototype so spyOn works in exportUserData tests
@@ -94,22 +94,33 @@ describe('User DB Service', () => {
describe('createUser', () => {
it('should execute a transaction to create a user and profile', async () => {
const mockUser = { user_id: 'new-user-id', email: 'new@example.com' };
const mockProfile = { ...mockUser, role: 'user' };
// This is the flat structure returned by the DB query inside createUser
const mockDbProfile = { user_id: 'new-user-id', email: 'new@example.com', role: 'user', full_name: 'New User', avatar_url: null, points: 0, preferences: null };
// This is the nested structure the function is expected to return
const expectedProfile: UserProfile = {
user: { user_id: 'new-user-id', email: 'new@example.com' },
user_id: 'new-user-id',
full_name: 'New User',
avatar_url: null,
role: 'user',
points: 0,
preferences: null,
};
vi.mocked(withTransaction).mockImplementation(async (callback) => {
const mockClient = { query: vi.fn() };
mockClient.query
.mockResolvedValueOnce({ rows: [] }) // set_config
.mockResolvedValueOnce({ rows: [mockUser] }) // INSERT user
.mockResolvedValueOnce({ rows: [mockProfile] }); // SELECT profile
.mockResolvedValueOnce({ rows: [mockDbProfile] }); // SELECT profile
return callback(mockClient as any);
});
const result = await userRepo.createUser('new@example.com', 'hashedpass', { full_name: 'New User' }, mockLogger);
expect(result).toEqual(mockProfile);
expect(result).toEqual(expectedProfile);
expect(withTransaction).toHaveBeenCalledTimes(1);
});
});
it('should rollback the transaction if creating the user fails', async () => {
const dbError = new Error('User insert failed');
@@ -156,7 +167,7 @@ describe('User DB Service', () => {
}
expect(withTransaction).toHaveBeenCalledTimes(1);
expect(mockLogger.error).toHaveBeenCalledWith({ err: dbError, email: 'exists@example.com' }, 'Error during createUser transaction');
expect(mockLogger.warn).toHaveBeenCalledWith(`Attempted to create a user with an existing email: exists@example.com`);
});
});
@@ -194,7 +205,7 @@ describe('User DB Service', () => {
it('should throw NotFoundError if user is not found', async () => {
mockPoolInstance.query.mockResolvedValue({ rows: [] });
await expect(userRepo.findUserById('not-found-id', mockLogger)).rejects.toThrow(NotFoundError);
await expect(userRepo.findUserById('not-found-id', mockLogger)).rejects.toThrow('User with ID not-found-id not found.');
});
it('should throw a generic error if the database query fails', async () => {

128
src/services/googleGeocodingService.server.test.ts Normal file
View File

@@ -0,0 +1,128 @@
// src/services/googleGeocodingService.server.test.ts
import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
// Un-mock the module we are testing to ensure we use the real implementation.
vi.unmock('./googleGeocodingService.server');
// Mock the logger to prevent console output and allow for assertions
vi.mock('./logger.server', () => ({
logger: {
info: vi.fn(),
warn: vi.fn(),
error: vi.fn(),
debug: vi.fn(),
},
}));
// Import the service to be tested and its mocked dependencies
import { GoogleGeocodingService } from './googleGeocodingService.server';
import { logger as mockLogger } from './logger.server';
describe('Google Geocoding Service', () => {
let googleGeocodingService: GoogleGeocodingService;
const originalEnv = process.env;
beforeEach(() => {
vi.clearAllMocks();
// Mock the global fetch function before each test
vi.stubGlobal('fetch', vi.fn());
// Restore process.env to a clean state for each test
process.env = { ...originalEnv };
googleGeocodingService = new GoogleGeocodingService();
});
afterEach(() => {
// Restore original environment variables after each test
process.env = originalEnv;
});
it('should return coordinates for a valid address when API key is present', async () => {
// Arrange
process.env.GOOGLE_MAPS_API_KEY = 'test-api-key';
const mockApiResponse = {
status: 'OK',
results: [{
geometry: {
location: { lat: 34.0522, lng: -118.2437 },
},
}],
};
vi.mocked(fetch).mockResolvedValue({
ok: true,
json: async () => mockApiResponse,
} as Response);
// Act
const result = await googleGeocodingService.geocode('Los Angeles, CA', mockLogger);
// Assert
expect(result).toEqual({ lat: 34.0522, lng: -118.2437 });
expect(fetch).toHaveBeenCalledWith(expect.stringContaining('https://maps.googleapis.com/maps/api/geocode/json'));
expect(mockLogger.info).toHaveBeenCalledWith(
{ address: 'Los Angeles, CA', result: { lat: 34.0522, lng: -118.2437 } },
'[GoogleGeocodingService] Successfully geocoded address'
);
});
it('should throw an error if GOOGLE_MAPS_API_KEY is not set', async () => {
// Arrange
delete process.env.GOOGLE_MAPS_API_KEY;
// Act & Assert
await expect(googleGeocodingService.geocode('Any Address', mockLogger))
.rejects.toThrow('GOOGLE_MAPS_API_KEY is not set.');
expect(mockLogger.error).toHaveBeenCalledWith('[GoogleGeocodingService] API key is missing.');
});
it('should return null if the API returns a status other than "OK"', async () => {
// Arrange
process.env.GOOGLE_MAPS_API_KEY = 'test-api-key';
const mockApiResponse = { status: 'ZERO_RESULTS', results: [] };
vi.mocked(fetch).mockResolvedValue({
ok: true,
json: async () => mockApiResponse,
} as Response);
// Act
const result = await googleGeocodingService.geocode('Invalid Address', mockLogger);
// Assert
expect(result).toBeNull();
expect(mockLogger.warn).toHaveBeenCalledWith(
{ address: 'Invalid Address', status: 'ZERO_RESULTS' },
'[GoogleGeocodingService] Geocoding failed or returned no results.'
);
});
it('should throw an error if the fetch response is not ok', async () => {
// Arrange
process.env.GOOGLE_MAPS_API_KEY = 'test-api-key';
vi.mocked(fetch).mockResolvedValue({
ok: false,
status: 403,
} as Response);
// Act & Assert
await expect(googleGeocodingService.geocode('Any Address', mockLogger))
.rejects.toThrow('Google Maps API returned status 403');
expect(mockLogger.error).toHaveBeenCalledWith(
{ err: expect.any(Error), address: 'Any Address' },
'[GoogleGeocodingService] An error occurred while calling the Google Maps API.'
);
});
it('should throw an error if the fetch call itself fails', async () => {
// Arrange
process.env.GOOGLE_MAPS_API_KEY = 'test-api-key';
const networkError = new Error('Network request failed');
vi.mocked(fetch).mockRejectedValue(networkError);
// Act & Assert
await expect(googleGeocodingService.geocode('Any Address', mockLogger))
.rejects.toThrow(networkError);
expect(mockLogger.error).toHaveBeenCalledWith(
{ err: networkError, address: 'Any Address' },
'[GoogleGeocodingService] An error occurred while calling the Google Maps API.'
);
});
});