module cleanup

apps/api/src/domain/media/MediaController.test.ts

@@ -0,0 +1,181 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { vi } from 'vitest';
+import { MediaController } from './MediaController';
+import { MediaService } from './MediaService';
+import type { Response } from 'express';
+import { RequestAvatarGenerationInputDTO } from './dtos/RequestAvatarGenerationInputDTO';
+import { UploadMediaInputDTO } from './dtos/UploadMediaInputDTO';
+
+describe('MediaController', () => {
+  let controller: MediaController;
+  let service: ReturnType<typeof vi.mocked<MediaService>>;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      controllers: [MediaController],
+      providers: [
+        {
+          provide: MediaService,
+          useValue: {
+            requestAvatarGeneration: vi.fn(),
+            uploadMedia: vi.fn(),
+            getMedia: vi.fn(),
+            deleteMedia: vi.fn(),
+            getAvatar: vi.fn(),
+            updateAvatar: vi.fn(),
+          },
+        },
+      ],
+    }).compile();
+
+    controller = module.get<MediaController>(MediaController);
+    service = vi.mocked(module.get(MediaService));
+  });
+
+  describe('requestAvatarGeneration', () => {
+    it('should request avatar generation and return 201 on success', async () => {
+      const input: RequestAvatarGenerationInputDTO = { driverId: 'driver-123' };
+      const result = { success: true, jobId: 'job-123' };
+      service.requestAvatarGeneration.mockResolvedValue(result);
+
+      const mockRes: ReturnType<typeof vi.mocked<Response>> = {
+        status: vi.fn().mockReturnThis(),
+        json: vi.fn(),
+      } as unknown as ReturnType<typeof vi.mocked<Response>>;
+
+      await controller.requestAvatarGeneration(input, mockRes);
+
+      expect(service.requestAvatarGeneration).toHaveBeenCalledWith(input);
+      expect(mockRes.status).toHaveBeenCalledWith(201);
+      expect(mockRes.json).toHaveBeenCalledWith(result);
+    });
+
+    it('should return 400 on failure', async () => {
+      const input: RequestAvatarGenerationInputDTO = { driverId: 'driver-123' };
+      const result = { success: false, error: 'Error' };
+      service.requestAvatarGeneration.mockResolvedValue(result);
+
+      const mockRes: ReturnType<typeof vi.mocked<Response>> = {
+        status: vi.fn().mockReturnThis(),
+        json: vi.fn(),
+      } as unknown as ReturnType<typeof vi.mocked<Response>>;
+
+      await controller.requestAvatarGeneration(input, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(400);
+      expect(mockRes.json).toHaveBeenCalledWith(result);
+    });
+  });
+
+  describe('uploadMedia', () => {
+    it('should upload media and return 201 on success', async () => {
+      const file: Express.Multer.File = { filename: 'file.jpg' } as Express.Multer.File;
+      const input: UploadMediaInputDTO = { type: 'image' };
+      const result = { success: true, mediaId: 'media-123' };
+      service.uploadMedia.mockResolvedValue(result);
+
+      const mockRes: ReturnType<typeof vi.mocked<Response>> = {
+        status: vi.fn().mockReturnThis(),
+        json: vi.fn(),
+      } as unknown as ReturnType<typeof vi.mocked<Response>>;
+
+      await controller.uploadMedia(file, input, mockRes);
+
+      expect(service.uploadMedia).toHaveBeenCalledWith({ ...input, file });
+      expect(mockRes.status).toHaveBeenCalledWith(201);
+      expect(mockRes.json).toHaveBeenCalledWith(result);
+    });
+  });
+
+  describe('getMedia', () => {
+    it('should return media if found', async () => {
+      const mediaId = 'media-123';
+      const result = { id: mediaId, url: 'url' };
+      service.getMedia.mockResolvedValue(result);
+
+      const mockRes: ReturnType<typeof vi.mocked<Response>> = {
+        status: vi.fn().mockReturnThis(),
+        json: vi.fn(),
+      } as unknown as ReturnType<typeof vi.mocked<Response>>;
+
+      await controller.getMedia(mediaId, mockRes);
+
+      expect(service.getMedia).toHaveBeenCalledWith(mediaId);
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      expect(mockRes.json).toHaveBeenCalledWith(result);
+    });
+
+    it('should return 404 if not found', async () => {
+      const mediaId = 'media-123';
+      service.getMedia.mockResolvedValue(null);
+
+      const mockRes: ReturnType<typeof vi.mocked<Response>> = {
+        status: vi.fn().mockReturnThis(),
+        json: vi.fn(),
+      } as unknown as ReturnType<typeof vi.mocked<Response>>;
+
+      await controller.getMedia(mediaId, mockRes);
+
+      expect(mockRes.status).toHaveBeenCalledWith(404);
+      expect(mockRes.json).toHaveBeenCalledWith({ error: 'Media not found' });
+    });
+  });
+
+  describe('deleteMedia', () => {
+    it('should delete media', async () => {
+      const mediaId = 'media-123';
+      const result = { success: true };
+      service.deleteMedia.mockResolvedValue(result);
+
+      const mockRes: ReturnType<typeof vi.mocked<Response>> = {
+        status: vi.fn().mockReturnThis(),
+        json: vi.fn(),
+      } as unknown as ReturnType<typeof vi.mocked<Response>>;
+
+      await controller.deleteMedia(mediaId, mockRes);
+
+      expect(service.deleteMedia).toHaveBeenCalledWith(mediaId);
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      expect(mockRes.json).toHaveBeenCalledWith(result);
+    });
+  });
+
+  describe('getAvatar', () => {
+    it('should return avatar if found', async () => {
+      const driverId = 'driver-123';
+      const result = { url: 'avatar.jpg' };
+      service.getAvatar.mockResolvedValue(result);
+
+      const mockRes: ReturnType<typeof vi.mocked<Response>> = {
+        status: vi.fn().mockReturnThis(),
+        json: vi.fn(),
+      } as unknown as ReturnType<typeof vi.mocked<Response>>;
+
+      await controller.getAvatar(driverId, mockRes);
+
+      expect(service.getAvatar).toHaveBeenCalledWith(driverId);
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      expect(mockRes.json).toHaveBeenCalledWith(result);
+    });
+  });
+
+  describe('updateAvatar', () => {
+    it('should update avatar', async () => {
+      const driverId = 'driver-123';
+      const input = { url: 'new-avatar.jpg' };
+      const result = { success: true };
+      service.updateAvatar.mockResolvedValue(result);
+
+      const mockRes: ReturnType<typeof vi.mocked<Response>> = {
+        status: vi.fn().mockReturnThis(),
+        json: vi.fn(),
+      } as unknown as ReturnType<typeof vi.mocked<Response>>;
+
+      await controller.updateAvatar(driverId, input, mockRes);
+
+      expect(service.updateAvatar).toHaveBeenCalledWith(driverId, input);
+      expect(mockRes.status).toHaveBeenCalledWith(200);
+      expect(mockRes.json).toHaveBeenCalledWith(result);
+    });
+  });
+});