nodejs-quickstart-structure 1.18.0 → 1.19.0

package/templates/mvc/ts/src/controllers/userController.spec.ts.ejs

@@ -1,203 +1,481 @@
-<% if (communication !== 'GraphQL') { -%>
-import { Request, Response, NextFunction } from 'express';
-import { HTTP_STATUS } from '@/utils/httpCodes';
-<% } -%>
-import { UserController } from '@/controllers/userController';
-import User from '@/models/User';
-<%_ if (caching === 'Redis') { -%>
-import cacheService from '@/config/redisClient';
-<%_ } else if (caching === 'Memory Cache') { -%>
-import cacheService from '@/config/memoryCache';
-<%_ } -%>
-
-// Mock dependencies
-jest.mock('@/models/User');
-<%_ if (caching === 'Redis') { -%>
-jest.mock('@/config/redisClient', () => ({
-    getOrSet: jest.fn(),
-    del: jest.fn()
-}));
-<%_ } else if (caching === 'Memory Cache') { -%>
-jest.mock('@/config/memoryCache', () => ({
-    getOrSet: jest.fn(),
-    del: jest.fn()
-}));
-<%_ } -%>
-jest.mock('@/utils/logger');
-<%_ if (communication === 'Kafka') { -%>
-jest.mock('@/services/kafkaService', () => {
-    const mockSendMessage = jest.fn().mockResolvedValue(undefined);
-    return {
-        kafkaService: {
-            sendMessage: mockSendMessage
-        },
-        KafkaService: jest.fn().mockImplementation(() => ({
-            sendMessage: mockSendMessage
-        }))
-    };
-});
-<%_ } -%>
-
-
-describe('UserController', () => {
-    let userController: UserController;
-<% if (communication !== 'GraphQL') { -%>
-    let mockRequest: Partial<Request>;
-    let mockResponse: Partial<Response>;
-    let mockNext: NextFunction;
-<% } -%>
-
-    beforeEach(() => {
-        userController = new UserController();
-<% if (communication !== 'GraphQL') { -%>
-        mockRequest = {};
-        mockResponse = {
-            json: jest.fn(),
-            status: jest.fn().mockReturnThis(),
-        };
-        mockNext = jest.fn();
-<% } -%>
-    });
-
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-
-    describe('getUsers', () => {
-        it('should return successfully (Happy Path)', async () => {
-            // Arrange
-            const usersMock = [{ id: '1', name: 'Test', email: 'test@example.com' }];
-<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
-            (cacheService.getOrSet as jest.Mock).mockResolvedValue(usersMock);
-<%_ } else { -%>
-<%_ if (database === 'MongoDB' || database === 'None') { -%>
-            (User.find as jest.Mock).mockResolvedValue(usersMock);
-<%_ } else { -%>
-            (User.findAll as jest.Mock).mockResolvedValue(usersMock);
-<%_ } -%>
-<%_ } -%>
-
-            // Act
-<% if (communication === 'GraphQL') { -%>
-            const result = await userController.getUsers();
-
-            // Assert
-            expect(result).toEqual(usersMock);
-<% } else { -%>
-            await userController.getUsers(mockRequest as Request, mockResponse as Response, mockNext);
-
-            // Assert
-            expect(mockResponse.json).toHaveBeenCalledWith(usersMock);
-<% } -%>
-<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
-            expect(cacheService.getOrSet).toHaveBeenCalled();
-<%_ } else { -%>
-<%_ if (database === 'MongoDB') { -%>
-            expect(User.find).toHaveBeenCalled();
-<%_ } else if (database === 'None') { -%>
-            // No DB mock logic
-<%_ } else { -%>
-            expect(User.findAll).toHaveBeenCalled();
-<%_ } -%>
-<%_ } -%>
-        });
-
-        it('should handle errors correctly (Error Handling)', async () => {
-            // Arrange
-            const error = new Error('Database Error');
-<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
-            (cacheService.getOrSet as jest.Mock).mockRejectedValue(error);
-<%_ } else { -%>
-<%_ if (database === 'MongoDB' || database === 'None') { -%>
-            (User.find as jest.Mock).mockRejectedValue(error);
-<%_ } else { -%>
-            (User.findAll as jest.Mock).mockRejectedValue(error);
-<%_ } -%>
-<%_ } -%>
-
-            // Act & Assert
-<% if (communication === 'GraphQL') { -%>
-            await expect(userController.getUsers()).rejects.toThrow(error);
-<% } else { -%>
-            await userController.getUsers(mockRequest as Request, mockResponse as Response, mockNext);
-            expect(mockNext).toHaveBeenCalledWith(error);
-<% } -%>
-        });
-    });
-
-    describe('createUser', () => {
-        it('should successfully create a new user (Happy Path)', async () => {
-            // Arrange
-            const payload = { name: 'Alice', email: 'alice@example.com' };
-<% if (communication === 'GraphQL') { -%>
-            const dataArg = payload;
-<% } else { -%>
-            mockRequest.body = payload;
-<% } -%>
-            
-<%_ if (database === 'MongoDB' || database === 'None') { -%>
-            const expectedUser = { id: '1', ...payload };
-            (User.create as jest.Mock).mockResolvedValue(expectedUser);
-            <%_ if (database === 'None') { -%>User.mockData = [expectedUser];<%_ } -%>
-<%_ } else { -%>
-            const expectedUser = { id: '1', ...payload };
-            (User.create as jest.Mock).mockResolvedValue(expectedUser);
-<%_ } -%>
-
-            // Act
-<% if (communication === 'GraphQL') { -%>
-            const result = await userController.createUser(dataArg);
-
-            // Assert
-<%_ if (database === 'None') { -%>
-            expect(result.name).toBe(payload.name);
-            expect(result.email).toBe(payload.email);
-            expect(User.mockData.length).toBe(1);
-<%_ } else { -%>
-            expect(result).toEqual(expectedUser);
-            expect(User.create).toHaveBeenCalledWith(payload);
-<%_ } -%>
-<% } else { -%>
-            await userController.createUser(mockRequest as Request, mockResponse as Response, mockNext);
-
-            // Assert
-            expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.CREATED);
-<%_ if (database === 'None') { -%>
-            expect(mockResponse.json).toHaveBeenCalled();
-            expect(User.mockData.length).toBe(1);
-<%_ } else { -%>
-            expect(mockResponse.json).toHaveBeenCalledWith(expectedUser);
-            expect(User.create).toHaveBeenCalledWith(payload);
-<%_ } -%>
-<% } -%>
-<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
-            expect(cacheService.del).toHaveBeenCalledWith('users:all');
-<%_ } -%>
-<%_ if (communication === 'Kafka') { -%>
-            const { kafkaService } = require('@/services/kafkaService');
-            expect(kafkaService.sendMessage).toHaveBeenCalled();
-<%_ } -%>
-        });
-
-        it('should handle errors when creation fails (Error Handling)', async () => {
-            // Arrange
-            const error = new Error('Creation Error');
-            const payload = { name: 'Bob', email: 'bob@example.com' };
-<% if (communication === 'GraphQL') { -%>
-            const dataArg = payload;
-<% } else { -%>
-            mockRequest.body = payload;
-<% } -%>
-
-            (User.create as jest.Mock).mockRejectedValue(error);
-
-            // Act & Assert
-<% if (communication === 'GraphQL') { -%>
-            await expect(userController.createUser(dataArg)).rejects.toThrow(error);
-<% } else { -%>
-            await userController.createUser(mockRequest as Request, mockResponse as Response, mockNext);
-            expect(mockNext).toHaveBeenCalledWith(error);
-<% } -%>
-        });
-    });
-});
+import { HTTP_STATUS } from '@/utils/httpCodes';
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+<% if (communication !== 'GraphQL') { -%>
+import { Request, Response, NextFunction } from 'express';
+<% } -%>
+import { UserController } from '@/controllers/userController';
+<%_ if (caching === 'Redis') { -%>
+import cacheService from '@/config/redisClient';
+<%_ } else if (caching === 'Memory Cache') { -%>
+import cacheService from '@/config/memoryCache';
+<%_ } -%>
+
+// Mock dependencies
+jest.mock('@/models/User', () => {
+    return {
+        create: jest.fn(),
+        find: jest.fn(),
+        findAll: jest.fn(),
+        findById: jest.fn(),
+        findByIdAndUpdate: jest.fn(),
+        findByIdAndDelete: jest.fn(),
+        findByPk: jest.fn(),
+        update: jest.fn(),
+        destroy: jest.fn(),
+        mockData: []
+    };
+});
+const User = require('@/models/User');
+<%_ if (caching === 'Redis') { -%>
+jest.mock('@/config/redisClient', () => ({
+    getOrSet: jest.fn((_key, fetcher) => fetcher()),
+    del: jest.fn(),
+    flush: jest.fn()
+}));
+<%_ } else if (caching === 'Memory Cache') { -%>
+jest.mock('@/config/memoryCache', () => ({
+    getOrSet: jest.fn((_key, fetcher) => fetcher()),
+    del: jest.fn(),
+    flush: jest.fn()
+}));
+<%_ } -%>
+jest.mock('@/utils/logger');
+<%_ if (communication === 'Kafka') { -%>
+jest.mock('@/services/kafkaService', () => {
+    const mockSendMessage = jest.fn().mockResolvedValue(undefined);
+    return {
+        sendMessage: mockSendMessage,
+        kafkaService: {
+            sendMessage: mockSendMessage
+        },
+        KafkaService: jest.fn().mockImplementation(() => ({
+            sendMessage: mockSendMessage
+        }))
+    };
+});
+import { kafkaService } from '@/services/kafkaService';
+<%_ } -%>
+
+
+describe('UserController', () => {
+    let userController: UserController;
+<% if (communication !== 'GraphQL') { -%>
+    let mockRequest: Partial<Request>;
+    let mockResponse: Partial<Response>;
+    let mockNext: NextFunction;
+<% } -%>
+
+    beforeEach(() => {
+        userController = new UserController();
+<% if (communication !== 'GraphQL') { -%>
+        mockRequest = {
+            body: {}
+        };
+        mockResponse = {
+            json: jest.fn(),
+            status: jest.fn().mockReturnThis(),
+        };
+        mockNext = jest.fn();
+<% } -%>
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+        (cacheService.getOrSet as jest.Mock).mockImplementation((_key, fetcher) => fetcher());
+        (cacheService.flush as jest.Mock).mockClear();
+<%_ } -%>
+    });
+
+    afterEach(() => {
+        jest.clearAllMocks();
+<%_ if (database === 'None') { -%>
+        (User as any).mockData = [];
+<%_ } -%>
+    });
+
+    describe('getUsers', () => {
+        it('should return successfully (Happy Path)', async () => {
+            // Arrange
+            const usersMock = [{ id: '1', name: 'Test', email: 'test@example.com' }];
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            (User.find as jest.Mock).mockResolvedValue(usersMock);
+<%_ } else { -%>
+            (User.findAll as jest.Mock).mockResolvedValue(usersMock);
+<%_ } -%>
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await userController.getUsers();
+
+            // Assert
+            expect(result!).toEqual(usersMock);
+<% } else { -%>
+            await userController.getUsers(mockRequest as Request, mockResponse as Response, mockNext);
+
+            // Assert
+            expect(mockResponse.json).toHaveBeenCalledWith(usersMock);
+<% } -%>
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            expect(cacheService.getOrSet).toHaveBeenCalled();
+<%_ } else { -%>
+<%_ if (database === 'MongoDB') { -%>
+            expect(User.find).toHaveBeenCalled();
+<%_ } else if (database === 'None') { -%>
+            // No DB mock logic
+<%_ } else { -%>
+            expect(User.findAll).toHaveBeenCalled();
+<%_ } -%>
+<%_ } -%>
+        });
+
+        it('should return an empty array when no users found', async () => {
+            // Arrange
+            const usersMock: any[] = [];
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            (User.find as jest.Mock).mockResolvedValue(usersMock);
+<%_ } else { -%>
+            (User.findAll as jest.Mock).mockResolvedValue(usersMock);
+<%_ } -%>
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await userController.getUsers();
+
+            // Assert
+            expect(result!).toEqual(usersMock);
+<% } else { -%>
+            await userController.getUsers(mockRequest as Request, mockResponse as Response, mockNext);
+
+            // Assert
+            expect(mockResponse.json).toHaveBeenCalledWith(usersMock);
+<% } -%>
+        });
+
+        it('should handle errors correctly (Error Handling)', async () => {
+            // Arrange
+            const error = new Error('Database Error');
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            // Simulating error inside the fetcher by making User.findAll fail
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            (User.find as jest.Mock).mockRejectedValue(error);
+<%_ } else { -%>
+            (User.findAll as jest.Mock).mockRejectedValue(error);
+<%_ } -%>
+<%_ } else { -%>
+<%_ if (database === 'MongoDB' || database === 'None') { -%>
+            (User.find as jest.Mock).mockRejectedValue(error);
+<%_ } else { -%>
+            (User.findAll as jest.Mock).mockRejectedValue(error);
+<%_ } -%>
+<%_ } -%>
+
+            // Act & Assert
+<% if (communication === 'GraphQL') { -%>
+            await expect(userController.getUsers()).rejects.toThrow(error);
+<% } else { -%>
+            await userController.getUsers(mockRequest as Request, mockResponse as Response, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<% } -%>
+        });
+    });
+
+    describe('createUser', () => {
+        it('should successfully create a new user (Happy Path)', async () => {
+            // Arrange
+            const payload = { name: 'Alice', email: 'alice@example.com' };
+<% if (communication === 'GraphQL') { -%>
+            const dataArg = payload;
+<% } else { -%>
+            mockRequest.body = payload;
+<% } -%>
+            
+            const expectedUser = { id: '1', ...payload };
+<%_ if (database === 'MongoDB') { -%>
+            (User.create as jest.Mock).mockResolvedValue(expectedUser);
+<%_ } else if (database === 'None') { -%>
+            (User.create as jest.Mock).mockResolvedValue(expectedUser);
+<%_ } else { -%>
+            (User.create as jest.Mock).mockResolvedValue(expectedUser);
+<%_ } -%>
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await userController.createUser(dataArg) as any;
+
+            // Assert
+            expect(result!).toEqual(expectedUser);
+<% } else { -%>
+            await userController.createUser(mockRequest as Request, mockResponse as Response, mockNext);
+
+            // Assert
+            expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.CREATED);
+            expect(mockResponse.json).toHaveBeenCalledWith(expectedUser);
+            expect(User.create).toHaveBeenCalledWith(payload);
+<% } -%>
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            expect(kafkaService.sendMessage).toHaveBeenCalled();
+<%_ } -%>
+        });
+
+        it('should handle errors when creation fails (Error Handling)', async () => {
+            // Arrange
+            const error = new Error('Creation Error');
+            const payload = { name: 'Bob', email: 'bob@example.com' };
+<% if (communication === 'GraphQL') { -%>
+            const dataArg = payload;
+<% } else { -%>
+            mockRequest.body = payload;
+<% } -%>
+
+            (User.create as jest.Mock).mockRejectedValue(error);
+
+            // Act & Assert
+<% if (communication === 'GraphQL') { -%>
+            await expect(userController.createUser(dataArg)).rejects.toThrow(error);
+<% } else { -%>
+            await userController.createUser(mockRequest as Request, mockResponse as Response, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<% } -%>
+        });
+    });
+
+    describe('updateUser', () => {
+        it('should successfully update a user (Happy Path)', async () => {
+            // Arrange
+            const id = '1';
+            const payload = { name: 'Alice Updated' };
+<% if (communication === 'GraphQL') { -%>
+            const idArg = id;
+            const dataArg = payload;
+<% } else { -%>
+            mockRequest.params = { id };
+            mockRequest.body = payload;
+<% } -%>
+            
+            const expectedUser = { id, ...payload, email: 'alice@example.com' };
+<%_ if (database === 'MongoDB') { -%>
+            (User.findByIdAndUpdate as jest.Mock).mockResolvedValue(expectedUser);
+            (User.findById as jest.Mock).mockResolvedValue(expectedUser);
+<%_ } else if (database === 'None') { -%>
+            (User.update as jest.Mock).mockResolvedValue(expectedUser);
+            (User.findByPk as jest.Mock).mockResolvedValue(expectedUser);
+<%_ } else { -%>
+            const userMock = { ...expectedUser, update: jest.fn().mockResolvedValue(true) };
+            (User.findByPk as jest.Mock).mockResolvedValue(userMock);
+<%_ } -%>
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await userController.updateUser(idArg, dataArg);
+
+            // Assert
+<%_ if (database === 'None' || database === 'MongoDB') { -%>
+            expect(result!).toEqual(expectedUser);
+<%_ } else { -%>
+            expect(result!).toMatchObject(payload);
+            expect(User.findByPk).toHaveBeenCalledWith(id);
+<%_ } -%>
+<% } else { -%>
+            await userController.updateUser(mockRequest as Request, mockResponse as Response, mockNext);
+
+            // Assert
+<%_ if (database === 'None' || database === 'MongoDB') { -%>
+            expect(mockResponse.json).toHaveBeenCalledWith(expectedUser);
+<%_ } else { -%>
+            expect(mockResponse.json).toHaveBeenCalled();
+            expect(User.findByPk).toHaveBeenCalledWith(id);
+<%_ } -%>
+<% } -%>
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            expect(kafkaService.sendMessage).toHaveBeenCalled();
+<%_ } -%>
+        });
+
+        it('should handle 404/errors when user not found or update fails', async () => {
+             // Arrange
+            const id = '999';
+<%_ if (communication === 'GraphQL') { -%>
+            const idArg = id;
+            const dataArg = { name: 'Fail' };
+<%_ if (database === 'MongoDB') { -%>
+            (User.findByIdAndUpdate as jest.Mock).mockResolvedValue(null);
+<%_ } else { -%>
+            (User.findByPk as jest.Mock).mockResolvedValue(null);
+<%_ } -%>
+            await expect(userController.updateUser(idArg, dataArg)).rejects.toThrow(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ } else { -%>
+            mockRequest.params = { id };
+            mockRequest.body = { name: 'Fail' };
+<%_ if (database === 'MongoDB') { -%>
+            (User.findByIdAndUpdate as jest.Mock).mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            (User.findByPk as jest.Mock).mockResolvedValue(null);
+<%_ } else { -%>
+            (User.findByPk as jest.Mock).mockResolvedValue(null);
+<%_ } -%>
+
+            // Act
+            await userController.updateUser(mockRequest as Request, mockResponse as Response, mockNext);
+            expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.NOT_FOUND);
+<%_ } -%>
+        });
+
+        it('should handle database errors during update (Error Handling)', async () => {
+            // Arrange
+            const id = '1';
+            const error = new Error('Database Error');
+<%_ if (database === 'MongoDB') { -%>
+            (User.findByIdAndUpdate as jest.Mock).mockRejectedValue(error);
+<%_ } else { -%>
+            (User.findByPk as jest.Mock).mockRejectedValue(error);
+<%_ } -%>
+<%_ if (communication === 'GraphQL') { -%>
+            await expect(userController.updateUser(id, { name: 'Fail' })).rejects.toThrow(error);
+<%_ } else { -%>
+            mockRequest.params = { id };
+            await userController.updateUser(mockRequest as Request, mockResponse as Response, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<%_ } -%>
+        });
+    });
+
+    describe('deleteUser', () => {
+        it('should successfully delete a user (Happy Path)', async () => {
+            // Arrange
+            const id = '1';
+<% if (communication === 'GraphQL') { -%>
+            const idArg = id;
+<% } else { -%>
+            mockRequest.params = { id };
+<% } -%>
+            
+<%_ if (database === 'MongoDB') { -%>
+            (User.findByIdAndDelete as jest.Mock).mockResolvedValue(true);
+<%_ } else if (database === 'None') { -%>
+            (User.destroy as jest.Mock).mockResolvedValue(true);
+<%_ } else { -%>
+            const userMock = { id, destroy: jest.fn().mockResolvedValue(true) };
+            (User.findByPk as jest.Mock).mockResolvedValue(userMock);
+<%_ } -%>
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await userController.deleteUser(idArg);
+            expect(result).toBe(true);
+<% } else { -%>
+            await userController.deleteUser(mockRequest as Request, mockResponse as Response, mockNext);
+            expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.OK);
+<% } -%>
+
+<%_ if (database === 'None') { -%>
+            expect(User.destroy).toHaveBeenCalledWith(id);
+<%_ } -%>
+<%_ if (caching === 'Redis' || caching === 'Memory Cache') { -%>
+            expect(cacheService.del).toHaveBeenCalledWith('users:all');
+<%_ } -%>
+<%_ if (communication === 'Kafka') { -%>
+            expect(kafkaService.sendMessage).toHaveBeenCalled();
+<%_ } -%>
+        });
+
+<% if (communication === 'GraphQL') { -%>
+        it('should handle user not found during deletion (Error Handling)', async () => {
+            const id = '999';
+<%_ if (database === 'MongoDB') { -%>
+            (User.findByIdAndDelete as jest.Mock).mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            (User.destroy as jest.Mock).mockResolvedValue(false);
+<%_ } else { -%>
+            (User.findByPk as jest.Mock).mockResolvedValue(null);
+<%_ } -%>
+            await expect(userController.deleteUser(id)).rejects.toThrow(ERROR_MESSAGES.USER_NOT_FOUND);
+        });
+
+        it('should handle database errors during deletion (Error Handling)', async () => {
+            const id = '1';
+            const error = new Error('Database Error');
+<%_ if (database === 'MongoDB') { -%>
+            (User.findByIdAndDelete as jest.Mock).mockRejectedValue(error);
+<%_ } else if (database === 'None') { -%>
+            (User.destroy as jest.Mock).mockRejectedValue(error);
+<%_ } else { -%>
+            (User.findByPk as jest.Mock).mockRejectedValue(error);
+<%_ } -%>
+            await expect(userController.deleteUser(id)).rejects.toThrow(error);
+        });
+<% } else { -%>
+        it('should handle user not found during deletion (Error Handling)', async () => {
+            // Arrange
+            const id = '999';
+            mockRequest.params = { id };
+<%_ if (database === 'MongoDB') { -%>
+            (User.findByIdAndDelete as jest.Mock).mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            (User.destroy as jest.Mock).mockResolvedValue(false);
+<%_ } else { -%>
+            (User.findByPk as jest.Mock).mockResolvedValue(null);
+<%_ } -%>
+            await userController.deleteUser(mockRequest as Request, mockResponse as Response, mockNext);
+            expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.NOT_FOUND);
+        });
+
+        it('should handle database errors during deletion (Error Handling)', async () => {
+            // Arrange
+            const id = '1';
+            mockRequest.params = { id };
+            const error = new Error('Database Error');
+<%_ if (database === 'MongoDB') { -%>
+            (User.findByIdAndDelete as jest.Mock).mockRejectedValue(error);
+<%_ } else if (database === 'None') { -%>
+            (User.destroy as jest.Mock).mockRejectedValue(error);
+<%_ } else { -%>
+            (User.findByPk as jest.Mock).mockRejectedValue(error);
+<%_ } -%>
+            await userController.deleteUser(mockRequest as Request, mockResponse as Response, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+        });
+<% } -%>
+    });
+
+    describe('createUser Error Paths', () => {
+        it('should handle database errors during creation (Error Handling)', async () => {
+            const error = new Error('Database Error');
+            (User.create as jest.Mock).mockRejectedValue(error);
+<% if (communication === 'GraphQL') { -%>
+            await expect(userController.createUser({ name: 'Alice', email: 'alice@example.com' })).rejects.toThrow(error);
+<% } else { -%>
+            mockRequest.body = { name: 'Alice', email: 'alice@example.com' };
+            await userController.createUser(mockRequest as Request, mockResponse as Response, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<% } -%>
+        });
+    });
+
+    describe('updateUser Error Paths', () => {
+        it('should handle database errors during update (Error Handling)', async () => {
+            const id = '1';
+            const error = new Error('Database Error');
+<%_ if (database === 'MongoDB') { -%>
+            (User.findById as jest.Mock).mockResolvedValue({ id });
+            (User.findByIdAndUpdate as jest.Mock).mockRejectedValue(error);
+<%_ } else if (database === 'None') { -%>
+            (User.findByPk as jest.Mock).mockResolvedValue({ id });
+            (User.update as jest.Mock).mockRejectedValue(error);
+<%_ } else { -%>
+            const userMock = { id, update: jest.fn().mockRejectedValue(error) };
+            (User.findByPk as jest.Mock).mockResolvedValue(userMock);
+<%_ } -%>
+<% if (communication === 'GraphQL') { -%>
+            await expect(userController.updateUser(id, { name: 'Bob' })).rejects.toThrow(error);
+<% } else { -%>
+            mockRequest.params = { id };
+            mockRequest.body = { name: 'Bob' };
+            await userController.updateUser(mockRequest as Request, mockResponse as Response, mockNext);
+            expect(mockNext).toHaveBeenCalledWith(error);
+<% } -%>
+        });
+    });
+});