more test improvements

src/routes/passport.routes.test.ts

@@ -618,21 +618,19 @@ describe('Passport Configuration', () => {
 
   describe('mockAuth Middleware', () => {
     const mockNext: NextFunction = vi.fn();
-    let mockRes: Partial<Response>;
-    let originalNodeEnv: string | undefined;
+    const mockRes: Partial<Response> = {
+      status: vi.fn().mockReturnThis(),
+      json: vi.fn(),
+    };
 
     beforeEach(() => {
-      mockRes = { status: vi.fn().mockReturnThis(), json: vi.fn() };
-      originalNodeEnv = process.env.NODE_ENV;
-    });
-
-    afterEach(() => {
-      process.env.NODE_ENV = originalNodeEnv;
+      // Unstub env variables before each test in this block to ensure a clean state.
+      vi.unstubAllEnvs();
     });
 
     it('should attach a mock admin user to req when NODE_ENV is "test"', () => {
       // Arrange
-      process.env.NODE_ENV = 'test';
+      vi.stubEnv('NODE_ENV', 'test');
       const mockReq = {} as Request;
 
       // Act
@@ -646,7 +644,7 @@ describe('Passport Configuration', () => {
 
     it('should do nothing and call next() when NODE_ENV is not "test"', () => {
       // Arrange
-      process.env.NODE_ENV = 'production';
+      vi.stubEnv('NODE_ENV', 'production');
       const mockReq = {} as Request;
 
       // Act

src/routes/reactions.routes.test.ts

@@ -0,0 +1,211 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import supertest from 'supertest';
+import { createTestApp } from '../tests/utils/createTestApp';
+import { createMockUserProfile } from '../tests/utils/mockFactories';
+
+// 1. Mock the Service Layer directly.
+vi.mock('../services/db/index.db', () => ({
+  reactionRepo: {
+    getReactions: vi.fn(),
+    getReactionSummary: vi.fn(),
+    toggleReaction: vi.fn(),
+  },
+}));
+
+// Mock the logger to keep test output clean
+vi.mock('../services/logger.server', async () => ({
+  logger: (await import('../tests/utils/mockLogger')).mockLogger,
+}));
+
+// Mock Passport middleware
+vi.mock('./passport.routes', () => ({
+  default: {
+    authenticate: vi.fn(
+      () => (req: any, res: any, next: any) => {
+        // If we are testing the unauthenticated state (no user injected), simulate 401.
+        if (!req.user) {
+          return res.status(401).json({ message: 'Unauthorized' });
+        }
+        next();
+      },
+    ),
+  },
+}));
+
+// Import the router and mocked DB AFTER all mocks are defined.
+import reactionsRouter from './reactions.routes';
+import { reactionRepo } from '../services/db/index.db';
+import { mockLogger } from '../tests/utils/mockLogger';
+
+const expectLogger = expect.objectContaining({
+  info: expect.any(Function),
+  error: expect.any(Function),
+});
+
+describe('Reaction Routes (/api/reactions)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('GET /', () => {
+    const app = createTestApp({ router: reactionsRouter, basePath: '/api/reactions' });
+
+    it('should return a list of reactions', async () => {
+      const mockReactions = [{ id: 1, reaction_type: 'like', entity_id: '123' }];
+      vi.mocked(reactionRepo.getReactions).mockResolvedValue(mockReactions as any);
+
+      const response = await supertest(app).get('/api/reactions');
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual(mockReactions);
+      expect(reactionRepo.getReactions).toHaveBeenCalledWith({}, expectLogger);
+    });
+
+    it('should filter by query parameters', async () => {
+      const mockReactions = [{ id: 1, reaction_type: 'like' }];
+      vi.mocked(reactionRepo.getReactions).mockResolvedValue(mockReactions as any);
+      
+      const validUuid = '123e4567-e89b-12d3-a456-426614174000';
+      const query = { userId: validUuid, entityType: 'recipe', entityId: '1' };
+
+      const response = await supertest(app).get('/api/reactions').query(query);
+
+      expect(response.status).toBe(200);
+      expect(reactionRepo.getReactions).toHaveBeenCalledWith(
+        expect.objectContaining(query),
+        expectLogger
+      );
+    });
+
+    it('should return 500 on database error', async () => {
+      const error = new Error('DB Error');
+      vi.mocked(reactionRepo.getReactions).mockRejectedValue(error);
+
+      const response = await supertest(app).get('/api/reactions');
+
+      expect(response.status).toBe(500);
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        { error },
+        'Error fetching user reactions'
+      );
+    });
+  });
+
+  describe('GET /summary', () => {
+    const app = createTestApp({ router: reactionsRouter, basePath: '/api/reactions' });
+
+    it('should return reaction summary for an entity', async () => {
+      const mockSummary = { like: 10, love: 5 };
+      vi.mocked(reactionRepo.getReactionSummary).mockResolvedValue(mockSummary as any);
+
+      const response = await supertest(app)
+        .get('/api/reactions/summary')
+        .query({ entityType: 'recipe', entityId: '123' });
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual(mockSummary);
+      expect(reactionRepo.getReactionSummary).toHaveBeenCalledWith(
+        'recipe',
+        '123',
+        expectLogger
+      );
+    });
+
+    it('should return 400 if required parameters are missing', async () => {
+      const response = await supertest(app).get('/api/reactions/summary');
+      expect(response.status).toBe(400);
+      expect(response.body.errors[0].message).toContain('required');
+    });
+
+    it('should return 500 on database error', async () => {
+      const error = new Error('DB Error');
+      vi.mocked(reactionRepo.getReactionSummary).mockRejectedValue(error);
+
+      const response = await supertest(app)
+        .get('/api/reactions/summary')
+        .query({ entityType: 'recipe', entityId: '123' });
+
+      expect(response.status).toBe(500);
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        { error },
+        'Error fetching reaction summary'
+      );
+    });
+  });
+
+  describe('POST /toggle', () => {
+    const mockUser = createMockUserProfile({ user: { user_id: 'user-123' } });
+    const app = createTestApp({
+      router: reactionsRouter,
+      basePath: '/api/reactions',
+      authenticatedUser: mockUser,
+    });
+
+    const validBody = {
+      entity_type: 'recipe',
+      entity_id: '123',
+      reaction_type: 'like',
+    };
+
+    it('should return 201 when a reaction is added', async () => {
+      const mockResult = { ...validBody, id: 1, user_id: 'user-123' };
+      vi.mocked(reactionRepo.toggleReaction).mockResolvedValue(mockResult as any);
+
+      const response = await supertest(app)
+        .post('/api/reactions/toggle')
+        .send(validBody);
+
+      expect(response.status).toBe(201);
+      expect(response.body).toEqual({ message: 'Reaction added.', reaction: mockResult });
+      expect(reactionRepo.toggleReaction).toHaveBeenCalledWith(
+        { user_id: 'user-123', ...validBody },
+        expectLogger
+      );
+    });
+
+    it('should return 200 when a reaction is removed', async () => {
+      // Returning null/false from toggleReaction implies the reaction was removed
+      vi.mocked(reactionRepo.toggleReaction).mockResolvedValue(null);
+
+      const response = await supertest(app)
+        .post('/api/reactions/toggle')
+        .send(validBody);
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual({ message: 'Reaction removed.' });
+    });
+
+    it('should return 400 if body is invalid', async () => {
+      const response = await supertest(app)
+        .post('/api/reactions/toggle')
+        .send({ entity_type: 'recipe' }); // Missing other required fields
+
+      expect(response.status).toBe(400);
+      expect(response.body.errors).toBeDefined();
+    });
+
+    it('should return 401 if not authenticated', async () => {
+      const unauthApp = createTestApp({ router: reactionsRouter, basePath: '/api/reactions' });
+      const response = await supertest(unauthApp)
+        .post('/api/reactions/toggle')
+        .send(validBody);
+
+      expect(response.status).toBe(401);
+    });
+
+    it('should return 500 on database error', async () => {
+      const error = new Error('DB Error');
+      vi.mocked(reactionRepo.toggleReaction).mockRejectedValue(error);
+
+      const response = await supertest(app)
+        .post('/api/reactions/toggle')
+        .send(validBody);
+
+      expect(response.status).toBe(500);
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        { error, body: validBody },
+        'Error toggling user reaction'
+      );
+    });
+  });
+});

src/routes/recipe.routes.test.ts

@@ -1,7 +1,7 @@
 // src/routes/recipe.routes.test.ts
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import supertest from 'supertest';
-import { createMockRecipe, createMockRecipeComment } from '../tests/utils/mockFactories';
+import { createMockRecipe, createMockRecipeComment, createMockUserProfile } from '../tests/utils/mockFactories';
 import { NotFoundError } from '../services/db/errors.db';
 import { createTestApp } from '../tests/utils/createTestApp';
 
@@ -16,9 +16,31 @@ vi.mock('../services/db/index.db', () => ({
   },
 }));
 
+// Mock AI Service
+vi.mock('../services/aiService.server', () => ({
+  aiService: {
+    generateRecipeSuggestion: vi.fn(),
+  },
+}));
+
+// Mock Passport
+vi.mock('./passport.routes', () => ({
+  default: {
+    authenticate: vi.fn(
+      () => (req: any, res: any, next: any) => {
+        if (!req.user) {
+          return res.status(401).json({ message: 'Unauthorized' });
+        }
+        next();
+      },
+    ),
+  },
+}));
+
 // Import the router and mocked DB AFTER all mocks are defined.
 import recipeRouter from './recipe.routes';
 import * as db from '../services/db/index.db';
+import { aiService } from '../services/aiService.server';
 import { mockLogger } from '../tests/utils/mockLogger';
 
 // Mock the logger to keep test output clean
@@ -229,4 +251,71 @@ describe('Recipe Routes (/api/recipes)', () => {
       expect(response.body.errors[0].message).toContain('received NaN');
     });
   });
+
+  describe('POST /suggest', () => {
+    const mockUser = createMockUserProfile({ user: { user_id: 'user-123' } });
+    const authApp = createTestApp({
+      router: recipeRouter,
+      basePath: '/api/recipes',
+      authenticatedUser: mockUser,
+    });
+
+    it('should return a recipe suggestion', async () => {
+      const ingredients = ['chicken', 'rice'];
+      const mockSuggestion = 'Chicken and Rice Casserole...';
+      vi.mocked(aiService.generateRecipeSuggestion).mockResolvedValue(mockSuggestion);
+
+      const response = await supertest(authApp)
+        .post('/api/recipes/suggest')
+        .send({ ingredients });
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual({ suggestion: mockSuggestion });
+      expect(aiService.generateRecipeSuggestion).toHaveBeenCalledWith(ingredients, expectLogger);
+    });
+
+    it('should return 503 if AI service returns null', async () => {
+      vi.mocked(aiService.generateRecipeSuggestion).mockResolvedValue(null);
+
+      const response = await supertest(authApp)
+        .post('/api/recipes/suggest')
+        .send({ ingredients: ['water'] });
+
+      expect(response.status).toBe(503);
+      expect(response.body.message).toContain('unavailable');
+    });
+
+    it('should return 400 if ingredients list is empty', async () => {
+      const response = await supertest(authApp)
+        .post('/api/recipes/suggest')
+        .send({ ingredients: [] });
+
+      expect(response.status).toBe(400);
+      expect(response.body.errors[0].message).toContain('At least one ingredient is required');
+    });
+
+    it('should return 401 if not authenticated', async () => {
+      const unauthApp = createTestApp({ router: recipeRouter, basePath: '/api/recipes' });
+      const response = await supertest(unauthApp)
+        .post('/api/recipes/suggest')
+        .send({ ingredients: ['chicken'] });
+
+      expect(response.status).toBe(401);
+    });
+
+    it('should return 500 on service error', async () => {
+      const error = new Error('AI Error');
+      vi.mocked(aiService.generateRecipeSuggestion).mockRejectedValue(error);
+
+      const response = await supertest(authApp)
+        .post('/api/recipes/suggest')
+        .send({ ingredients: ['chicken'] });
+
+      expect(response.status).toBe(500);
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        { error },
+        'Error generating recipe suggestion'
+      );
+    });
+  });
 });

