improve: whitespace and clarity in exercise-logic tests, strengthen type safety and schema validation

Author: rgilks

app/actions/exercise-logic.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import * as logic from './exercise-logic';
 import { generateAndValidateExercise } from '@/lib/ai/exercise-generator';
 import { saveExerciseToCache, getValidatedExerciseFromCache } from '@/lib/exercise-cache';
+import { ExerciseRequestParamsSchema, GenerateExerciseResultSchema } from '@/lib/domain/schemas';
 import type { ExerciseGenerationParams } from '@/lib/domain/ai';
 import type {
   ExerciseContent,
@@ -21,7 +22,7 @@ const {
   getOrGenerateExercise,
 } = logic;
 
-const mockParams: ExerciseGenerationParams = {
+const mockParams = {
   topic: 'Test Topic',
   passageLanguage: 'en',
   questionLanguage: 'es',
@@ -30,28 +31,28 @@ const mockParams: ExerciseGenerationParams = {
   level: 'B1',
   grammarGuidance: 'Past tense',
   vocabularyGuidance: 'Travel words',
-};
+} as const satisfies ExerciseGenerationParams;
 
-const mockRequestParams: ExerciseRequestParams = {
+const mockRequestParams = {
   passageLanguage: 'en',
   questionLanguage: 'es',
   cefrLevel: 'B1',
-};
+} as const satisfies ExerciseRequestParams;
 
 const mockUserId = 123;
 const mockLanguage = 'en';
 
-const mockExerciseContent: ExerciseContent = {
+const mockExerciseContent = {
   paragraph: 'p',
   question: 'q',
   options: { A: 'A', B: 'B', C: 'C', D: 'D' },
   correctAnswer: 'A',
   allExplanations: { A: 'EA', B: 'EB', C: 'EC', D: 'ED' },
   relevantText: 'rt',
   topic: 'Test Topic',
-};
+} as const satisfies ExerciseContent;
 
-const mockCacheResult: GenerateExerciseResult = {
+const mockCacheResult = {
   quizData: {
     paragraph: 'cached_p',
     question: 'cached_q',
@@ -62,7 +63,7 @@ const mockCacheResult: GenerateExerciseResult = {
   quizId: 999,
   cached: true,
   error: null,
-};
+} as const satisfies GenerateExerciseResult;
 
 describe('Exercise Logic Functions', () => {
   beforeEach(() => {
@@ -91,25 +92,18 @@ describe('Exercise Logic Functions', () => {
         mockUserId
       );
     });
-    it('returns failure if generateAndValidateExercise throws an error', async () => {
-      const error = new Error('AI failed');
-      vi.mocked(generateAndValidateExercise).mockRejectedValue(error);
+    it.each([
+      [new Error('AI failed'), 'Error during AI generation/processing: AI failed'],
+      [new Error('Generic failure'), 'Error during AI generation/processing: Generic failure'],
+      [123, 'Error during AI generation/processing: 123'],
+      [null, 'Error during AI generation/processing: null'],
+    ])('returns failure if generateAndValidateExercise throws %p', async (thrown, expectedMsg) => {
+      vi.mocked(generateAndValidateExercise).mockRejectedValue(thrown);
       const result = await tryGenerateAndCacheExercise(mockParams, mockLanguage, mockUserId);
       expect(result.success).toBe(false);
       if (!result.success) {
-        expect(result.error.error).toContain('Error during AI generation/processing: AI failed');
-      }
-      expect(saveExerciseToCache).not.toHaveBeenCalled();
-    });
-    it('returns failure if generateAndValidateExercise throws a non-standard error', async () => {
-      const genericError = new Error('Generic failure');
-      vi.mocked(generateAndValidateExercise).mockRejectedValue(genericError);
-      const result = await tryGenerateAndCacheExercise(mockParams, mockLanguage, mockUserId);
-      expect(result.success).toBe(false);
-      if (!result.success) {
-        expect(result.error.error).toContain(
-          'Error during AI generation/processing: Generic failure'
-        );
+        expect(result.error.error).toContain(expectedMsg);
+        expect(typeof result.error.error).toBe('string');
       }
       expect(saveExerciseToCache).not.toHaveBeenCalled();
     });
@@ -125,17 +119,27 @@ describe('Exercise Logic Functions', () => {
       }
     });
     it('returns failure if saveExerciseToCache throws an error', async () => {
-      const cacheError = new Error('Cache save failed');
       vi.mocked(generateAndValidateExercise).mockResolvedValue(mockExerciseContent);
       vi.mocked(saveExerciseToCache).mockImplementation(() => {
-        throw cacheError;
+        throw new Error('Cache save failed');
       });
       const result = await tryGenerateAndCacheExercise(mockParams, mockLanguage, mockUserId);
       expect(result.success).toBe(false);
       if (!result.success) {
         expect(result.error.error).toBe('Error during AI generation/processing: Cache save failed');
       }
     });
+    it('returns failure if saveExerciseToCache throws a non-Error value', async () => {
+      vi.mocked(generateAndValidateExercise).mockResolvedValue(mockExerciseContent);
+      vi.mocked(saveExerciseToCache).mockImplementation(() => {
+        throw new Error('123');
+      });
+      const result = await tryGenerateAndCacheExercise(mockParams, mockLanguage, mockUserId);
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.error).toBe('Error during AI generation/processing: 123');
+      }
+    });
   });
 
   describe('tryGetCachedExercise', () => {
@@ -152,17 +156,12 @@ describe('Exercise Logic Functions', () => {
         mockRequestParams.cefrLevel,
         mockUserId
       );
+      expect(GenerateExerciseResultSchema.safeParse(result).success).toBe(true);
     });
     it('returns null if no cached exercise is found', async () => {
       vi.mocked(getValidatedExerciseFromCache).mockReturnValue(undefined);
       const result = await tryGetCachedExercise(mockRequestParams, mockUserId);
       expect(result).toBeNull();
-      expect(getValidatedExerciseFromCache).toHaveBeenCalledWith(
-        mockRequestParams.passageLanguage,
-        mockRequestParams.questionLanguage,
-        mockRequestParams.cefrLevel,
-        mockUserId
-      );
     });
   });
 
@@ -176,6 +175,7 @@ describe('Exercise Logic Functions', () => {
         error: errorMsg,
         cached: false,
       });
+      expect(GenerateExerciseResultSchema.safeParse(response).success).toBe(true);
     });
     it('includes details if provided', () => {
       const errorMsg = 'Test error';
@@ -187,6 +187,7 @@ describe('Exercise Logic Functions', () => {
         error: `${errorMsg}: ${JSON.stringify(details)}`,
         cached: false,
       });
+      expect(GenerateExerciseResultSchema.safeParse(response).success).toBe(true);
     });
   });
 
