integration tests

tests/integration/media/general/media-management.test.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { MediaTestContext } from '../MediaTestContext';
+import { Media } from '@core/media/domain/entities/Media';
+import type { MulterFile } from '@core/media/application/use-cases/UploadMediaUseCase';
+
+describe('General Media Management: Upload, Retrieval, and Deletion', () => {
+  let ctx: MediaTestContext;
+
+  beforeEach(() => {
+    ctx = MediaTestContext.create();
+    ctx.reset();
+  });
+
+  const createMockFile = (filename: string, mimeType: string, content: Buffer): MulterFile => ({
+    fieldname: 'file',
+    originalname: filename,
+    encoding: '7bit',
+    mimetype: mimeType,
+    size: content.length,
+    buffer: content,
+    stream: null as any,
+    destination: '',
+    filename: filename,
+    path: '',
+  });
+
+  describe('UploadMediaUseCase', () => {
+    it('should upload media successfully', async () => {
+      const content = Buffer.from('test content');
+      const file = createMockFile('test.png', 'image/png', content);
+
+      const result = await ctx.uploadMediaUseCase.execute({
+        file,
+        uploadedBy: 'user-1',
+      });
+
+      expect(result.isOk()).toBe(true);
+      const successResult = result.unwrap();
+      expect(successResult.mediaId).toBeDefined();
+      expect(successResult.url).toBeDefined();
+
+      const media = await ctx.mediaRepository.findById(successResult.mediaId);
+      expect(media).not.toBeNull();
+      expect(media?.filename).toBe('test.png');
+    });
+  });
+
+  describe('GetMediaUseCase', () => {
+    it('should retrieve media by ID', async () => {
+      const media = Media.create({
+        id: 'media-1',
+        filename: 'test.png',
+        originalName: 'test.png',
+        mimeType: 'image/png',
+        size: 100,
+        url: 'https://example.com/test.png',
+        type: 'image',
+        uploadedBy: 'user-1',
+      });
+      await ctx.mediaRepository.save(media);
+
+      const result = await ctx.getMediaUseCase.execute({ mediaId: 'media-1' });
+
+      expect(result.isOk()).toBe(true);
+      const successResult = result.unwrap();
+      expect(successResult.media.id).toBe('media-1');
+    });
+
+    it('should return MEDIA_NOT_FOUND when media does not exist', async () => {
+      const result = await ctx.getMediaUseCase.execute({ mediaId: 'non-existent' });
+
+      expect(result.isErr()).toBe(true);
+      expect(result.unwrapErr().code).toBe('MEDIA_NOT_FOUND');
+    });
+  });
+
+  describe('GetUploadedMediaUseCase', () => {
+    it('should retrieve uploaded media content', async () => {
+      const uploadResult = await ctx.mediaStorage.uploadMedia(
+        Buffer.from('test content'),
+        { filename: 'test.png', mimeType: 'image/png' }
+      );
+      const storageKey = uploadResult.url!;
+
+      const result = await ctx.getUploadedMediaUseCase.execute({ storageKey });
+
+      expect(result.isOk()).toBe(true);
+      const successResult = result.unwrap();
+      expect(successResult?.bytes.toString()).toBe('test content');
+      expect(successResult?.contentType).toBe('image/png');
+    });
+
+    it('should return null when media does not exist in storage', async () => {
+      const result = await ctx.getUploadedMediaUseCase.execute({ storageKey: 'non-existent' });
+
+      expect(result.isOk()).toBe(true);
+      expect(result.unwrap()).toBeNull();
+    });
+  });
+
+  describe('DeleteMediaUseCase', () => {
+    it('should delete media file and repository entry', async () => {
+      const uploadResult = await ctx.mediaStorage.uploadMedia(
+        Buffer.from('test content'),
+        { filename: 'test.png', mimeType: 'image/png' }
+      );
+      const storageKey = uploadResult.url!;
+
+      const media = Media.create({
+        id: 'media-1',
+        filename: 'test.png',
+        originalName: 'test.png',
+        mimeType: 'image/png',
+        size: 12,
+        url: storageKey,
+        type: 'image',
+        uploadedBy: 'user-1',
+      });
+      await ctx.mediaRepository.save(media);
+
+      const result = await ctx.deleteMediaUseCase.execute({ mediaId: 'media-1' });
+
+      expect(result.isOk()).toBe(true);
+      expect(result.unwrap().deleted).toBe(true);
+
+      const deletedMedia = await ctx.mediaRepository.findById('media-1');
+      expect(deletedMedia).toBeNull();
+
+      const storageExists = ctx.mediaStorage.has(storageKey);
+      expect(storageExists).toBe(false);
+    });
+
+    it('should return MEDIA_NOT_FOUND when media does not exist', async () => {
+      const result = await ctx.deleteMediaUseCase.execute({ mediaId: 'non-existent' });
+
+      expect(result.isErr()).toBe(true);
+      expect(result.unwrapErr().code).toBe('MEDIA_NOT_FOUND');
+    });
+  });
+});