view data tests

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

@@ -0,0 +1,128 @@
+import { Result } from '@core/shared/domain/Result';
+import { describe, expect, it, vi, type Mock } from 'vitest';
+import type { MediaStoragePort } from '../ports/MediaStoragePort';
+import { GetUploadedMediaUseCase } from './GetUploadedMediaUseCase';
+
+describe('GetUploadedMediaUseCase', () => {
+  let mediaStorage: {
+    getBytes: Mock;
+    getMetadata: Mock;
+  };
+  let useCase: GetUploadedMediaUseCase;
+
+  beforeEach(() => {
+    mediaStorage = {
+      getBytes: vi.fn(),
+      getMetadata: vi.fn(),
+    };
+
+    useCase = new GetUploadedMediaUseCase(
+      mediaStorage as unknown as MediaStoragePort,
+    );
+  });
+
+  it('returns null when media is not found', async () => {
+    mediaStorage.getBytes.mockResolvedValue(null);
+
+    const input = { storageKey: 'missing-key' };
+    const result = await useCase.execute(input);
+
+    expect(mediaStorage.getBytes).toHaveBeenCalledWith('missing-key');
+    expect(result).toBeInstanceOf(Result);
+    expect(result.isOk()).toBe(true);
+    expect(result.unwrap()).toBe(null);
+  });
+
+  it('returns media bytes and content type when found', async () => {
+    const mockBytes = Buffer.from('test data');
+    const mockMetadata = { size: 9, contentType: 'image/png' };
+
+    mediaStorage.getBytes.mockResolvedValue(mockBytes);
+    mediaStorage.getMetadata.mockResolvedValue(mockMetadata);
+
+    const input = { storageKey: 'media-key' };
+    const result = await useCase.execute(input);
+
+    expect(mediaStorage.getBytes).toHaveBeenCalledWith('media-key');
+    expect(mediaStorage.getMetadata).toHaveBeenCalledWith('media-key');
+    expect(result.isOk()).toBe(true);
+
+    const successResult = result.unwrap();
+    expect(successResult).not.toBeNull();
+    expect(successResult!.bytes).toBeInstanceOf(Buffer);
+    expect(successResult!.bytes.toString()).toBe('test data');
+    expect(successResult!.contentType).toBe('image/png');
+  });
+
+  it('returns default content type when metadata is null', async () => {
+    const mockBytes = Buffer.from('test data');
+
+    mediaStorage.getBytes.mockResolvedValue(mockBytes);
+    mediaStorage.getMetadata.mockResolvedValue(null);
+
+    const input = { storageKey: 'media-key' };
+    const result = await useCase.execute(input);
+
+    expect(result.isOk()).toBe(true);
+
+    const successResult = result.unwrap();
+    expect(successResult!.contentType).toBe('application/octet-stream');
+  });
+
+  it('returns default content type when metadata has no contentType', async () => {
+    const mockBytes = Buffer.from('test data');
+    const mockMetadata = { size: 9 };
+
+    mediaStorage.getBytes.mockResolvedValue(mockBytes);
+    mediaStorage.getMetadata.mockResolvedValue(mockMetadata as any);
+
+    const input = { storageKey: 'media-key' };
+    const result = await useCase.execute(input);
+
+    expect(result.isOk()).toBe(true);
+
+    const successResult = result.unwrap();
+    expect(successResult!.contentType).toBe('application/octet-stream');
+  });
+
+  it('handles storage errors by returning error', async () => {
+    mediaStorage.getBytes.mockRejectedValue(new Error('Storage error'));
+
+    const input = { storageKey: 'media-key' };
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr();
+    expect(err.message).toBe('Storage error');
+  });
+
+  it('handles getMetadata errors by returning error', async () => {
+    const mockBytes = Buffer.from('test data');
+
+    mediaStorage.getBytes.mockResolvedValue(mockBytes);
+    mediaStorage.getMetadata.mockRejectedValue(new Error('Metadata error'));
+
+    const input = { storageKey: 'media-key' };
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr();
+    expect(err.message).toBe('Metadata error');
+  });
+
+  it('returns bytes as Buffer', async () => {
+    const mockBytes = new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f]); // "Hello"
+
+    mediaStorage.getBytes.mockResolvedValue(mockBytes);
+    mediaStorage.getMetadata.mockResolvedValue({ size: 5, contentType: 'text/plain' });
+
+    const input = { storageKey: 'media-key' };
+    const result = await useCase.execute(input);
+
+    expect(result.isOk()).toBe(true);
+
+    const successResult = result.unwrap();
+    expect(successResult!.bytes).toBeInstanceOf(Buffer);
+    expect(successResult!.bytes.toString()).toBe('Hello');
+  });
+});

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

