129 lines
4.2 KiB
TypeScript
129 lines
4.2 KiB
TypeScript
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');
|
|
});
|
|
});
|