create-theta-code 1.0.1

package/templates/pg-js/tests/integration/user.routes.test.js

@@ -0,0 +1,95 @@
+// tests/integration/user.routes.test.js — Integration tests for HTTP layer. Real app, mocked DB.
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import request from 'supertest';
+import { createApp } from '../../src/config/app.config.js';
+import * as userRepository from '../../src/modules/user/user.repository.js';
+
+vi.mock('../../src/modules/user/user.repository.js');
+
+describe('User Routes', () => {
+  let app;
+
+  beforeEach(() => {
+    app = createApp();
+    vi.clearAllMocks();
+  });
+
+  describe('POST /api/v1/users/register', () => {
+    it('should register a new user', async () => {
+      vi.mocked(userRepository.findByEmailPublic).mockResolvedValueOnce(null);
+      vi.mocked(userRepository.create).mockResolvedValueOnce({
+        id: 1,
+        email: 'test@example.com',
+        firstName: 'John',
+        lastName: 'Doe',
+      });
+
+      const response = await request(app)
+        .post('/api/v1/users/register')
+        .send({
+          email: 'test@example.com',
+          firstName: 'John',
+          lastName: 'Doe',
+          password: 'Password123!',
+        });
+
+      expect(response.status).toBe(201);
+      expect(response.body).toHaveProperty('success', true);
+      expect(response.body).toHaveProperty('data.user');
+    });
+
+    it('should return 400 on validation error', async () => {
+      const response = await request(app)
+        .post('/api/v1/users/register')
+        .send({
+          email: 'invalid-email',
+          firstName: 'John',
+          lastName: 'Doe',
+          password: 'pass',
+        });
+
+      expect(response.status).toBe(400);
+      expect(response.body).toHaveProperty('success', false);
+    });
+  });
+
+  describe('POST /api/v1/users/login', () => {
+    it('should login successfully', async () => {
+      const user = {
+        id: 1,
+        email: 'test@example.com',
+        password: '$2a$12$abcdefghijklmnopqrstuvwxyz',
+      };
+
+      vi.mocked(userRepository.findByEmail).mockResolvedValueOnce(user);
+
+      const response = await request(app)
+        .post('/api/v1/users/login')
+        .send({
+          email: 'test@example.com',
+          password: 'Password123!',
+        });
+
+      expect(response.status).toBeDefined();
+    });
+  });
+
+  describe('GET /health', () => {
+    it('should return health status', async () => {
+      const response = await request(app).get('/health');
+
+      expect(response.status).toBe(200);
+      expect(response.body).toHaveProperty('status', 'UP');
+    });
+  });
+
+  describe('404 handler', () => {
+    it('should return 404 for unknown routes', async () => {
+      const response = await request(app).get('/api/v1/unknown');
+
+      expect(response.status).toBe(404);
+      expect(response.body).toHaveProperty('success', false);
+    });
+  });
+});

package/templates/pg-js/tests/unit/user.service.test.js

@@ -0,0 +1,96 @@
+// tests/unit/user.service.test.js — Unit tests for business logic. Mocked repository.
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import * as userService from '../../src/modules/user/user.service.js';
+import * as userRepository from '../../src/modules/user/user.repository.js';
+import { AppError } from '../../src/utils/AppError.js';
+import bcryptjs from 'bcryptjs';
+
+vi.mock('../../src/modules/user/user.repository.js');
+vi.mock('bcryptjs');
+
+describe('User Service', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe('register', () => {
+    it('should create a new user successfully', async () => {
+      const userData = {
+        id: 1,
+        email: 'test@example.com',
+        firstName: 'John',
+        lastName: 'Doe',
+        password: 'hashedPassword123',
+      };
+
+      vi.mocked(userRepository.findByEmailPublic).mockResolvedValueOnce(null);
+      vi.mocked(bcryptjs.hash).mockResolvedValueOnce('hashedPassword123');
+      vi.mocked(userRepository.create).mockResolvedValueOnce(userData);
+
+      const result = await userService.register(
+        'test@example.com',
+        'John',
+        'Doe',
+        'password123'
+      );
+
+      expect(result).toEqual(userData);
+      expect(userRepository.findByEmailPublic).toHaveBeenCalledWith('test@example.com');
+      expect(bcryptjs.hash).toHaveBeenCalledWith('password123', 12);
+    });
+
+    it('should throw error if email exists', async () => {
+      vi.mocked(userRepository.findByEmailPublic).mockResolvedValueOnce({ email: 'test@example.com' });
+
+      await expect(
+        userService.register('test@example.com', 'John', 'Doe', 'password123')
+      ).rejects.toThrow(AppError);
+    });
+  });
+
+  describe('login', () => {
+    it('should return user and tokens on successful login', async () => {
+      const user = {
+        id: 1,
+        email: 'test@example.com',
+        password: 'hashedPassword123',
+      };
+
+      vi.mocked(userRepository.findByEmail).mockResolvedValueOnce(user);
+      vi.mocked(bcryptjs.compare).mockResolvedValueOnce(true);
+
+      const result = await userService.login('test@example.com', 'password123');
+
+      expect(result).toHaveProperty('user');
+      expect(result).toHaveProperty('token');
+      expect(result).toHaveProperty('refreshToken');
+    });
+
+    it('should throw error on invalid credentials', async () => {
+      vi.mocked(userRepository.findByEmail).mockResolvedValueOnce(null);
+
+      await expect(
+        userService.login('test@example.com', 'password123')
+      ).rejects.toThrow(AppError);
+    });
+  });
+
+  describe('getUserById', () => {
+    it('should return user by id', async () => {
+      const user = { id: 1, email: 'test@example.com' };
+      vi.mocked(userRepository.findById).mockResolvedValueOnce(user);
+
+      const result = await userService.getUserById(1);
+
+      expect(result).toEqual(user);
+      expect(userRepository.findById).toHaveBeenCalledWith(1);
+    });
+
+    it('should throw error if user not found', async () => {
+      vi.mocked(userRepository.findById).mockResolvedValueOnce(null);
+
+      await expect(userService.getUserById(1)).rejects.toThrow(AppError);
+    });
+  });
+});