Merge pull request #60 from AdityaDRathore/feature/db_test

Feature/db test

Author: AdityaDRathore

backend/jest.config.js

@@ -3,14 +3,11 @@ module.exports = {
   testEnvironment: 'node',
   roots: ['<rootDir>/src'],
   transform: {
-    '^.+\\.tsx?$': 'ts-jest',
+    '^.+\\.tsx?$': ['ts-jest', {
+      tsconfig: 'tsconfig.json',
+    }],
   },
   moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
   testRegex: '(/__tests__/.*|(\\.|/)(test|spec))\\.tsx?$',
   collectCoverageFrom: ['src/**/*.{ts,tsx}', '!src/**/*.d.ts'],
-  globals: {
-    'ts-jest': {
-      tsconfig: 'tsconfig.json',
-    },
-  },
 };

backend/package.json

@@ -51,6 +51,7 @@
         "eslint-config-prettier": "^9.0.0",
         "eslint-plugin-prettier": "^5.1.3",
         "jest": "^29.7.0",
+        "jest-mock-extended": "^4.0.0-beta1",
         "prettier": "^3.2.5",
         "prisma": "^6.8.2",
         "ts-jest": "^29.1.4",

backend/src/config/environment.ts

@@ -10,10 +10,10 @@ dotenv.config();
 const envSchema = z.object({
   NODE_ENV: z.enum(['development', 'test', 'production']).default('development'),
   PORT: z.string().default('4000'),
-  DATABASE_URL: z.string(),
-  JWT_SECRET: z.string(),
+  DATABASE_URL: process.env.NODE_ENV === 'test' ? z.string().optional() : z.string(),
+  JWT_SECRET: process.env.NODE_ENV === 'test' ? z.string().optional() : z.string(),
   JWT_EXPIRES_IN: z.string().default('15m'),
-  REFRESH_TOKEN_SECRET: z.string(),
+  REFRESH_TOKEN_SECRET: process.env.NODE_ENV === 'test' ? z.string().optional() : z.string(),
   REFRESH_TOKEN_EXPIRES_IN: z.string().default('7d'),
   REDIS_URL: z.string().optional(),
   CORS_ORIGIN: z.string().default('*'),
@@ -24,8 +24,26 @@ const envSchema = z.object({
 const env = envSchema.safeParse(process.env);
 
 if (!env.success) {
-  console.error('❌ Invalid environment variables:', JSON.stringify(env.error.format(), null, 4));
-  process.exit(1);
+  if (process.env.NODE_ENV === 'test') {
+    console.warn('⚠️ Running with incomplete environment in test mode');
+  } else {
+    console.error('❌ Invalid environment variables:', JSON.stringify(env.error.format(), null, 4));
+    process.exit(1);
+  }
 }
 
-export const config = env.data;
+// Export validated config or fallbacks for test environment
+export const config = env.success
+  ? env.data
+  : {
+      NODE_ENV: process.env.NODE_ENV ?? 'test',
+      PORT: process.env.PORT ?? '4000',
+      LOG_LEVEL: process.env.LOG_LEVEL ?? 'error',
+      DATABASE_URL:
+        process.env.DATABASE_URL ?? 'postgresql://postgres:postgres@localhost:5432/test_db',
+      JWT_SECRET: process.env.JWT_SECRET ?? 'test_secret',
+      JWT_EXPIRES_IN: process.env.JWT_EXPIRES_IN ?? '15m',
+      REFRESH_TOKEN_SECRET: process.env.REFRESH_TOKEN_SECRET ?? 'test_refresh_secret',
+      REFRESH_TOKEN_EXPIRES_IN: process.env.REFRESH_TOKEN_EXPIRES_IN ?? '7d',
+      CORS_ORIGIN: process.env.CORS_ORIGIN ?? '*',
+    };

backend/src/tests/database/db-connection.test.ts

@@ -1,95 +1,114 @@
-import { PrismaClient, Prisma } from '@prisma/client';
-import { config } from '../../config/environment';
+import { Prisma } from '@prisma/client';
 import logger from '../../utils/logger';
+import { createMockPrismaClient } from '../prisma-mock';
+import { mockDeep } from 'jest-mock-extended';
+
+// Replace jest-fail-fast which can't be found
+const fail = (message: string): never => {
+  throw new Error(message);
+};
 
 describe('Database Connection', () => {
-  let prisma: PrismaClient;
-
-  beforeAll(() => {
-    // Environment-aware configuration - remove unused variable
-    prisma = new PrismaClient({
-      log: [
-        { level: 'query', emit: 'event' },
-        { level: 'error', emit: 'stdout' },
-      ],
-    });
-
-    // Log query performance in non-test environments
-    if (config.NODE_ENV !== 'test') {
-      prisma.$on('query' as never, (e: Prisma.QueryEvent) => {
-        logger.debug(`Query executed in ${e.duration}ms: ${e.query}`);
-      });
-    }
-  });
+  let prisma: ReturnType<typeof createMockPrismaClient>;
 
-  afterAll(async () => {
-    await prisma.$disconnect();
+  beforeEach(() => {
+    prisma = createMockPrismaClient();
   });
 
   it('should connect to the database successfully', async () => {
-    if (!config.DATABASE_URL) {
-      console.warn('DATABASE_URL not found, skipping test');
-      return;
-    }
+    // Mock the query response
+    prisma.$queryRaw.mockResolvedValue([{ result: 1 }]);
 
     const result = await prisma.$queryRaw`SELECT 1 as result`;
     expect(result).toBeDefined();
+    expect(result).toEqual([{ result: 1 }]);
   });
 
   it('should handle connection pool correctly', async () => {
-    if (!config.DATABASE_URL) return;
+    // Mock multiple parallel queries
+    for (let i = 0; i < 5; i++) {
+      prisma.$queryRaw.mockResolvedValueOnce([{ value: Math.random() }]);
+    }
 
-    // Run multiple queries in parallel to test connection pool
     const promises = Array(5)
       .fill(0)
       .map(() => prisma.$queryRaw`SELECT random() as value`);
 
     const results = await Promise.all(promises);
     expect(results.length).toBe(5);
+    expect(results.every(r => Array.isArray(r) && r.length === 1)).toBe(true);
   });
 
   it('should handle transaction rollback correctly', async () => {
-    if (!config.DATABASE_URL) return;
+    // Mock successful transaction
+    const mockTx = mockDeep<Prisma.TransactionClient>();
+
+    // First mock a successful query
+    mockTx.$executeRaw.mockResolvedValueOnce(1);
+
+    // Then mock a failing query
+    const duplicateKeyError = new Error('Duplicate key value');
+    mockTx.$executeRaw.mockRejectedValueOnce(duplicateKeyError);
+
+    // Fix the callback type to match Prisma's $transaction overloads
+    // Define transaction related types
+    type TransactionCallback<T> = (tx: Prisma.TransactionClient) => Promise<T>;
+    type TransactionQueries<T> = Array<Promise<T>>;
+
+    prisma.$transaction.mockImplementation(
+      <T>(
+        callbackOrQueries: TransactionCallback<T> | TransactionQueries<T>,
+      ): Promise<T | Array<T>> => {
+        if (typeof callbackOrQueries === 'function') {
+          return callbackOrQueries(mockTx).catch(error => {
+            throw error instanceof Error ? error : new Error(String(error));
+          });
+        }
+        // Handle the array of queries case
+        return Promise.all(callbackOrQueries);
+      },
+    );
 
-    // Test transaction rollback
     try {
       await prisma.$transaction(async tx => {
         // This should succeed
         await tx.$executeRaw`CREATE TEMPORARY TABLE test_table (id SERIAL PRIMARY KEY)`;
-
-        // This will deliberately fail due to duplicate PK
+        // This will deliberately fail
         await tx.$executeRaw`INSERT INTO test_table (id) VALUES (1), (1)`;
       });
-
       fail('Transaction should have failed');
-    } catch (error) {
-      // Transaction should fail and roll back
+    } catch (error: unknown) {
       expect(error).toBeDefined();
+      expect(error).toEqual(duplicateKeyError);
     }
   });
 
   it('should handle connection errors gracefully', async () => {
-    // Create a client with invalid credentials to test error handling
-    // Use an environment variable or generate an invalid URL without credentials
-    const invalidDatabaseUrl =
-      process.env.TEST_INVALID_DB_URL ??
-      `postgresql://invalid_user:${Buffer.from(Date.now().toString()).toString('base64')}@non-existent-host:5432/invalid_db`;
-
-    const badClient = new PrismaClient({
-      datasources: {
-        db: {
-          url: invalidDatabaseUrl,
-        },
-      },
-    });
+    // Instead of creating a real bad client, we'll mock a connection error
+    // Fix constructor arguments to match expected signature
+    const mockError = new Prisma.PrismaClientInitializationError(
+      "Can't reach database server",
+      '4.5.0',
+    );
+
+    // No need to set clientVersion property as it's now provided in the constructor
+
+    prisma.$queryRaw.mockRejectedValueOnce(mockError);
 
     try {
-      await badClient.$queryRaw`SELECT 1`;
-      fail('Query should have failed with invalid credentials');
-    } catch (error) {
+      await prisma.$queryRaw`SELECT 1`;
+      fail('Query should have failed with database connection error');
+    } catch (error: unknown) {
+      // Add proper error handling logic to satisfy SonarQube
       expect(error).toBeDefined();
-    } finally {
-      await badClient.$disconnect();
+      expect(error).toBe(mockError);
+
+      if (error instanceof Prisma.PrismaClientInitializationError) {
+        expect(error.message).toContain("Can't reach database server");
+        logger.error(`Database connection error: ${error.message}`);
+      } else {
+        fail('Error should be a PrismaClientInitializationError');
+      }
     }
   });
 });

backend/src/tests/database/db-error-handling.test.ts

@@ -1,19 +1,24 @@
-import { PrismaClient } from '@prisma/client';
+import { Prisma } from '@prisma/client';
 import { withErrorHandling, handlePrismaError } from '../../utils/db-errors';
 import { AppError } from '../../utils/errors';
+import { createMockPrismaClient } from '../prisma-mock';
 
 describe('Database Error Handling', () => {
-  let prisma: PrismaClient;
+  let prisma: ReturnType<typeof createMockPrismaClient>;
 
-  beforeAll(() => {
-    prisma = new PrismaClient();
-  });
-
-  afterAll(async () => {
-    await prisma.$disconnect();
+  beforeEach(() => {
+    prisma = createMockPrismaClient();
   });
 
   it('should handle record not found errors', async () => {
+    // Mock a record not found error
+    const notFoundError = new Prisma.PrismaClientKnownRequestError('Record not found', {
+      code: 'P2001',
+      clientVersion: '4.5.0',
+    });
+
+    prisma.user.findUniqueOrThrow.mockRejectedValueOnce(notFoundError);
+
     try {
       await withErrorHandling(async () => {
         return await prisma.user.findUniqueOrThrow({
@@ -28,22 +33,22 @@ describe('Database Error Handling', () => {
   });
 
   it('should handle unique constraint errors', async () => {
-    // This test requires existing data or setup
-    // For now, we'll just mock the error
-    const mockPrismaError = {
-      code: 'P2002',
-      clientVersion: '4.5.0',
-      meta: { target: ['user_email'] },
-      message: 'Unique constraint failed on the fields: (`user_email`)',
-    };
-
-    const error = handlePrismaError(mockPrismaError);
+    // Create a proper PrismaClientKnownRequestError for unique constraint
+    const uniqueError = new Prisma.PrismaClientKnownRequestError(
+      'Unique constraint failed on the fields: (`user_email`)',
+      {
+        code: 'P2002',
+        clientVersion: '4.5.0',
+        meta: { target: ['user_email'] },
+      },
+    );
+
+    const error = handlePrismaError(uniqueError);
     expect(error.statusCode).toBe(409); // Conflict
     expect(error.message).toContain('already exists');
   });
 
   it('should pass through successful operations', async () => {
-    // Test with a query that should succeed
     const result = await withErrorHandling(async () => {
       return 'success';
     });

backend/src/tests/database/db-performance.test.ts

@@ -1,42 +1,49 @@
-import { PrismaClient } from '@prisma/client';
 import { createPerformanceTest, DatabasePerformance } from '../../utils/db-performance';
 import fs from 'fs';
-import path from 'path';
-import logger from '../../utils/logger';
+import { createMockPrismaClient } from '../prisma-mock';
+
+// Mock logger to avoid file system operations
+jest.mock('../../utils/logger', () => ({
+  info: jest.fn(),
+  error: jest.fn(),
+  warn: jest.fn(),
+  debug: jest.fn(),
+}));
+
+// More complete fs mock including stat function needed by Winston
+jest.mock('fs', () => ({
+  existsSync: jest.fn().mockReturnValue(true),
+  mkdirSync: jest.fn(),
+  writeFileSync: jest.fn(),
+  stat: jest.fn().mockImplementation((path, callback) => {
+    callback(null, { isDirectory: () => true });
+  }),
+  createWriteStream: jest.fn().mockReturnValue({
+    on: jest.fn(),
+    write: jest.fn(),
+    end: jest.fn(),
+    once: jest.fn(),
+  }),
+}));
 
 describe('Database Performance Baseline', () => {
-  let prisma: PrismaClient;
+  let prisma: ReturnType<typeof createMockPrismaClient>;
   let performanceMonitor: DatabasePerformance;
 
-  beforeAll(() => {
-    prisma = new PrismaClient();
+  beforeEach(() => {
+    prisma = createMockPrismaClient();
     performanceMonitor = new DatabasePerformance(prisma, 'test');
   });
 
-  afterAll(async () => {
-    await prisma.$disconnect();
-  });
-
   it('should establish performance baseline for key queries', async () => {
-    // Skip in CI environments
-    if (process.env.CI === 'true') {
-      logger.info('Skipping performance test in CI environment');
-      return;
-    }
+    // Mock necessary Prisma methods
+    prisma.user.findMany.mockResolvedValue([]);
+    prisma.lab.findFirst.mockResolvedValue(null);
 
-    const report = await createPerformanceTest(prisma);
-
-    // Save the report to a file for historical comparison
-    const reportsDir = path.join(__dirname, '../../../performance-reports');
-    if (!fs.existsSync(reportsDir)) {
-      fs.mkdirSync(reportsDir, { recursive: true });
-    }
+    // Mock fs methods
+    (fs.existsSync as jest.Mock).mockReturnValue(false);
 
-    const timestamp = new Date().toISOString().replace(/:/g, '-');
-    fs.writeFileSync(
-      path.join(reportsDir, `performance-baseline-${timestamp}.json`),
-      JSON.stringify(report, null, 2),
-    );
+    const report = await createPerformanceTest(prisma);
 
     // Basic assertions to ensure the test ran
     expect(report.queries.length).toBeGreaterThan(0);
@@ -45,6 +52,8 @@ describe('Database Performance Baseline', () => {
 
   // Add tests for specific high-impact queries
   it('should measure lab booking query performance', async () => {
+    prisma.lab.findMany.mockResolvedValue([]);
+
     const result = await performanceMonitor.measureQuery('Find available labs', async () => {
       return prisma.lab.findMany({
         where: { status: 'ACTIVE' },