refactor use cases

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

@@ -1,12 +1,23 @@
 import { describe, it, expect, vi, type Mock } from 'vitest';
-import { DeleteMediaUseCase } from './DeleteMediaUseCase';
+import {
+  DeleteMediaUseCase,
+  type DeleteMediaInput,
+  type DeleteMediaResult,
+  type DeleteMediaErrorCode,
+} from './DeleteMediaUseCase';
 import type { IMediaRepository } from '../../domain/repositories/IMediaRepository';
 import type { MediaStoragePort } from '../ports/MediaStoragePort';
-import type { IDeleteMediaPresenter } from '../presenters/IDeleteMediaPresenter';
-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 { Media } from '../../domain/entities/Media';
 import { MediaUrl } from '../../domain/value-objects/MediaUrl';
 
+interface TestOutputPort extends UseCaseOutputPort<DeleteMediaResult> {
+  present: Mock;
+  result?: DeleteMediaResult;
+}
+
 describe('DeleteMediaUseCase', () => {
   let mediaRepo: {
     findById: Mock;
@@ -16,7 +27,7 @@ describe('DeleteMediaUseCase', () => {
     deleteMedia: Mock;
   };
   let logger: Logger;
-  let presenter: IDeleteMediaPresenter & { result?: any };
+  let output: TestOutputPort;
   let useCase: DeleteMediaUseCase;
 
   beforeEach(() => {
@@ -36,29 +47,35 @@ describe('DeleteMediaUseCase', () => {
       error: vi.fn(),
     } as unknown as Logger;
 
-    presenter = {
-      present: vi.fn((result) => {
-        (presenter as any).result = result;
+    output = {
+      present: vi.fn((result: DeleteMediaResult) => {
+        output.result = result;
       }),
-    } as unknown as IDeleteMediaPresenter & { result?: any };
+    } as unknown as TestOutputPort;
 
     useCase = new DeleteMediaUseCase(
       mediaRepo as unknown as IMediaRepository,
       mediaStorage as unknown as MediaStoragePort,
+      output,
       logger,
     );
   });
 
-  it('returns error result when media is not found', async () => {
+  it('returns MEDIA_NOT_FOUND when media is not found', async () => {
     mediaRepo.findById.mockResolvedValue(null);
 
-    await useCase.execute({ mediaId: 'missing' }, presenter);
+    const input: DeleteMediaInput = { mediaId: 'missing' };
+    const result = await useCase.execute(input);
 
     expect(mediaRepo.findById).toHaveBeenCalledWith('missing');
-    expect((presenter.present as unknown as Mock)).toHaveBeenCalledWith({
-      success: false,
-      errorMessage: 'Media not found',
-    });
+    expect(result).toBeInstanceOf(Result);
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      DeleteMediaErrorCode,
+      { message: string }
+    >;
+    expect(err.code).toBe('MEDIA_NOT_FOUND');
+    expect(output.present).not.toHaveBeenCalled();
   });
 
   it('deletes media from storage and repository on success', async () => {
@@ -68,30 +85,39 @@ describe('DeleteMediaUseCase', () => {
       originalName: 'file.png',
       mimeType: 'image/png',
       size: 123,
-      url: MediaUrl.create('https://example.com/file.png'),
+      url: 'https://example.com/file.png',
       type: 'image',
       uploadedBy: 'user-1',
     });
 
     mediaRepo.findById.mockResolvedValue(media);
 
-    await useCase.execute({ mediaId: 'media-1' }, presenter);
+    const input: DeleteMediaInput = { mediaId: 'media-1' };
+    const result = await useCase.execute(input);
 
+    expect(result.isOk()).toBe(true);
     expect(mediaRepo.findById).toHaveBeenCalledWith('media-1');
     expect(mediaStorage.deleteMedia).toHaveBeenCalledWith(media.url.value);
     expect(mediaRepo.delete).toHaveBeenCalledWith('media-1');
-    expect((presenter.present as unknown as Mock)).toHaveBeenCalledWith({ success: true });
-  });
-
-  it('handles errors and presents failure result', async () => {
-    mediaRepo.findById.mockRejectedValue(new Error('DB error'));
-
-    await useCase.execute({ mediaId: 'media-1' }, presenter);
-
-    expect((logger.error as unknown as Mock)).toHaveBeenCalled();
-    expect((presenter.present as unknown as Mock)).toHaveBeenCalledWith({
-      success: false,
-      errorMessage: 'Internal error occurred while deleting media',
+    expect(output.present).toHaveBeenCalledWith({
+      mediaId: 'media-1',
+      deleted: true,
     });
   });
+
+  it('handles repository errors by returning REPOSITORY_ERROR', async () => {
+    mediaRepo.findById.mockRejectedValue(new Error('DB error'));
+
+    const input: DeleteMediaInput = { mediaId: 'media-1' };
+    const result = await useCase.execute(input);
+
+    expect((logger.error as unknown as Mock)).toHaveBeenCalled();
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr() as ApplicationErrorCode<
+      DeleteMediaErrorCode,
+      { message: string }
+    >;
+    expect(err.code).toBe('REPOSITORY_ERROR');
+    expect(output.present).not.toHaveBeenCalled();
+  });
 });