@@ -0,0 +1,103 @@
+import { Result } from '@core/shared/domain/Result';
+import { describe, expect, it, vi, type Mock } from 'vitest';
+import type { MediaResolverPort } from '@core/ports/media/MediaResolverPort';
+import { ResolveMediaReferenceUseCase } from './ResolveMediaReferenceUseCase';
+
+describe('ResolveMediaReferenceUseCase', () => {
+  let mediaResolver: {
+    resolve: Mock;
+  };
+  let useCase: ResolveMediaReferenceUseCase;
+
+  beforeEach(() => {
+    mediaResolver = {
+      resolve: vi.fn(),
+    };
+
+    useCase = new ResolveMediaReferenceUseCase(
+      mediaResolver as unknown as MediaResolverPort,
+    );
+  });
+
+  it('returns resolved path when media reference is resolved', async () => {
+    mediaResolver.resolve.mockResolvedValue('/resolved/path/to/media.png');
+
+    const input = { reference: { type: 'team', id: 'team-123' } };
+    const result = await useCase.execute(input);
+
+    expect(mediaResolver.resolve).toHaveBeenCalledWith({ type: 'team', id: 'team-123' });
+    expect(result.isOk()).toBe(true);
+
+    const successResult = result.unwrap();
+    expect(successResult).toBe('/resolved/path/to/media.png');
+  });
+
+  it('returns null when media reference resolves to null', async () => {
+    mediaResolver.resolve.mockResolvedValue(null);
+
+    const input = { reference: { type: 'team', id: 'team-123' } };
+    const result = await useCase.execute(input);
+
+    expect(mediaResolver.resolve).toHaveBeenCalledWith({ type: 'team', id: 'team-123' });
+    expect(result.isOk()).toBe(true);
+
+    const successResult = result.unwrap();
+    expect(successResult).toBe(null);
+  });
+
+  it('returns empty string when media reference resolves to empty string', async () => {
+    mediaResolver.resolve.mockResolvedValue('');
+
+    const input = { reference: { type: 'team', id: 'team-123' } };
+    const result = await useCase.execute(input);
+
+    expect(mediaResolver.resolve).toHaveBeenCalledWith({ type: 'team', id: 'team-123' });
+    expect(result.isOk()).toBe(true);
+
+    const successResult = result.unwrap();
+    expect(successResult).toBe('');
+  });
+
+  it('handles resolver errors by returning error', async () => {
+    mediaResolver.resolve.mockRejectedValue(new Error('Resolver error'));
+
+    const input = { reference: { type: 'team', id: 'team-123' } };
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr();
+    expect(err.message).toBe('Resolver error');
+  });
+
+  it('handles non-Error exceptions by wrapping in Error', async () => {
+    mediaResolver.resolve.mockRejectedValue('string error');
+
+    const input = { reference: { type: 'team', id: 'team-123' } };
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr();
+    expect(err.message).toBe('string error');
+  });
+
+  it('resolves different reference types', async () => {
+    const testCases = [
+      { type: 'team', id: 'team-123' },
+      { type: 'league', id: 'league-456' },
+      { type: 'driver', id: 'driver-789' },
+    ];
+
+    for (const reference of testCases) {
+      mediaResolver.resolve.mockResolvedValue(`/resolved/${reference.type}/${reference.id}.png`);
+
+      const input = { reference };
+      const result = await useCase.execute(input);
+
+      expect(mediaResolver.resolve).toHaveBeenCalledWith(reference);
+      expect(result.isOk()).toBe(true);
+
+      const successResult = result.unwrap();
+      expect(successResult).toBe(`/resolved/${reference.type}/${reference.id}.png`);
+    }
+  });
+});