refactor use cases

core/identity/application/use-cases/GetUserUseCase.test.ts

@@ -1,22 +1,22 @@
 import { describe, it, expect, vi, type Mock } from 'vitest';
 import { GetUserUseCase } from './GetUserUseCase';
-import { User } from '../../domain/entities/User';
-import type { IUserRepository, StoredUser } from '../../domain/repositories/IUserRepository';
-import type { Logger, UseCaseOutputPort } from '@core/shared/application';
+import type { IUserRepository } from '../../domain/repositories/IUserRepository';
+import type { Logger } from '@core/shared/application';
 import { Result } from '@core/shared/application/Result';
-
-type GetUserOutput = Result<{ user: User }, unknown>;
+import { User } from '../../domain/entities/User';
+import { UserId } from '../../domain/value-objects/UserId';
+import { PasswordHash } from '../../domain/value-objects/PasswordHash';
+import { EmailAddress } from '../../domain/value-objects/EmailAddress';
 
 describe('GetUserUseCase', () => {
-  let userRepository: {
+  let userRepo: {
     findById: Mock;
   };
   let logger: Logger;
-  let output: UseCaseOutputPort<GetUserOutput> & { present: Mock };
   let useCase: GetUserUseCase;
 
   beforeEach(() => {
-    userRepository = {
+    userRepo = {
       findById: vi.fn(),
     };
 
@@ -27,48 +27,48 @@ describe('GetUserUseCase', () => {
       error: vi.fn(),
     } as unknown as Logger;
 
-    output = {
-      present: vi.fn(),
-    };
-
     useCase = new GetUserUseCase(
-      userRepository as unknown as IUserRepository,
+      userRepo as unknown as IUserRepository,
       logger,
-      output,
     );
   });
 
-  it('returns a User when the user exists', async () => {
-    const storedUser: StoredUser = {
+  it('returns user when found', async () => {
+    const storedUser = {
       id: 'user-1',
       email: 'test@example.com',
       displayName: 'John Smith',
-      passwordHash: 'hash',
-      primaryDriverId: 'driver-1',
+      passwordHash: 'hashed-password',
       createdAt: new Date(),
     };
-
-    userRepository.findById.mockResolvedValue(storedUser);
+    userRepo.findById.mockResolvedValue(storedUser);
 
     const result = await useCase.execute({ userId: 'user-1' });
 
-    expect(userRepository.findById).toHaveBeenCalledWith('user-1');
     expect(result.isOk()).toBe(true);
-    expect(output.present).toHaveBeenCalled();
-    const callArgs = output.present.mock.calls?.[0]?.[0];
-    expect(callArgs).toBeInstanceOf(Result);
-    const user = (callArgs as GetUserOutput).unwrap().user;
-    expect(user).toBeInstanceOf(User);
-    expect(user.getId().value).toBe('user-1');
-    expect(user.getDisplayName()).toBe('John Smith');
+    const getUserResult = result.unwrap();
+    expect(getUserResult.user).toBeDefined();
+    expect(getUserResult.user.getId().value).toBe('user-1');
+    expect(getUserResult.user.getEmail()).toBe('test@example.com');
+    expect(userRepo.findById).toHaveBeenCalledWith('user-1');
   });
 
-  it('returns error when the user does not exist', async () => {
-    userRepository.findById.mockResolvedValue(null);
+  it('returns error when user not found', async () => {
+    userRepo.findById.mockResolvedValue(null);
 
-    const result = await useCase.execute({ userId: 'missing-user' });
+    const result = await useCase.execute({ userId: 'nonexistent' });
 
-    expect(userRepository.findById).toHaveBeenCalledWith('missing-user');
     expect(result.isErr()).toBe(true);
+    expect(result.unwrapErr().code).toBe('USER_NOT_FOUND');
+  });
+
+  it('returns error on repository failure', async () => {
+    userRepo.findById.mockRejectedValue(new Error('Database error'));
+
+    const result = await useCase.execute({ userId: 'user-1' });
+
+    expect(result.isErr()).toBe(true);
+    expect(result.unwrapErr().code).toBe('REPOSITORY_ERROR');
+    expect(logger.error).toHaveBeenCalled();
   });
 });