add changes

tests/auth.controller.test.js

@@ -0,0 +1,337 @@
+const authController = require('../controllers/auth.controller');
+const { User } = require('../models');
+const bcrypt = require('bcrypt');
+const jwt = require('jsonwebtoken');
+
+// Mock dependencies
+jest.mock('../models');
+jest.mock('bcrypt');
+jest.mock('jsonwebtoken');
+
+describe('Auth Controller', () => {
+  let req, res;
+
+  beforeEach(() => {
+    req = {
+      body: {},
+      user: null
+    };
+    res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn().mockReturnThis()
+    };
+    jest.clearAllMocks();
+  });
+
+  describe('register', () => {
+    it('should register a new user successfully', async () => {
+      req.body = {
+        username: 'testuser',
+        email: 'test@example.com',
+        password: 'Test123!@#'
+      };
+
+      User.findOne = jest.fn().mockResolvedValue(null);
+      User.create = jest.fn().mockResolvedValue({
+        id: '123',
+        username: 'testuser',
+        email: 'test@example.com',
+        role: 'user'
+      });
+      jwt.sign = jest.fn().mockReturnValue('mock-token');
+
+      await authController.register(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(201);
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          success: true,
+          message: 'User registered successfully',
+          data: expect.objectContaining({
+            token: 'mock-token',
+            user: expect.objectContaining({
+              username: 'testuser',
+              email: 'test@example.com'
+            })
+          })
+        })
+      );
+    });
+
+    it('should return 400 if username already exists', async () => {
+      req.body = {
+        username: 'existinguser',
+        email: 'new@example.com',
+        password: 'Test123!@#'
+      };
+
+      User.findOne = jest.fn().mockResolvedValue({ username: 'existinguser' });
+
+      await authController.register(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          success: false,
+          message: 'Username already exists'
+        })
+      );
+    });
+
+    it('should return 409 if email already exists', async () => {
+      req.body = {
+        username: 'newuser',
+        email: 'existing@example.com',
+        password: 'Test123!@#'
+      };
+
+      User.findOne = jest.fn()
+        .mockResolvedValueOnce(null) // username check
+        .mockResolvedValueOnce({ email: 'existing@example.com' }); // email check
+
+      await authController.register(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(409);
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          success: false,
+          message: 'Email already registered'
+        })
+      );
+    });
+
+    it('should return 400 for missing required fields', async () => {
+      req.body = {
+        username: 'testuser'
+        // missing email and password
+      };
+
+      await authController.register(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          success: false
+        })
+      );
+    });
+
+    it('should return 500 on database error', async () => {
+      req.body = {
+        username: 'testuser',
+        email: 'test@example.com',
+        password: 'Test123!@#'
+      };
+
+      User.findOne = jest.fn().mockRejectedValue(new Error('Database error'));
+
+      await authController.register(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(500);
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          success: false,
+          message: 'Internal server error'
+        })
+      );
+    });
+  });
+
+  describe('login', () => {
+    it('should login user successfully with email', async () => {
+      req.body = {
+        email: 'test@example.com',
+        password: 'Test123!@#'
+      };
+
+      const mockUser = {
+        id: '123',
+        username: 'testuser',
+        email: 'test@example.com',
+        password: 'hashed-password',
+        role: 'user',
+        isActive: true,
+        save: jest.fn()
+      };
+
+      User.findOne = jest.fn().mockResolvedValue(mockUser);
+      bcrypt.compare = jest.fn().mockResolvedValue(true);
+      jwt.sign = jest.fn().mockReturnValue('mock-token');
+
+      await authController.login(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(200);
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          success: true,
+          message: 'Login successful',
+          data: expect.objectContaining({
+            token: 'mock-token'
+          })
+        })
+      );
+    });
+
+    it('should login user successfully with username', async () => {
+      req.body = {
+        username: 'testuser',
+        password: 'Test123!@#'
+      };
+
+      const mockUser = {
+        id: '123',
+        username: 'testuser',
+        email: 'test@example.com',
+        password: 'hashed-password',
+        role: 'user',
+        isActive: true,
+        save: jest.fn()
+      };
+
+      User.findOne = jest.fn().mockResolvedValue(mockUser);
+      bcrypt.compare = jest.fn().mockResolvedValue(true);
+      jwt.sign = jest.fn().mockReturnValue('mock-token');
+
+      await authController.login(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(200);
+    });
+
+    it('should return 400 if user not found', async () => {
+      req.body = {
+        email: 'nonexistent@example.com',
+        password: 'Test123!@#'
+      };
+
+      User.findOne = jest.fn().mockResolvedValue(null);
+
+      await authController.login(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          success: false,
+          message: 'Invalid credentials'
+        })
+      );
+    });
+
+    it('should return 400 if password is incorrect', async () => {
+      req.body = {
+        email: 'test@example.com',
+        password: 'WrongPassword'
+      };
+
+      User.findOne = jest.fn().mockResolvedValue({
+        password: 'hashed-password'
+      });
+      bcrypt.compare = jest.fn().mockResolvedValue(false);
+
+      await authController.login(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          success: false,
+          message: 'Invalid credentials'
+        })
+      );
+    });
+
+    it('should return 403 if user account is deactivated', async () => {
+      req.body = {
+        email: 'test@example.com',
+        password: 'Test123!@#'
+      };
+
+      User.findOne = jest.fn().mockResolvedValue({
+        isActive: false,
+        password: 'hashed-password'
+      });
+      bcrypt.compare = jest.fn().mockResolvedValue(true);
+
+      await authController.login(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(403);
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          success: false,
+          message: 'Account is deactivated'
+        })
+      );
+    });
+
+    it('should return 400 for missing credentials', async () => {
+      req.body = {};
+
+      await authController.login(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(400);
+    });
+  });
+
+  describe('logout', () => {
+    it('should logout user successfully', async () => {
+      req.user = { id: '123' };
+
+      await authController.logout(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(200);
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          success: true,
+          message: 'Logged out successfully'
+        })
+      );
+    });
+
+    it('should handle logout without user context', async () => {
+      req.user = null;
+
+      await authController.logout(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(200);
+    });
+  });
+
+  describe('verifyToken', () => {
+    it('should verify user successfully', async () => {
+      req.user = {
+        id: '123',
+        username: 'testuser',
+        email: 'test@example.com',
+        role: 'user'
+      };
+
+      await authController.verifyToken(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(200);
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          success: true,
+          message: 'Token is valid',
+          data: expect.objectContaining({
+            user: expect.objectContaining({
+              id: '123',
+              username: 'testuser'
+            })
+          })
+        })
+      );
+    });
+
+    it('should return 401 if no user in request', async () => {
+      req.user = null;
+
+      await authController.verifyToken(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(401);
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          success: false,
+          message: 'Unauthorized'
+        })
+      );
+    });
+  });
+});