imlil 1.0.1

package/agentTestSandbox/parallel-test/server/__tests__/models/user.model.test.ts

@@ -0,0 +1,111 @@
+import { PrismaClient } from '@prisma/client';
+import { User } from '../models/user.model';
+
+// Mock Prisma Client
+jest.mock('@prisma/client');
+
+describe('User Model', () => {
+  let prisma: jest.Mocked<PrismaClient>;
+
+  beforeEach(() => {
+    // Clear all mocks before each test
+    jest.clearAllMocks();
+    prisma = new PrismaClient() as jest.Mocked<PrismaClient>;
+  });
+
+  describe('createUser', () => {
+    const mockUserData = {
+      email: 'test@example.com',
+      password: 'hashedPassword123',
+      username: 'testuser',
+    };
+
+    it('should create a new user successfully', async () => {
+      const expectedUser = { 
+        id: 1, 
+        ...mockUserData, 
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      prisma.user.create.mockResolvedValue(expectedUser);
+
+      const result = await User.create(mockUserData);
+      
+      expect(prisma.user.create).toHaveBeenCalledWith({
+        data: mockUserData
+      });
+      expect(result).toEqual(expectedUser);
+    });
+
+    it('should throw an error if user creation fails', async () => {
+      const error = new Error('Database error');
+      prisma.user.create.mockRejectedValue(error);
+
+      await expect(User.create(mockUserData)).rejects.toThrow('Database error');
+    });
+  });
+
+  describe('findByEmail', () => {
+    const email = 'test@example.com';
+
+    it('should find user by email', async () => {
+      const expectedUser = {
+        id: 1,
+        email,
+        username: 'testuser',
+        password: 'hashedPassword123',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      prisma.user.findUnique.mockResolvedValue(expectedUser);
+
+      const result = await User.findByEmail(email);
+
+      expect(prisma.user.findUnique).toHaveBeenCalledWith({
+        where: { email }
+      });
+      expect(result).toEqual(expectedUser);
+    });
+
+    it('should return null if user not found', async () => {
+      prisma.user.findUnique.mockResolvedValue(null);
+
+      const result = await User.findByEmail(email);
+
+      expect(prisma.user.findUnique).toHaveBeenCalledWith({
+        where: { email }
+      });
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('updateUser', () => {
+    const userId = 1;
+    const updateData = {
+      username: 'newusername'
+    };
+
+    it('should update user successfully', async () => {
+      const expectedUser = {
+        id: userId,
+        email: 'test@example.com',
+        username: 'newusername',
+        password: 'hashedPassword123',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      };
+
+      prisma.user.update.mockResolvedValue(expectedUser);
+
+      const result = await User.update(userId, updateData);
+
+      expect(prisma.user.update).toHaveBeenCalledWith({
+        where: { id: userId },
+        data: updateData
+      });
+      expect(result).toEqual(expectedUser);
+    });
+  });
+});

package/agentTestSandbox/parallel-test/server/config/__tests__/swagger.test.ts

@@ -0,0 +1,128 @@
+import swaggerConfig from '../swagger';
+import { OpenAPIV3 } from 'openapi-types';
+
+describe('Swagger Configuration', () => {
+  let config: OpenAPIV3.Document;
+
+  beforeAll(() => {
+    config = swaggerConfig;
+  });
+
+  describe('Basic Configuration', () => {
+    test('should have valid OpenAPI specification', () => {
+      expect(config.openapi).toBe('3.0.0');
+      expect(config.info).toBeDefined();
+      expect(config.info.title).toBe('Admin Dashboard API');
+      expect(config.info.version).toBeDefined();
+    });
+
+    test('should include server configurations', () => {
+      expect(config.servers).toBeDefined();
+      expect(Array.isArray(config.servers)).toBe(true);
+      expect(config.servers.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('API Endpoints Documentation', () => {
+    test('should include authentication paths', () => {
+      expect(config.paths['/api/auth/login']).toBeDefined();
+      expect(config.paths['/api/auth/register']).toBeDefined();
+      expect(config.paths['/api/auth/refresh']).toBeDefined();
+    });
+
+    test('should include user management paths', () => {
+      expect(config.paths['/api/users']).toBeDefined();
+      expect(config.paths['/api/users/{id}']).toBeDefined();
+    });
+
+    test('should include dashboard paths', () => {
+      expect(config.paths['/api/dashboard/stats']).toBeDefined();
+      expect(config.paths['/api/dashboard/analytics']).toBeDefined();
+    });
+  });
+
+  describe('Security Schemes', () => {
+    test('should define security schemes', () => {
+      expect(config.components?.securitySchemes).toBeDefined();
+      expect(config.components?.securitySchemes?.bearerAuth).toBeDefined();
+    });
+
+    test('should have proper bearer auth configuration', () => {
+      const bearerAuth = config.components?.securitySchemes?.bearerAuth;
+      expect(bearerAuth?.type).toBe('http');
+      expect(bearerAuth?.scheme).toBe('bearer');
+      expect(bearerAuth?.bearerFormat).toBe('JWT');
+    });
+  });
+
+  describe('Schema Definitions', () => {
+    test('should include common request/response schemas', () => {
+      expect(config.components?.schemas?.Error).toBeDefined();
+      expect(config.components?.schemas?.Success).toBeDefined();
+    });
+
+    test('should include user-related schemas', () => {
+      expect(config.components?.schemas?.User).toBeDefined();
+      expect(config.components?.schemas?.UserCreate).toBeDefined();
+      expect(config.components?.schemas?.UserUpdate).toBeDefined();
+    });
+
+    test('should include authentication-related schemas', () => {
+      expect(config.components?.schemas?.LoginRequest).toBeDefined();
+      expect(config.components?.schemas?.LoginResponse).toBeDefined();
+      expect(config.components?.schemas?.RegisterRequest).toBeDefined();
+    });
+  });
+});
+
+// README Validation Tests
+describe('README Validation', () => {
+  const fs = require('fs');
+  const path = require('path');
+  
+  let readmeContent: string;
+
+  beforeAll(() => {
+    readmeContent = fs.readFileSync(path.join(process.cwd(), 'README.md'), 'utf8');
+  });
+
+  test('should include project title and description', () => {
+    expect(readmeContent).toMatch(/# Admin Dashboard/);
+    expect(readmeContent).toMatch(/## Description/);
+  });
+
+  test('should include installation instructions', () => {
+    expect(readmeContent).toMatch(/## Installation/);
+    expect(readmeContent).toMatch(/npm install/);
+  });
+
+  test('should include environment setup section', () => {
+    expect(readmeContent).toMatch(/## Environment Setup/);
+    expect(readmeContent).toMatch(/\.env/);
+  });
+
+  test('should include API documentation section', () => {
+    expect(readmeContent).toMatch(/## API Documentation/);
+    expect(readmeContent).toMatch(/Swagger/);
+  });
+
+  test('should include tech stack information', () => {
+    expect(readmeContent).toMatch(/## Tech Stack/);
+    expect(readmeContent).toMatch(/React/);
+    expect(readmeContent).toMatch(/Node\.js/);
+    expect(readmeContent).toMatch(/PostgreSQL/);
+  });
+
+  test('should include development commands', () => {
+    expect(readmeContent).toMatch(/## Available Scripts/);
+    expect(readmeContent).toMatch(/npm run/);
+  });
+
+  test('should include deployment instructions', () => {
+    expect(readmeContent).toMatch(/## Deployment/);
+  });
+
+  test('should include project structure', () => {
+    expect(readmeContent).toMatch(/## Project Structure/);
+  });
+});

package/agentTestSandbox/parallel-test/server/controllers/__tests__/auth.controller.test.ts

@@ -0,0 +1,178 @@
+import { Request, Response } from 'express';
+import { AuthController } from '../auth.controller';
+import prisma from '../../config/database';
+import bcrypt from 'bcrypt';
+import jwt from 'jsonwebtoken';
+
+// Mock dependencies
+jest.mock('../../config/database');
+jest.mock('bcrypt');
+jest.mock('jsonwebtoken');
+
+describe('AuthController', () => {
+  let mockRequest: Partial<Request>;
+  let mockResponse: Partial<Response>;
+  let mockNext: jest.Mock;
+
+  beforeEach(() => {
+    mockRequest = {
+      body: {},
+    };
+    mockResponse = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn().mockReturnThis(),
+    };
+    mockNext = jest.fn();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('register', () => {
+    const validRegisterData = {
+      email: 'test@example.com',
+      password: 'Password123!',
+      name: 'Test User',
+    };
+
+    it('should successfully register a new user', async () => {
+      // Arrange
+      mockRequest.body = validRegisterData;
+      const hashedPassword = 'hashedPassword123';
+      (bcrypt.hash as jest.Mock).mockResolvedValue(hashedPassword);
+      (prisma.user.create as jest.Mock).mockResolvedValue({
+        id: 1,
+        ...validRegisterData,
+        password: hashedPassword,
+      });
+
+      // Act
+      await AuthController.register(
+        mockRequest as Request,
+        mockResponse as Response,
+        mockNext
+      );
+
+      // Assert
+      expect(bcrypt.hash).toHaveBeenCalledWith(validRegisterData.password, 10);
+      expect(prisma.user.create).toHaveBeenCalledWith({
+        data: {
+          ...validRegisterData,
+          password: hashedPassword,
+        },
+      });
+      expect(mockResponse.status).toHaveBeenCalledWith(201);
+      expect(mockResponse.json).toHaveBeenCalledWith({
+        message: 'User registered successfully',
+        user: expect.objectContaining({
+          email: validRegisterData.email,
+          name: validRegisterData.name,
+        }),
+      });
+    });
+
+    it('should handle duplicate email registration', async () => {
+      // Arrange
+      mockRequest.body = validRegisterData;
+      (prisma.user.create as jest.Mock).mockRejectedValue({
+        code: 'P2002',
+        meta: { target: ['email'] },
+      });
+
+      // Act
+      await AuthController.register(
+        mockRequest as Request,
+        mockResponse as Response,
+        mockNext
+      );
+
+      // Assert
+      expect(mockResponse.status).toHaveBeenCalledWith(400);
+      expect(mockResponse.json).toHaveBeenCalledWith({
+        message: 'Email already exists',
+      });
+    });
+  });
+
+  describe('login', () => {
+    const validLoginData = {
+      email: 'test@example.com',
+      password: 'Password123!',
+    };
+
+    it('should successfully login a user', async () => {
+      // Arrange
+      mockRequest.body = validLoginData;
+      const mockUser = {
+        id: 1,
+        ...validLoginData,
+        password: 'hashedPassword',
+      };
+      (prisma.user.findUnique as jest.Mock).mockResolvedValue(mockUser);
+      (bcrypt.compare as jest.Mock).mockResolvedValue(true);
+      (jwt.sign as jest.Mock).mockReturnValue('mockToken');
+
+      // Act
+      await AuthController.login(
+        mockRequest as Request,
+        mockResponse as Response,
+        mockNext
+      );
+
+      // Assert
+      expect(prisma.user.findUnique).toHaveBeenCalledWith({
+        where: { email: validLoginData.email },
+      });
+      expect(bcrypt.compare).toHaveBeenCalledWith(
+        validLoginData.password,
+        mockUser.password
+      );
+      expect(jwt.sign).toHaveBeenCalled();
+      expect(mockResponse.status).toHaveBeenCalledWith(200);
+      expect(mockResponse.json).toHaveBeenCalledWith({
+        message: 'Login successful',
+        token: 'mockToken',
+        user: expect.objectContaining({
+          email: validLoginData.email,
+        }),
+      });
+    });
+
+    it('should handle invalid credentials', async () => {
+      // Arrange
+      mockRequest.body = validLoginData;
+      (prisma.user.findUnique as jest.Mock).mockResolvedValue(null);
+
+      // Act
+      await AuthController.login(
+        mockRequest as Request,
+        mockResponse as Response,
+        mockNext
+      );
+
+      // Assert
+      expect(mockResponse.status).toHaveBeenCalledWith(401);
+      expect(mockResponse.json).toHaveBeenCalledWith({
+        message: 'Invalid credentials',
+      });
+    });
+  });
+
+  describe('logout', () => {
+    it('should successfully logout a user', async () => {
+      // Act
+      await AuthController.logout(
+        mockRequest as Request,
+        mockResponse as Response,
+        mockNext
+      );
+
+      // Assert
+      expect(mockResponse.status).toHaveBeenCalledWith(200);
+      expect(mockResponse.json).toHaveBeenCalledWith({
+        message: 'Logged out successfully',
+      });
+    });
+  });
+});

package/agentTestSandbox/parallel-test/server/controllers/__tests__/user.controller.test.ts

@@ -0,0 +1,105 @@
+import { Request, Response } from 'express';
+import { UserController } from '../user.controller';
+import prisma from '../../config/database';
+
+// Mock Prisma
+jest.mock('../../config/database', () => ({
+  user: {
+    create: jest.fn(),
+    findMany: jest.fn(),
+    findUnique: jest.fn(),
+    update: jest.fn(),
+    delete: jest.fn(),
+  },
+}));
+
+describe('UserController', () => {
+  let mockRequest: Partial<Request>;
+  let mockResponse: Partial<Response>;
+  let mockNext: jest.Mock;
+
+  beforeEach(() => {
+    mockRequest = {
+      body: {},
+      params: {},
+    };
+    mockResponse = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn().mockReturnThis(),
+    };
+    mockNext = jest.fn();
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('createUser', () => {
+    const validUserData = {
+      email: 'test@example.com',
+      password: 'Password123!',
+      firstName: 'John',
+      lastName: 'Doe',
+      role: 'USER',
+    };
+
+    it('should create a new user successfully', async () => {
+      mockRequest.body = validUserData;
+      const mockCreatedUser = { id: 1, ...validUserData };
+      
+      (prisma.user.create as jest.Mock).mockResolvedValue(mockCreatedUser);
+
+      await UserController.createUser(
+        mockRequest as Request,
+        mockResponse as Response,
+        mockNext
+      );
+
+      expect(prisma.user.create).toHaveBeenCalledWith({
+        data: validUserData,
+      });
+      expect(mockResponse.status).toHaveBeenCalledWith(201);
+      expect(mockResponse.json).toHaveBeenCalledWith({
+        success: true,
+        data: mockCreatedUser,
+      });
+    });
+
+    it('should handle validation errors', async () => {
+      mockRequest.body = { email: 'invalid-email' };
+
+      await UserController.createUser(
+        mockRequest as Request,
+        mockResponse as Response,
+        mockNext
+      );
+
+      expect(mockNext).toHaveBeenCalled();
+      expect(mockNext.mock.calls[0][0]).toBeInstanceOf(Error);
+    });
+
+    it('should handle duplicate email errors', async () => {
+      mockRequest.body = validUserData;
+      
+      (prisma.user.create as jest.Mock).mockRejectedValue({
+        code: 'P2002',
+        meta: { target: ['email'] },
+      });
+
+      await UserController.createUser(
+        mockRequest as Request,
+        mockResponse as Response,
+        mockNext
+      );
+
+      expect(mockNext).toHaveBeenCalled();
+      expect(mockNext.mock.calls[0][0].message).toContain('Email already exists');
+    });
+  });
+
+  // Additional test cases could include:
+  // - getUsers
+  // - getUserById
+  // - updateUser
+  // - deleteUser
+});

package/agentTestSandbox/parallel-test/server/controllers/auth.controller.ts

@@ -0,0 +1,148 @@
+import { Request, Response } from 'express';
+import { PrismaClient } from '@prisma/client';
+import bcrypt from 'bcrypt';
+import jwt from 'jsonwebtoken';
+import { Joi } from 'joi';
+
+const prisma = new PrismaClient();
+
+// Validation schemas
+const registerSchema = Joi.object({
+  email: Joi.string().email().required(),
+  password: Joi.string().min(8).required(),
+  name: Joi.string().required(),
+});
+
+const loginSchema = Joi.object({
+  email: Joi.string().email().required(),
+  password: Joi.string().required(),
+});
+
+export class AuthController {
+  // Register new user
+  static async register(req: Request, res: Response) {
+    try {
+      // Validate request body
+      const { error } = registerSchema.validate(req.body);
+      if (error) {
+        return res.status(400).json({ error: error.details[0].message });
+      }
+
+      const { email, password, name } = req.body;
+
+      // Check if user already exists
+      const existingUser = await prisma.user.findUnique({
+        where: { email },
+      });
+
+      if (existingUser) {
+        return res.status(400).json({ error: 'User already exists' });
+      }
+
+      // Hash password
+      const salt = await bcrypt.genSalt(10);
+      const hashedPassword = await bcrypt.hash(password, salt);
+
+      // Create user
+      const user = await prisma.user.create({
+        data: {
+          email,
+          password: hashedPassword,
+          name,
+        },
+      });
+
+      // Generate JWT token
+      const token = jwt.sign(
+        { userId: user.id },
+        process.env.JWT_SECRET || 'default-secret',
+        { expiresIn: '24h' }
+      );
+
+      // Return user data (excluding password) and token
+      const { password: _, ...userWithoutPassword } = user;
+      return res.status(201).json({
+        user: userWithoutPassword,
+        token,
+      });
+    } catch (error) {
+      console.error('Register error:', error);
+      return res.status(500).json({ error: 'Internal server error' });
+    }
+  }
+
+  // Login user
+  static async login(req: Request, res: Response) {
+    try {
+      // Validate request body
+      const { error } = loginSchema.validate(req.body);
+      if (error) {
+        return res.status(400).json({ error: error.details[0].message });
+      }
+
+      const { email, password } = req.body;
+
+      // Find user
+      const user = await prisma.user.findUnique({
+        where: { email },
+      });
+
+      if (!user) {
+        return res.status(401).json({ error: 'Invalid credentials' });
+      }
+
+      // Verify password
+      const validPassword = await bcrypt.compare(password, user.password);
+      if (!validPassword) {
+        return res.status(401).json({ error: 'Invalid credentials' });
+      }
+
+      // Generate JWT token
+      const token = jwt.sign(
+        { userId: user.id },
+        process.env.JWT_SECRET || 'default-secret',
+        { expiresIn: '24h' }
+      );
+
+      // Return user data (excluding password) and token
+      const { password: _, ...userWithoutPassword } = user;
+      return res.status(200).json({
+        user: userWithoutPassword,
+        token,
+      });
+    } catch (error) {
+      console.error('Login error:', error);
+      return res.status(500).json({ error: 'Internal server error' });
+    }
+  }
+
+  // Get current user
+  static async getCurrentUser(req: Request, res: Response) {
+    try {
+      const userId = req.user?.id; // Set by auth middleware
+      if (!userId) {
+        return res.status(401).json({ error: 'Unauthorized' });
+      }
+
+      const user = await prisma.user.findUnique({
+        where: { id: userId },
+      });
+
+      if (!user) {
+        return res.status(404).json({ error: 'User not found' });
+      }
+
+      // Return user data without password
+      const { password: _, ...userWithoutPassword } = user;
+      return res.status(200).json(userWithoutPassword);
+    } catch (error) {
+      console.error('Get current user error:', error);
+      return res.status(500).json({ error: 'Internal server error' });
+    }
+  }
+
+  // Logout (token invalidation would be handled on the client side)
+  static async logout(_req: Request, res: Response) {
+    return res.status(200).json({ message: 'Logged out successfully' });
+  }
+}