@@ -199,17 +200,22 @@ describe('Exercise Logic Functions', () => {
         expect(result.data.passageLanguage).toBe(validParams.passageLanguage);
         expect(result.data.questionLanguage).toBe(validParams.questionLanguage);
         expect(result.data.cefrLevel).toBe(validParams.cefrLevel);
+        expect(ExerciseRequestParamsSchema.safeParse(result.data).success).toBe(true);
       }
     });
     it('invalidates incorrect params', () => {
       const invalidParams = { passageLanguage: 'en', questionLanguage: 'fr', cefrLevel: 'Z9' };
       const result = validateRequestParams(invalidParams);
       expect(result.success).toBe(false);
     });
+    it('invalidates missing params', () => {
+      const result = validateRequestParams({});
+      expect(result.success).toBe(false);
+    });
   });
 
   describe('getOrGenerateExercise', () => {
-    const validGenParams: ExerciseGenerationParams = {
+    const validGenParams = {
       passageLanguage: 'en',
       questionLanguage: 'fr',
       level: 'A2',
@@ -218,10 +224,10 @@ describe('Exercise Logic Functions', () => {
       questionLangName: 'French',
       grammarGuidance: 'Mock Grammar',
       vocabularyGuidance: 'Mock Vocab',
-    };
+    } as const satisfies ExerciseGenerationParams;
     const mockUserId = 1;
     const generatedSuccessData = { content: mockExerciseContent, id: 555 };
-    const cachedResult: GenerateExerciseResult = {
+    const cachedResult = {
       quizData: {
         paragraph: 'Cached Para',
         question: 'Cached Q',
@@ -232,35 +238,46 @@ describe('Exercise Logic Functions', () => {
       quizId: 999,
       cached: true,
       error: null,
-    };
+    } as const satisfies GenerateExerciseResult;
     beforeEach(() => {
       vi.resetAllMocks();
     });
-    it('returns generated exercise if cache is low and generation succeeds', async () => {
-      vi.mocked(generateAndValidateExercise).mockResolvedValue(mockExerciseContent);
-      vi.mocked(saveExerciseToCache).mockReturnValue(555);
-      vi.mocked(getValidatedExerciseFromCache).mockReturnValue(undefined);
-      const result = await getOrGenerateExercise(validGenParams, mockUserId, 10);
-      expect(result.quizId).toBe(generatedSuccessData.id);
-      expect(result.cached).toBe(false);
-      expect(result.error).toBeNull();
-      expect(result.quizData.paragraph).toBe(mockExerciseContent.paragraph);
-    });
-    it('returns cached exercise if cache is low, generation fails, but cache fallback succeeds', async () => {
-      vi.mocked(generateAndValidateExercise).mockRejectedValue(new Error('Generation Failed'));
-      vi.mocked(getValidatedExerciseFromCache).mockReturnValue({
-        quizData: cachedResult.quizData,
-        quizId: cachedResult.quizId,
-      });
-      const result = await getOrGenerateExercise(validGenParams, mockUserId, 10);
-      expect(result).toEqual(cachedResult);
-    });
+    it.each([
+      [10, false],
+      [99, false],
+      [100, true],
+      [200, true],
+    ])(
+      'returns correct result for cachedCount=%i (preferGenerate=%s)',
+      async (cachedCount, preferCache) => {
+        if (preferCache) {
+          vi.mocked(getValidatedExerciseFromCache).mockReturnValue({
+            quizData: cachedResult.quizData,
+            quizId: cachedResult.quizId,
+          });
+          const result = await getOrGenerateExercise(validGenParams, mockUserId, cachedCount);
+          expect(result).toEqual(cachedResult);
+          expect(GenerateExerciseResultSchema.safeParse(result).success).toBe(true);
+        } else {
+          vi.mocked(generateAndValidateExercise).mockResolvedValue(mockExerciseContent);
+          vi.mocked(saveExerciseToCache).mockReturnValue(555);
+          vi.mocked(getValidatedExerciseFromCache).mockReturnValue(undefined);
+          const result = await getOrGenerateExercise(validGenParams, mockUserId, cachedCount);
+          expect(result.quizId).toBe(generatedSuccessData.id);
+          expect(result.cached).toBe(false);
+          expect(result.error).toBeNull();
+          expect(result.quizData.paragraph).toBe(mockExerciseContent.paragraph);
+          expect(GenerateExerciseResultSchema.safeParse(result).success).toBe(true);
+        }
+      }
+    );
     it('returns generation error if cache is low, generation and cache fallback both fail', async () => {
       vi.mocked(generateAndValidateExercise).mockRejectedValue(new Error('Generation Failed'));
       vi.mocked(getValidatedExerciseFromCache).mockReturnValue(undefined);
       const result = await getOrGenerateExercise(validGenParams, mockUserId, 10);
       expect(result.error).toContain('Generation Failed');
       expect(result.quizId).toBe(-1);
+      expect(GenerateExerciseResultSchema.safeParse(result).success).toBe(true);
     });
     it('returns generation error if cache is low and generation fails (terminal cache error)', async () => {
       vi.mocked(generateAndValidateExercise).mockResolvedValue(mockExerciseContent);
@@ -271,31 +288,15 @@ describe('Exercise Logic Functions', () => {
         'Exercise generated but failed to save to cache (undefined ID).'
       );
       expect(result.quizId).toBe(-1);
-    });
-    it('returns cached exercise if cache is high and cache lookup succeeds', async () => {
-      vi.mocked(getValidatedExerciseFromCache).mockReturnValue({
-        quizData: cachedResult.quizData,
-        quizId: cachedResult.quizId,
-      });
-      const result = await getOrGenerateExercise(validGenParams, mockUserId, 200);
-      expect(result).toEqual(cachedResult);
-    });
-    it('returns generated exercise if cache is high, cache lookup fails, but generation succeeds', async () => {
-      vi.mocked(getValidatedExerciseFromCache).mockReturnValue(undefined);
-      vi.mocked(generateAndValidateExercise).mockResolvedValue(mockExerciseContent);
-      vi.mocked(saveExerciseToCache).mockReturnValue(555);
-      const result = await getOrGenerateExercise(validGenParams, mockUserId, 200);
-      expect(result.quizId).toBe(generatedSuccessData.id);
-      expect(result.cached).toBe(false);
-      expect(result.error).toBeNull();
-      expect(result.quizData.paragraph).toBe(mockExerciseContent.paragraph);
+      expect(GenerateExerciseResultSchema.safeParse(result).success).toBe(true);
     });
     it('returns generation error if cache is high, cache lookup and generation both fail', async () => {
       vi.mocked(getValidatedExerciseFromCache).mockReturnValue(undefined);
       vi.mocked(generateAndValidateExercise).mockRejectedValue(new Error('Generation Failed'));
       const result = await getOrGenerateExercise(validGenParams, mockUserId, 200);
       expect(result.error).toContain('Generation Failed');
       expect(result.quizId).toBe(-1);
+      expect(GenerateExerciseResultSchema.safeParse(result).success).toBe(true);
     });
   });
 });