src/routes/user.routes.test.ts

@@ -122,10 +122,10 @@ describe('User Routes (/api/users)', () => {
   describe('Avatar Upload Directory Creation', () => {
     it('should log an error if avatar directory creation fails', async () => {
       // Arrange
-      const mkdirError = new Error('EACCES: permission denied');
+      const mkdirError = new Error('EACCES: permission denied'); // This error is specific to the fs.mkdir mock.
       // Reset modules to force re-import with a new mock implementation
       vi.resetModules();
-      // Set up the mock *before* the module is re-imported
+      // Set up the mock *before* the module is re-imported.
       vi.doMock('node:fs/promises', () => ({
         default: {
           // We only need to mock mkdir for this test.
@@ -133,6 +133,10 @@ describe('User Routes (/api/users)', () => {
         },
       }));
       const { logger } = await import('../services/logger.server');
+      // Stub NODE_ENV to ensure the relevant code path is executed if it depends on it.
+      // Although the mkdir call itself doesn't depend on NODE_ENV, this is good practice
+      // when re-importing modules that might have conditional logic based on it.
+      vi.stubEnv('NODE_ENV', 'test');
 
       // Act: Dynamically import the router to trigger the top-level fs.mkdir call
       await import('./user.routes');
@@ -142,6 +146,7 @@ describe('User Routes (/api/users)', () => {
         { error: mkdirError },
         'Failed to create multer storage directories on startup.',
       );
+      vi.unstubAllEnvs(); // Clean up the stubbed environment variable.
       vi.doUnmock('node:fs/promises'); // Clean up
     });
   });