fixed test cases

Author: verakohh

question-service/package.json

@@ -7,7 +7,7 @@
     "start": "node dist/index.js",
     "dev": "ts-node-dev --respawn --transpile-only src/index.ts",
     "build": "tsc",
-    "test": "jest --runInBand --verbose",
+    "test": "dotenv -e .env.test -- jest --runInBand --verbose",
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage"
   },

question-service/src/index.ts

@@ -1,6 +1,6 @@
 import express = require('express');
 import { Request, Response, NextFunction } from 'express';
-import * as cors from 'cors';
+import cors = require('cors');
 import helmet from 'helmet';
 import questionRoutes from './routes/questionRoutes';
 import { errorHandler, notFoundHandler } from './middleware/errorHandler';

question-service/src/test/question.service.integration.test.ts

@@ -1,69 +1,117 @@
-import * as request from 'supertest';
+import request from 'supertest';
 import app from '../index';
-import { pool, closePool } from '../config/database'; // Import pool for direct checks if needed
-
-// Close the database pool after all integration tests have run
-afterAll(async () => {
-  await closePool();
-});
+import { closePool } from '../config/database';
 
 describe('Question Service API (Integration)', () => {
-
-  // Test the health check endpoint
-  it('health check should return status and timestamp', async () => {
-    const res = await request(app).get('/health');
-    expect([200, 503]).toContain(res.statusCode);
-    expect(res.body).toHaveProperty('status');
-    expect(res.body).toHaveProperty('database');
-    expect(res.body).toHaveProperty('timestamp');
+  afterAll(async () => {
+    await closePool();
   });
 
-  // Test the GET /api/topics endpoint
-  it('GET /api/topics should return an array or an error status', async () => {
-    const res = await request(app).get('/api/topics');
-    expect([200, 500]).toContain(res.statusCode); // Expect 200 or 500 (if DB not ready)
-    if (res.statusCode === 200) {
-      expect(Array.isArray(res.body)).toBe(true);
-    }
+  describe('Health Check', () => {
+    it('should return status and timestamp', async () => {
+      const res = await request(app).get('/health');
+      expect([200, 503]).toContain(res.statusCode);
+      expect(res.body).toHaveProperty('status');
+      expect(res.body).toHaveProperty('database');
+      expect(res.body).toHaveProperty('timestamp');
+    });
   });
 
-  // Test the main POST /api/questions/select endpoint
-  it('POST /api/questions/select should accept criteria and excludedIds', async () => {
-    const payload = {
-      criteria: { topic: 'Array', difficulty: 'Easy' }, // Make sure 'Array' exists in your test DB
-      excludedIds: ['00000000-0000-0000-0000-000000000000'] // A fake UUID
-    };
+  describe('Questions API', () => {
+    describe('GET /api/questions', () => {
+      it('should return all questions', async () => {
+        const res = await request(app).get('/api/questions');
+        expect(res.statusCode).toBe(200);
+        expect(Array.isArray(res.body)).toBe(true);
+      });
+    });
 
-    const res = await request(app)
-      .post('/api/questions/select')
-      .send(payload)
-      .set('Accept', 'application/json');
+    describe('GET /api/questions/:id', () => {
+      it('should return question by id if exists', async () => {
+        // First get all questions to get a valid ID
+        const allQuestionsRes = await request(app).get('/api/questions');
+        if (allQuestionsRes.body.length > 0) {
+          const questionId = allQuestionsRes.body[0].question_id;
+          const res = await request(app).get(`/api/questions/${questionId}`);
+          expect(res.statusCode).toBe(200);
+          expect(res.body).toHaveProperty('question_id', questionId);
+        }
+      });
 
-    // Depending on seeded data, this may return 200 with a question or 404 if none found.
-    // 400 is also possible if criteria are bad. 500 if the DB connection fails.
-    expect([200, 400, 404, 500]).toContain(res.statusCode);
+      it('should return 404 for non-existent question', async () => {
+        const res = await request(app).get('/api/questions/652c60dc-f518-4a7c-9c3c-bab6bf4b6cc0');
+        expect(res.statusCode).toBe(404);
+      });
+    });
 
-    if (res.statusCode === 200) {
-      expect(res.body).toHaveProperty('question_id');
-      expect(res.body).toHaveProperty('title');
-      expect(res.body).toHaveProperty('difficulty');
-      // We know it's not the one we excluded
-      expect(res.body.question_id).not.toBe('00000000-0000-0000-0000-000000000000');
-    }
+    describe('GET /api/topics', () => {
+      it('should return array of topics', async () => {
+        const res = await request(app).get('/api/topics');
+        expect(res.statusCode).toBe(200);
+        expect(Array.isArray(res.body)).toBe(true);
+      });
+    });
 
-    if (res.statusCode === 404) {
-      expect(res.body).toHaveProperty('message', 'No suitable question found for the given criteria.');
-    }
-  });
+    describe('POST /api/questions/select', () => {
+      it('should return a question matching criteria', async () => {
+        const payload = {
+          criteria: { topic: 'Array', difficulty: 'Easy' },
+          excludedIds: []
+        };
 
-  it('POST /api/questions/select validates body', async () => {
-    const res = await request(app)
-      .post('/api/questions/select')
-      .send({ topic: 'Array' }); // Missing criteria.difficulty and excludedIds
-    
-    // This expects your controller's validation logic to catch the bad body
-    expect(res.statusCode).toBe(400); 
-    expect(res.body).toHaveProperty('message');
-  });
+        const res = await request(app)
+          .post('/api/questions/select')
+          .send(payload);
+
+        if (res.statusCode === 200) {
+          expect(res.body).toMatchObject({
+            question_id: expect.any(String),
+            title: expect.any(String),
+            difficulty: expect.stringMatching(/^(Easy|Medium|Hard)$/)
+          });
+        } else {
+          expect([404]).toContain(res.statusCode); // No matching questions found
+        }
+      });
+
+      it('should validate request payload', async () => {
+        const invalidPayload = {
+          criteria: { topic: '', difficulty: 'Invalid' }
+        };
 
-});
+        const res = await request(app)
+          .post('/api/questions/select')
+          .send(invalidPayload);
+
+        expect(res.statusCode).toBe(400);
+        expect(res.body).toHaveProperty('message');
+      });
+
+      it('should handle excludedIds correctly', async () => {
+        // First get all questions
+        const allQuestionsRes = await request(app).get('/api/questions');
+        if (allQuestionsRes.body.length > 0) {
+          const firstQuestion = allQuestionsRes.body[0];
+          
+          const payload = {
+            criteria: { 
+              topic: firstQuestion.topic,
+              difficulty: firstQuestion.difficulty 
+            },
+            excludedIds: [firstQuestion.question_id]
+          };
+
+          const res = await request(app)
+            .post('/api/questions/select')
+            .send(payload);
+
+          if (res.statusCode === 200) {
+            expect(res.body.question_id).not.toBe(firstQuestion.question_id);
+          } else {
+            expect([404]).toContain(res.statusCode);
+          }
+        }
+      });
+    });
+  });
+});

question-service/src/test/question.service.unit.test.ts

@@ -1,32 +1,36 @@
-import { Pool, QueryResult } from 'pg'; // Import QueryResult
-import { pool } from '../config/database'; // This is the *mocked* pool
-import {
-  selectQuestion,
-  Difficulty,
-  Question,
-} from '../services/questionService'; // Import ONLY the service
-
-// Mock the database module
+// --- FIX ---
+// jest.mock MUST be the first statement in the file.
+// This tells Jest to replace the module *before* any other code imports it.
 jest.mock('../config/database', () => {
   const actual = jest.requireActual('../config/database');
 
-  // Explicitly type the mock function to expect SQL query arguments
-  // and return a Promise that resolves to a QueryResult.
+  // Explicitly type the mock function
   const mockQuery = jest.fn<Promise<QueryResult<any>>, [string, any[]]>();
   // Set a default implementation
-  mockQuery.mockResolvedValue({ rows: [] } as unknown as QueryResult<any>); // FIX: Add 'as unknown'
+  mockQuery.mockResolvedValue({ rows: [] } as unknown as QueryResult<any>);
 
   const mockEnd = jest.fn().mockResolvedValue(undefined);
   const mockPool = { query: mockQuery, end: mockEnd };
 
   return { 
     ...actual, 
-    // Explicitly cast the exported pool to satisfy the module's type
     pool: mockPool as unknown as Pool 
   };
 });
+// --- END FIX ---
+
+
+import { Pool, QueryResult } from 'pg'; // Import QueryResult
+import {
+  selectQuestion,
+  Difficulty,
+  Question,
+} from '../services/questionService'; // Import ONLY the service
+import { pool } from '../config/database'; // This is now the *mocked* pool
 
 
+// We must cast pool.query once, outside the mock, to the correct Jest mock type.
+// This tells TypeScript what 'pool.query' is, so we can access .mock.calls etc.
 const mockedQuery = pool.query as unknown as jest.Mock<Promise<QueryResult<any>>, [string, any[]]>;
 
 describe('questionService (Unit)', () => {
@@ -36,7 +40,7 @@ describe('questionService (Unit)', () => {
     // Use the correctly typed mock
     mockedQuery.mockClear();
     // Reset to default implementation
-    mockedQuery.mockResolvedValue({ rows: [] } as unknown as QueryResult<any>); // FIX: Add 'as unknown'
+    mockedQuery.mockResolvedValue({ rows: [] } as unknown as QueryResult<any>);
   });
 
   // Test 1: Check the logic WITH excluded IDs
@@ -53,7 +57,7 @@ describe('questionService (Unit)', () => {
     };
 
     // Use the correctly typed mock
-    mockedQuery.mockResolvedValue({ rows: [mockQuestion] } as unknown as QueryResult<any>); // FIX: Add 'as unknown'
+    mockedQuery.mockResolvedValue({ rows: [mockQuestion] } as unknown as QueryResult<any>);
 
     // Call the function directly (no server, no HTTP)
     const result = await selectQuestion(criteria, excludedIds);
@@ -65,7 +69,8 @@ describe('questionService (Unit)', () => {
 
     // --- This is the "white box" part ---
     // Check the *exact* SQL string and parameters it tried to run
-    const queryArgs = mockedQuery.mock.calls[0];
+    // FIX: Add '!' to tell TypeScript 'mock.calls[0]' is not undefined
+    const queryArgs = mockedQuery.mock.calls[0]!; 
     const queryString = queryArgs[0] as string;
     const queryParams = queryArgs[1] as any[];
 
@@ -94,7 +99,8 @@ describe('questionService (Unit)', () => {
     expect(mockedQuery).toHaveBeenCalledTimes(1);
 
     // --- Check the logic again ---
-    const queryArgs = mockedQuery.mock.calls[0];
+    // FIX: Add '!' to tell TypeScript 'mock.calls[0]' is not undefined
+    const queryArgs = mockedQuery.mock.calls[0]!;
     const queryString = queryArgs[0] as string;
     const queryParams = queryArgs[1] as any[];
 

question-service/tsconfig.json

@@ -5,10 +5,14 @@
     "module": "commonjs",
     "target": "esnext",
     "lib": ["esnext"],
-    "types": ["node"],
+    "types": ["node", "jest"],
     "sourceMap": true,
     "declaration": true,
     "declarationMap": true,
+
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+
     "noUncheckedIndexedAccess": true,
     "exactOptionalPropertyTypes": true,
     "noImplicitReturns": true,
@@ -23,5 +27,6 @@
     "skipLibCheck": true
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts"]
-}
+  "exclude": ["node_modules", "dist"]
+}
+