refactor use cases

core/media/application/use-cases/GetAvatarUseCase.test.ts

@@ -1,13 +1,19 @@
 import { describe, it, expect, vi, type Mock } from 'vitest';
-import { GetAvatarUseCase } from './GetAvatarUseCase';
+import {
+  GetAvatarUseCase,
+  type GetAvatarInput,
+  type GetAvatarResult,
+  type GetAvatarErrorCode,
+} from './GetAvatarUseCase';
 import type { IAvatarRepository } from '../../domain/repositories/IAvatarRepository';
-import type { IGetAvatarPresenter } from '../presenters/IGetAvatarPresenter';
-import type { Logger } from '@core/shared/application';
+import type { Logger, UseCaseOutputPort } from '@core/shared/application';
+import { Result } from '@core/shared/application/Result';
+import type { ApplicationErrorCode } from '@core/shared/errors/ApplicationErrorCode';
 import { Avatar } from '../../domain/entities/Avatar';
-import { MediaUrl } from '../../domain/value-objects/MediaUrl';
 
-interface TestPresenter extends IGetAvatarPresenter {
-  result?: any;
+interface TestOutputPort extends UseCaseOutputPort<GetAvatarResult> {
+  present: Mock;
+  result?: GetAvatarResult;
 }
 
 describe('GetAvatarUseCase', () => {
@@ -16,7 +22,7 @@ describe('GetAvatarUseCase', () => {
     save: Mock;
   };
   let logger: Logger;
-  let presenter: TestPresenter;
+  let output: TestOutputPort;
   let useCase: GetAvatarUseCase;
 
   beforeEach(() => {
@@ -32,44 +38,51 @@ describe('GetAvatarUseCase', () => {
       error: vi.fn(),
     } as unknown as Logger;
 
-    presenter = {
-      present: vi.fn((result) => {
-        presenter.result = result;
+    output = {
+      present: vi.fn((result: GetAvatarResult) => {
+        output.result = result;
       }),
-    } as unknown as TestPresenter;
+    } as unknown as TestOutputPort;
 
     useCase = new GetAvatarUseCase(
       avatarRepo as unknown as IAvatarRepository,
+      output,
       logger,
     );
   });
 
-  it('presents error when no avatar exists for driver', async () => {
+  it('returns AVATAR_NOT_FOUND when no avatar exists for driver', async () => {
     avatarRepo.findActiveByDriverId.mockResolvedValue(null);
 
-    await useCase.execute({ driverId: 'driver-1' }, presenter);
+    const input: GetAvatarInput = { driverId: 'driver-1' };
+    const result = await useCase.execute(input);
 
     expect(avatarRepo.findActiveByDriverId).toHaveBeenCalledWith('driver-1');
-    expect((presenter.present as unknown as Mock)).toHaveBeenCalledWith({
-      success: false,
-      errorMessage: 'Avatar not found',
-    });
+    expect(result).toBeInstanceOf(Result);
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      GetAvatarErrorCode,
+      { message: string }
+    >;
+    expect(err.code).toBe('AVATAR_NOT_FOUND');
+    expect(output.present).not.toHaveBeenCalled();
   });
 
   it('presents avatar details when avatar exists', async () => {
     const avatar = Avatar.create({
       id: 'avatar-1',
       driverId: 'driver-1',
-      mediaUrl: MediaUrl.create('https://example.com/avatar.png'),
+      mediaUrl: 'https://example.com/avatar.png',
     });
 
     avatarRepo.findActiveByDriverId.mockResolvedValue(avatar);
 
-    await useCase.execute({ driverId: 'driver-1' }, presenter);
+    const input: GetAvatarInput = { driverId: 'driver-1' };
+    const result = await useCase.execute(input);
 
+    expect(result.isOk()).toBe(true);
     expect(avatarRepo.findActiveByDriverId).toHaveBeenCalledWith('driver-1');
-    expect((presenter.present as unknown as Mock)).toHaveBeenCalledWith({
-      success: true,
+    expect(output.present).toHaveBeenCalledWith({
       avatar: {
         id: avatar.id,
         driverId: avatar.driverId,
@@ -79,15 +92,19 @@ describe('GetAvatarUseCase', () => {
     });
   });
 
-  it('handles errors by logging and presenting failure', async () => {
+  it('handles repository errors by returning REPOSITORY_ERROR', async () => {
     avatarRepo.findActiveByDriverId.mockRejectedValue(new Error('DB error'));
 
-    await useCase.execute({ driverId: 'driver-1' }, presenter);
+    const input: GetAvatarInput = { driverId: 'driver-1' };
+    const result = await useCase.execute(input);
 
     expect((logger.error as unknown as Mock)).toHaveBeenCalled();
-    expect((presenter.present as unknown as Mock)).toHaveBeenCalledWith({
-      success: false,
-      errorMessage: 'Internal error occurred while retrieving avatar',
-    });
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      GetAvatarErrorCode,
+      { message: string }
+    >;
+    expect(err.code).toBe('REPOSITORY_ERROR');
+    expect(output.present).not.toHaveBeenCalled();
   });
 });