nodejs-structure-cli 1.0.0

package/templates/clean-architecture/ts/src/infrastructure/repositories/UserRepository.spec.ts.ejs

@@ -0,0 +1,175 @@
+import { UserRepository } from '@/infrastructure/repositories/UserRepository';
+import UserModel from '@/infrastructure/database/models/User';
+
+// Mock DB Model Database Layer
+jest.mock('@/infrastructure/database/models/User');
+
+describe('UserRepository', () => {
+    let userRepository: UserRepository;
+
+    beforeEach(() => {
+        userRepository = new UserRepository();
+        jest.clearAllMocks();
+    });
+
+    describe('save', () => {
+        it('should save and return a newly created user (Happy Path)', async () => {
+            // Arrange
+            const payload = { id: '', name: 'TestUser', email: 'test@example.com' };
+<%_ if (database === 'MongoDB') { -%>
+            const mockDbRecord = { _id: { toString: () => '1' }, name: 'TestUser', email: 'test@example.com' };
+            (UserModel.create as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.create as jest.Mock).mockResolvedValue(payload);
+<%_ } else { -%>
+            const mockDbRecord = { id: '1', name: 'TestUser', email: 'test@example.com' };
+            (UserModel.create as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.save(payload);
+
+            // Assert
+<%_ if (database === 'None') { -%>
+            expect(result.name).toEqual(payload.name)
+<%_ } else { -%>
+            expect(result).toEqual({ id: '1', name: 'TestUser', email: 'test@example.com' });
+            expect(UserModel.create).toHaveBeenCalledWith({ name: payload.name, email: payload.email });
+<%_ } -%>
+        });
+
+        it('should throw an error when DB fails explicitly (Edge Case)', async () => {
+<%_ if (database === 'None') { -%>
+            // Mocks do not naturally fail 
+<%_ } else { -%>
+            // Arrange
+            const payload = { id: '', name: 'FailUser', email: 'fail@example.com' };
+            const error = new Error('DB Connection Refused');
+            (UserModel.create as jest.Mock).mockRejectedValue(error);
+
+            // Act & Assert
+            await expect(userRepository.save(payload)).rejects.toThrow(error);
+<%_ } -%>
+        });
+    });
+
+    describe('getUsers', () => {
+        it('should return a list of mapped UserEntities (Happy Path)', async () => {
+            // Arrange
+<%_ if (database === 'MongoDB') { -%>
+            const mockDbRecords = [{ _id: { toString: () => '1' }, name: 'User1', email: 'user1@example.com' }];
+            (UserModel.find as jest.Mock).mockResolvedValue(mockDbRecords);
+<%_ } else if (database === 'None') { -%>
+            const mockData = [{ id: '1', name: 'User1', email: 'user1@example.com' }];
+            (UserModel.find as jest.Mock).mockResolvedValue(mockData);
+<%_ } else { -%>
+            const mockDbRecords = [{ id: '1', name: 'User1', email: 'user1@example.com' }];
+            (UserModel.findAll as jest.Mock).mockResolvedValue(mockDbRecords);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.getUsers();
+
+            // Assert
+            expect(result).toHaveLength(1);
+            expect(result[0]).toEqual({ id: '1', name: 'User1', email: 'user1@example.com' });
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+            expect(UserModel.find).toHaveBeenCalled();
+<%_ } else { -%>
+            expect(UserModel.findAll).toHaveBeenCalled();
+<%_ } -%>
+<%_ } -%>
+        });
+    });
+
+    describe('update', () => {
+        it('should update and return the user (Happy Path)', async () => {
+            // Arrange
+            const id = '1';
+            const data = { name: 'Updated' };
+            const expectedUser = { id: '1', name: 'Updated', email: 'test@example.com' };
+
+<%_ if (database === 'MongoDB') { -%>
+            const mockDbRecord = { _id: { toString: () => '1' }, name: 'Updated', email: 'test@example.com' };
+            (UserModel.findByIdAndUpdate as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.update as jest.Mock).mockResolvedValue(expectedUser);
+<%_ } else { -%>
+            const mockDbRecord = { id: '1', name: 'Updated', email: 'test@example.com', update: jest.fn().mockResolvedValue(true) };
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.update(id, data);
+
+            // Assert
+            expect(result?.name).toEqual(data.name);
+<%_ if (database !== 'None') { -%>
+<%_ if (database === 'MongoDB') { -%>
+            expect(UserModel.findByIdAndUpdate).toHaveBeenCalled();
+<%_ } else { -%>
+            expect(UserModel.findByPk).toHaveBeenCalled();
+<%_ } -%>
+<%_ } -%>
+        });
+
+        it('should return null when user not found (Error Handling)', async () => {
+            // Arrange
+            const id = '999';
+<%_ if (database === 'MongoDB') { -%>
+            (UserModel.findByIdAndUpdate as jest.Mock).mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.update as jest.Mock).mockResolvedValue(null);
+<%_ } else { -%>
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(null);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.update(id, { name: 'Fail' });
+
+            // Assert
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('delete', () => {
+        it('should successfully delete a user (Happy Path)', async () => {
+            // Arrange
+            const id = '1';
+
+<%_ if (database === 'MongoDB') { -%>
+            (UserModel.findByIdAndDelete as jest.Mock).mockResolvedValue(true);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.destroy as jest.Mock).mockResolvedValue(true);
+<%_ } else { -%>
+            const mockDbRecord = { id: '1', destroy: jest.fn().mockResolvedValue(true) };
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(mockDbRecord);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.delete(id);
+
+            // Assert
+            expect(result).toBe(true);
+        });
+
+        it('should return false when user not found during deletion (Error Handling)', async () => {
+            // Arrange
+            const id = '999';
+<%_ if (database === 'MongoDB') { -%>
+            (UserModel.findByIdAndDelete as jest.Mock).mockResolvedValue(null);
+<%_ } else if (database === 'None') { -%>
+            (UserModel.destroy as jest.Mock).mockResolvedValue(false);
+<%_ } else { -%>
+            (UserModel.findByPk as jest.Mock).mockResolvedValue(null);
+<%_ } -%>
+
+            // Act
+            const result = await userRepository.delete(id);
+
+            // Assert
+            expect(result).toBe(false);
+        });
+    });
+});

package/templates/clean-architecture/ts/src/infrastructure/repositories/userRepository.ts.ejs

@@ -0,0 +1,125 @@
+import { User as UserEntity } from '@/domain/user';
+import UserModel from '@/infrastructure/database/models/User';
+
+export class UserRepository {
+    async save(user: UserEntity): Promise<UserEntity> {
+<%_ if (database === 'MongoDB') { -%>
+        const userData = { name: user.name, email: user.email };
+        <% if (auth && auth !== 'None') { %>if (user.password) (userData as any).password = user.password;<% } %>
+        <% if (includeMulter) { %>if (user.imageUrl) (userData as any).imageUrl = user.imageUrl;<% } %>
+        const newUser = await UserModel.create(userData);
+        return { 
+          id: newUser._id.toString(), 
+          name: newUser.name, 
+          email: newUser.email,
+          <% if (auth && auth !== 'None') { %>password: (newUser as any).password,<% } %>
+          <% if (includeMulter) { %>imageUrl: (newUser as any).imageUrl,<% } %>
+        };
+<%_ } else if (database === 'None') { -%>
+        const userData = { name: user.name, email: user.email };
+        <% if (auth && auth !== 'None') { %>if (user.password) (userData as any).password = user.password;<% } %>
+        <% if (includeMulter) { %>if (user.imageUrl) (userData as any).imageUrl = user.imageUrl;<% } %>
+        const newUser = await UserModel.create(userData);
+        return { 
+          id: newUser.id, 
+          name: newUser.name, 
+          email: newUser.email,
+          <% if (auth && auth !== 'None') { %>password: (newUser as any).password,<% } %>
+          <% if (includeMulter) { %>imageUrl: (newUser as any).imageUrl,<% } %>
+        };
+<%_ } else { -%>
+        const userData = { name: user.name, email: user.email };
+        <% if (auth && auth !== 'None') { %>if (user.password) (userData as any).password = user.password;<% } %>
+        <% if (includeMulter) { %>if (user.imageUrl) (userData as any).imageUrl = user.imageUrl;<% } %>
+        const newUser = await UserModel.create(userData);
+        return { 
+          id: newUser.id, 
+          name: newUser.name, 
+          email: newUser.email,
+          <% if (auth && auth !== 'None') { %>password: (newUser as any).password,<% } %>
+          <% if (includeMulter) { %>imageUrl: (newUser as any).imageUrl,<% } %>
+        };
+<%_ } -%>
+    }
+
+    async getUsers(): Promise<UserEntity[]> {
+<%_ if (database === 'MongoDB') { -%>
+        const users = await UserModel.find();
+        return users.map(user => ({
+            id: user._id.toString(),
+            name: user.name,
+            email: user.email,
+            <% if (auth && auth !== 'None') { %>password: (user as any).password,<% } %>
+            <% if (includeMulter) { %>imageUrl: (user as any).imageUrl,<% } %>
+        }));
+<%_ } else if (database === 'None') { -%>
+        const users = await UserModel.find();
+        return users.map(user => ({
+            id: user.id,
+            name: user.name,
+            email: user.email,
+            <% if (auth && auth !== 'None') { %>password: (user as any).password,<% } %>
+            <% if (includeMulter) { %>imageUrl: (user as any).imageUrl,<% } %>
+        }));
+<%_ } else { -%>
+        const users = await UserModel.findAll();
+        return users.map(user => ({
+            id: user.id,
+            name: user.name,
+            email: user.email,
+            <% if (auth && auth !== 'None') { %>password: (user as any).password,<% } %>
+            <% if (includeMulter) { %>imageUrl: (user as any).imageUrl,<% } %>
+        }));
+<%_ } -%>
+    }
+
+    async update(id: number | string, data: Partial<UserEntity>): Promise<UserEntity | null> {
+<%_ if (database === 'MongoDB') { -%>
+        const user = await UserModel.findByIdAndUpdate(id, data, { new: true });
+        if (!user) return null;
+        return { 
+          id: user._id.toString(), 
+          name: user.name, 
+          email: user.email,
+          <% if (auth && auth !== 'None') { %>password: (user as any).password,<% } %>
+          <% if (includeMulter) { %>imageUrl: (user as any).imageUrl,<% } %>
+        };
+<%_ } else if (database === 'None') { -%>
+        const { id: _, ...updateData } = data;
+        const user = await UserModel.update(id, updateData as Parameters<typeof UserModel.update>[1]);
+        if (!user) return null;
+        return { 
+          id: user.id, 
+          name: user.name, 
+          email: user.email,
+          <% if (auth && auth !== 'None') { %>password: (user as any).password,<% } %>
+          <% if (includeMulter) { %>imageUrl: (user as any).imageUrl,<% } %>
+        };
+<%_ } else { -%>
+        const user = await UserModel.findByPk(id);
+        if (!user) return null;
+        await user.update(data);
+        return { 
+          id: user.id || 0, 
+          name: user.name, 
+          email: user.email,
+          <% if (auth && auth !== 'None') { %>password: (user as any).password,<% } %>
+          <% if (includeMulter) { %>imageUrl: (user as any).imageUrl,<% } %>
+        };
+<%_ } -%>
+    }
+
+    async delete(id: number | string): Promise<boolean> {
+<%_ if (database === 'MongoDB') { -%>
+        const result = await UserModel.findByIdAndDelete(id);
+        return !!result;
+<%_ } else if (database === 'None') { -%>
+        return await UserModel.destroy(id);
+<%_ } else { -%>
+        const user = await UserModel.findByPk(id);
+        if (!user) return false;
+        await user.destroy();
+        return true;
+<%_ } -%>
+    }
+}

package/templates/clean-architecture/ts/src/interfaces/controllers/userController.spec.ts.ejs

@@ -0,0 +1,331 @@
+<% if (communication !== 'GraphQL') { -%>
+import { Request, Response, NextFunction } from 'express';
+import { HTTP_STATUS } from '@/utils/httpCodes';
+<% } -%>
+import { ERROR_MESSAGES } from '@/utils/errorMessages';
+import { UserController } from '@/interfaces/controllers/userController';
+import CreateUser from '@/usecases/createUser';
+import GetAllUsers from '@/usecases/getAllUsers';
+import UpdateUser from '@/usecases/updateUser';
+import DeleteUser from '@/usecases/deleteUser';
+
+// Mock dependencies
+jest.mock('@/infrastructure/repositories/UserRepository');
+jest.mock('@/usecases/createUser');
+jest.mock('@/usecases/getAllUsers');
+jest.mock('@/usecases/updateUser');
+jest.mock('@/usecases/deleteUser');
+jest.mock('@/infrastructure/log/logger');
+<%_ if (communication === 'Kafka') { -%>
+jest.mock('@/infrastructure/messaging/kafkaClient', () => ({
+    kafkaService: {
+        sendMessage: jest.fn().mockResolvedValue(undefined)
+    },
+    KafkaService: jest.fn().mockImplementation(() => ({
+        sendMessage: jest.fn().mockResolvedValue(undefined)
+    }))
+}));
+const { kafkaService } = require('@/infrastructure/messaging/kafkaClient');
+<%_ } -%>
+
+
+describe('UserController (Clean Architecture)', () => {
+    let userController: UserController;
+    let mockCreateUserUseCase: jest.Mocked<CreateUser>;
+    let mockGetAllUsersUseCase: jest.Mocked<GetAllUsers>;
+    let mockUpdateUserUseCase: jest.Mocked<UpdateUser>;
+    let mockDeleteUserUseCase: jest.Mocked<DeleteUser>;
+<% if (communication !== 'GraphQL') { -%>
+    let mockRequest: Partial<Request>;
+    let mockResponse: Partial<Response>;
+    let mockNext: NextFunction;
+<% } -%>
+
+    beforeEach(() => {
+        // Clear all mocks
+        jest.resetAllMocks();
+
+        userController = new UserController();
+
+        // Retrieve the mocked instances created inside UserController constructor
+        mockCreateUserUseCase = (CreateUser as jest.Mock).mock.instances[0] as jest.Mocked<CreateUser>;
+        mockGetAllUsersUseCase = (GetAllUsers as jest.Mock).mock.instances[0] as jest.Mocked<GetAllUsers>;
+        mockUpdateUserUseCase = (UpdateUser as jest.Mock).mock.instances[0] as jest.Mocked<UpdateUser>;
+        mockDeleteUserUseCase = (DeleteUser as jest.Mock).mock.instances[0] as jest.Mocked<DeleteUser>;
+
+<% if (communication !== 'GraphQL') { -%>
+        mockRequest = {
+            body: {}
+        };
+        mockResponse = {
+            json: jest.fn(),
+            status: jest.fn().mockReturnThis(),
+        };
+        mockNext = jest.fn();
+<% } -%>
+    });
+
+    describe('getUsers', () => {
+        it('should return successfully (Happy Path)', async () => {
+            // Arrange
+            const usersMock = [{ id: '1', name: 'Test', email: 'test@example.com' }];
+            mockGetAllUsersUseCase.execute.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);
+<% } -%>
+            expect(mockGetAllUsersUseCase.execute).toHaveBeenCalled();
+        });
+
+        it('should handle errors correctly (Error Handling)', async () => {
+            // Arrange
+            const error = new Error('UseCase Error');
+            mockGetAllUsersUseCase.execute.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);
+<% } -%>
+        });
+
+        it('should handle non-Error objects in catch block', async () => {
+            // Arrange
+            const error = 'String Error';
+            mockGetAllUsersUseCase.execute.mockRejectedValue(error);
+
+            // Act & Assert
+<% if (communication === 'GraphQL') { -%>
+            await expect(userController.getUsers()).rejects.toEqual(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 };
+            
+            mockCreateUserUseCase.execute.mockResolvedValue(expectedUser);
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await userController.createUser(dataArg);
+
+            // Assert
+            expect(result).toEqual(expectedUser);
+<% } else { -%>
+            await userController.createUser(mockRequest as Request, mockResponse as Response, mockNext);
+
+            // Assert
+<%_ if (communication === 'Kafka') { -%>
+            const { kafkaService } = require('@/infrastructure/messaging/kafkaClient');
+            expect(kafkaService.sendMessage).toHaveBeenCalled();
+<%_ } -%>
+            expect(mockResponse.status).toHaveBeenCalledWith(HTTP_STATUS.CREATED);
+
+            expect(mockResponse.json).toHaveBeenCalledWith(expectedUser);
+<% } -%>
+            expect(mockCreateUserUseCase.execute).toHaveBeenCalledWith(payload.name, payload.email);
+        });
+
+        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;
+<% } -%>
+
+            mockCreateUserUseCase.execute.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);
+<% } -%>
+        });
+
+        it('should handle non-Error objects in catch block when creation fails', async () => {
+            // Arrange
+            const error = 'Creation String Error';
+            const payload = { name: 'Bob', email: 'bob@example.com' };
+<% if (communication === 'GraphQL') { -%>
+            const dataArg = payload;
+<% } else { -%>
+            mockRequest.body = payload;
+<% } -%>
+
+            mockCreateUserUseCase.execute.mockRejectedValue(error);
+
+            // Act & Assert
+<% if (communication === 'GraphQL') { -%>
+            await expect(userController.createUser(dataArg)).rejects.toEqual(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, name: 'Alice Updated', email: 'alice@example.com' };
+
+            mockUpdateUserUseCase.execute.mockResolvedValue(expectedUser as any);
+
+            // Act
+<% if (communication === 'GraphQL') { -%>
+            const result = await userController.updateUser(idArg, dataArg);
+            expect(result).toEqual(expectedUser);
+<% } else { -%>
+            await userController.updateUser(mockRequest as Request, mockResponse as Response, mockNext);
+            expect(mockResponse.json).toHaveBeenCalledWith(expectedUser);
+<% } -%>
+
+<%_ if (communication === 'Kafka') { -%>
+            const { kafkaService } = require('@/infrastructure/messaging/kafkaClient');
+            expect(kafkaService.sendMessage).toHaveBeenCalled();
+<%_ } -%>
+            expect(mockUpdateUserUseCase.execute).toHaveBeenCalledWith(id, payload);
+        });
+
+        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' };
+            mockUpdateUserUseCase.execute.mockResolvedValue(null);
+            await expect(userController.updateUser(idArg, dataArg)).rejects.toThrow(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ } else { -%>
+            mockRequest.params = { id };
+            mockRequest.body = { name: 'Fail' };
+            mockUpdateUserUseCase.execute.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');
+            mockUpdateUserUseCase.execute.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 };
+<% } -%>
+            mockDeleteUserUseCase.execute.mockResolvedValue(true);
+
+            // 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 (communication === 'Kafka') { -%>
+            const { kafkaService } = require('@/infrastructure/messaging/kafkaClient');
+            expect(kafkaService.sendMessage).toHaveBeenCalled();
+<%_ } -%>
+            expect(mockDeleteUserUseCase.execute).toHaveBeenCalledWith(id);
+        });
+
+        it('should throw error if user not found during deletion (Error Handling)', async () => {
+            // Arrange
+            const id = '999';
+<%_ if (communication === 'GraphQL') { -%>
+            mockDeleteUserUseCase.execute.mockResolvedValue(false);
+            await expect(userController.deleteUser(id)).rejects.toThrow(ERROR_MESSAGES.USER_NOT_FOUND);
+<%_ } else { -%>
+            mockRequest.params = { id };
+            mockDeleteUserUseCase.execute.mockResolvedValue(false);
+            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';
+            const error = new Error('Database Error');
+            mockDeleteUserUseCase.execute.mockRejectedValue(error);
+<%_ if (communication === 'GraphQL') { -%>
+            await expect(userController.deleteUser(id)).rejects.toThrow(error);
+<%_ } else { -%>
+            mockRequest.params = { id };
+            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');
+            mockCreateUserUseCase.execute.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);
+<%_ } -%>
+        });
+    });
+});