tests

apps/api/src/domain/media/presenters/DeleteMediaPresenter.test.ts

@@ -0,0 +1,61 @@
+import { DeleteMediaPresenter } from './DeleteMediaPresenter';
+
+describe('DeleteMediaPresenter', () => {
+  let presenter: DeleteMediaPresenter;
+
+  beforeEach(() => {
+    presenter = new DeleteMediaPresenter();
+  });
+
+  describe('transform', () => {
+    it('should map successful result to response model', () => {
+      const result = { mediaId: 'media-123', deleted: true };
+
+      const response = presenter.transform(result);
+
+      expect(response).toEqual({ success: true });
+      expect(presenter.getResponseModel()).toEqual({ success: true });
+    });
+
+    it('should handle failed deletion', () => {
+      const result = { mediaId: 'media-123', deleted: false };
+
+      const response = presenter.transform(result);
+
+      expect(response).toEqual({ success: false });
+      expect(presenter.getResponseModel()).toEqual({ success: false });
+    });
+  });
+
+  describe('reset', () => {
+    it('should clear the model', () => {
+      presenter.transform({ mediaId: 'media-123', deleted: true });
+      expect(presenter.getResponseModel()).not.toBeNull();
+
+      presenter.reset();
+      expect(presenter.getResponseModel()).toBeNull();
+    });
+  });
+
+  describe('responseModel', () => {
+    it('should throw error when accessed before transform()', () => {
+      expect(() => presenter.responseModel).toThrow('Presenter not presented');
+    });
+
+    it('should return model after transform()', () => {
+      presenter.transform({ mediaId: 'media-123', deleted: true });
+      expect(presenter.responseModel).toEqual({ success: true });
+    });
+  });
+
+  describe('getResponseModel', () => {
+    it('should return null before transform()', () => {
+      expect(presenter.getResponseModel()).toBeNull();
+    });
+
+    it('should return model after transform()', () => {
+      presenter.transform({ mediaId: 'media-123', deleted: true });
+      expect(presenter.getResponseModel()).toEqual({ success: true });
+    });
+  });
+});

apps/api/src/domain/media/presenters/GetAvatarPresenter.test.ts

@@ -0,0 +1,95 @@
+import { GetAvatarPresenter } from './GetAvatarPresenter';
+
+describe('GetAvatarPresenter', () => {
+  let presenter: GetAvatarPresenter;
+
+  beforeEach(() => {
+    presenter = new GetAvatarPresenter();
+  });
+
+  describe('transform', () => {
+    it('should map result to response model', () => {
+      const result = {
+        avatar: {
+          id: 'avatar-123',
+          driverId: 'driver-456',
+          mediaUrl: 'https://example.com/avatar.png',
+          selectedAt: new Date('2024-01-01'),
+        },
+      };
+
+      const response = presenter.transform(result);
+
+      expect(response).toEqual({ avatarUrl: 'https://example.com/avatar.png' });
+      expect(presenter.getResponseModel()).toEqual({ avatarUrl: 'https://example.com/avatar.png' });
+    });
+
+    it('should handle different avatar URLs', () => {
+      const result = {
+        avatar: {
+          id: 'avatar-789',
+          driverId: 'driver-456',
+          mediaUrl: 'https://cdn.example.com/avatars/test.jpg',
+          selectedAt: new Date('2024-01-02'),
+        },
+      };
+
+      const response = presenter.transform(result);
+
+      expect(response).toEqual({ avatarUrl: 'https://cdn.example.com/avatars/test.jpg' });
+    });
+  });
+
+  describe('reset', () => {
+    it('should clear the model', () => {
+      presenter.transform({
+        avatar: {
+          id: 'avatar-123',
+          driverId: 'driver-456',
+          mediaUrl: 'https://example.com/avatar.png',
+          selectedAt: new Date('2024-01-01'),
+        },
+      });
+      expect(presenter.getResponseModel()).not.toBeNull();
+
+      presenter.reset();
+      expect(presenter.getResponseModel()).toBeNull();
+    });
+  });
+
+  describe('responseModel', () => {
+    it('should return null when model is null', () => {
+      expect(presenter.responseModel).toBeNull();
+    });
+
+    it('should return model after transform()', () => {
+      presenter.transform({
+        avatar: {
+          id: 'avatar-123',
+          driverId: 'driver-456',
+          mediaUrl: 'https://example.com/avatar.png',
+          selectedAt: new Date('2024-01-01'),
+        },
+      });
+      expect(presenter.responseModel).toEqual({ avatarUrl: 'https://example.com/avatar.png' });
+    });
+  });
+
+  describe('getResponseModel', () => {
+    it('should return null before transform()', () => {
+      expect(presenter.getResponseModel()).toBeNull();
+    });
+
+    it('should return model after transform()', () => {
+      presenter.transform({
+        avatar: {
+          id: 'avatar-123',
+          driverId: 'driver-456',
+          mediaUrl: 'https://example.com/avatar.png',
+          selectedAt: new Date('2024-01-01'),
+        },
+      });
+      expect(presenter.getResponseModel()).toEqual({ avatarUrl: 'https://example.com/avatar.png' });
+    });
+  });
+});

apps/api/src/domain/media/presenters/GetMediaPresenter.test.ts

@@ -0,0 +1,165 @@
+import { GetMediaPresenter } from './GetMediaPresenter';
+
+describe('GetMediaPresenter', () => {
+  let presenter: GetMediaPresenter;
+
+  beforeEach(() => {
+    presenter = new GetMediaPresenter();
+  });
+
+  describe('transform', () => {
+    it('should map result to response model', () => {
+      const result = {
+        media: {
+          id: 'media-123',
+          filename: 'avatar.png',
+          originalName: 'my-avatar.png',
+          mimeType: 'image/png',
+          size: 12345,
+          url: 'https://example.com/avatar.png',
+          type: 'image',
+          uploadedBy: 'user-456',
+          uploadedAt: new Date('2024-01-01'),
+        },
+      };
+
+      const response = presenter.transform(result);
+
+      expect(response).toEqual({
+        id: 'media-123',
+        url: 'https://example.com/avatar.png',
+        type: 'image',
+        uploadedAt: new Date('2024-01-01'),
+        size: 12345,
+      });
+    });
+
+    it('should handle metadata', () => {
+      const result = {
+        media: {
+          id: 'media-123',
+          filename: 'avatar.png',
+          originalName: 'my-avatar.png',
+          mimeType: 'image/png',
+          size: 12345,
+          url: 'https://example.com/avatar.png',
+          type: 'image',
+          uploadedBy: 'user-456',
+          uploadedAt: new Date('2024-01-01'),
+          metadata: { category: 'profile', width: 100, height: 100 },
+        },
+      };
+
+      const response = presenter.transform(result);
+
+      expect(response).toEqual({
+        id: 'media-123',
+        url: 'https://example.com/avatar.png',
+        type: 'image',
+        uploadedAt: new Date('2024-01-01'),
+        size: 12345,
+        category: 'profile',
+      });
+    });
+
+    it('should handle result without metadata', () => {
+      const result = {
+        media: {
+          id: 'media-123',
+          filename: 'avatar.png',
+          originalName: 'my-avatar.png',
+          mimeType: 'image/png',
+          size: 12345,
+          url: 'https://example.com/avatar.png',
+          type: 'image',
+          uploadedBy: 'user-456',
+          uploadedAt: new Date('2024-01-01'),
+        },
+      };
+
+      const response = presenter.transform(result);
+
+      expect(response?.category).toBeUndefined();
+    });
+  });
+
+  describe('reset', () => {
+    it('should clear the model', () => {
+      presenter.transform({
+        media: {
+          id: 'media-123',
+          filename: 'avatar.png',
+          originalName: 'my-avatar.png',
+          mimeType: 'image/png',
+          size: 12345,
+          url: 'https://example.com/avatar.png',
+          type: 'image',
+          uploadedBy: 'user-456',
+          uploadedAt: new Date('2024-01-01'),
+        },
+      });
+      expect(presenter.getResponseModel()).not.toBeNull();
+
+      presenter.reset();
+      expect(presenter.getResponseModel()).toBeNull();
+    });
+  });
+
+  describe('responseModel', () => {
+    it('should return null when model is null', () => {
+      expect(presenter.responseModel).toBeNull();
+    });
+
+    it('should return model after transform()', () => {
+      presenter.transform({
+        media: {
+          id: 'media-123',
+          filename: 'avatar.png',
+          originalName: 'my-avatar.png',
+          mimeType: 'image/png',
+          size: 12345,
+          url: 'https://example.com/avatar.png',
+          type: 'image',
+          uploadedBy: 'user-456',
+          uploadedAt: new Date('2024-01-01'),
+        },
+      });
+      expect(presenter.responseModel).toEqual({
+        id: 'media-123',
+        url: 'https://example.com/avatar.png',
+        type: 'image',
+        uploadedAt: new Date('2024-01-01'),
+        size: 12345,
+      });
+    });
+  });
+
+  describe('getResponseModel', () => {
+    it('should return null before transform()', () => {
+      expect(presenter.getResponseModel()).toBeNull();
+    });
+
+    it('should return model after transform()', () => {
+      presenter.transform({
+        media: {
+          id: 'media-123',
+          filename: 'avatar.png',
+          originalName: 'my-avatar.png',
+          mimeType: 'image/png',
+          size: 12345,
+          url: 'https://example.com/avatar.png',
+          type: 'image',
+          uploadedBy: 'user-456',
+          uploadedAt: new Date('2024-01-01'),
+        },
+      });
+      expect(presenter.getResponseModel()).toEqual({
+        id: 'media-123',
+        url: 'https://example.com/avatar.png',
+        type: 'image',
+        uploadedAt: new Date('2024-01-01'),
+        size: 12345,
+      });
+    });
+  });
+});

apps/api/src/domain/media/presenters/RequestAvatarGenerationPresenter.test.ts

@@ -0,0 +1,126 @@
+import { RequestAvatarGenerationPresenter } from './RequestAvatarGenerationPresenter';
+
+describe('RequestAvatarGenerationPresenter', () => {
+  let presenter: RequestAvatarGenerationPresenter;
+
+  beforeEach(() => {
+    presenter = new RequestAvatarGenerationPresenter();
+  });
+
+  describe('transform', () => {
+    it('should map completed result to response model', () => {
+      const result = {
+        requestId: 'req-123',
+        status: 'completed' as const,
+        avatarUrls: ['https://example.com/avatar1.png', 'https://example.com/avatar2.png'],
+      };
+
+      const response = presenter.transform(result);
+
+      expect(response).toEqual({
+        success: true,
+        requestId: 'req-123',
+        avatarUrls: ['https://example.com/avatar1.png', 'https://example.com/avatar2.png'],
+      });
+    });
+
+    it('should handle empty avatarUrls', () => {
+      const result = {
+        requestId: 'req-123',
+        status: 'completed' as const,
+        avatarUrls: [],
+      };
+
+      const response = presenter.transform(result);
+
+      expect(response).toEqual({
+        success: true,
+        requestId: 'req-123',
+        avatarUrls: [],
+      });
+    });
+
+    it('should handle undefined avatarUrls', () => {
+      const result = {
+        requestId: 'req-123',
+        status: 'completed' as const,
+      };
+
+      const response = presenter.transform(result);
+
+      expect(response).toEqual({
+        success: true,
+        requestId: 'req-123',
+        avatarUrls: [],
+      });
+    });
+
+    it('should handle non-completed status', () => {
+      const result = {
+        requestId: 'req-123',
+        status: 'generating' as const,
+        avatarUrls: [],
+      };
+
+      const response = presenter.transform(result);
+
+      expect(response).toEqual({
+        success: false,
+        requestId: 'req-123',
+        avatarUrls: [],
+      });
+    });
+  });
+
+  describe('reset', () => {
+    it('should clear the model', () => {
+      presenter.transform({
+        requestId: 'req-123',
+        status: 'completed' as const,
+        avatarUrls: ['https://example.com/avatar1.png'],
+      });
+      expect(presenter.getResponseModel()).not.toBeNull();
+
+      presenter.reset();
+      expect(presenter.getResponseModel()).toBeNull();
+    });
+  });
+
+  describe('responseModel', () => {
+    it('should throw error when accessed before transform()', () => {
+      expect(() => presenter.responseModel).toThrow('Presenter not presented');
+    });
+
+    it('should return model after transform()', () => {
+      presenter.transform({
+        requestId: 'req-123',
+        status: 'completed' as const,
+        avatarUrls: ['https://example.com/avatar1.png'],
+      });
+      expect(presenter.responseModel).toEqual({
+        success: true,
+        requestId: 'req-123',
+        avatarUrls: ['https://example.com/avatar1.png'],
+      });
+    });
+  });
+
+  describe('getResponseModel', () => {
+    it('should return null before transform()', () => {
+      expect(presenter.getResponseModel()).toBeNull();
+    });
+
+    it('should return model after transform()', () => {
+      presenter.transform({
+        requestId: 'req-123',
+        status: 'completed' as const,
+        avatarUrls: ['https://example.com/avatar1.png'],
+      });
+      expect(presenter.getResponseModel()).toEqual({
+        success: true,
+        requestId: 'req-123',
+        avatarUrls: ['https://example.com/avatar1.png'],
+      });
+    });
+  });
+});

apps/api/src/domain/media/presenters/UpdateAvatarPresenter.test.ts

@@ -0,0 +1,66 @@
+import { UpdateAvatarPresenter } from './UpdateAvatarPresenter';
+
+describe('UpdateAvatarPresenter', () => {
+  let presenter: UpdateAvatarPresenter;
+
+  beforeEach(() => {
+    presenter = new UpdateAvatarPresenter();
+  });
+
+  describe('transform', () => {
+    it('should map result to response model', () => {
+      const result = {
+        avatarId: 'avatar-123',
+        driverId: 'driver-456',
+      };
+
+      const response = presenter.transform(result);
+
+      expect(response).toEqual({ success: true });
+      expect(presenter.getResponseModel()).toEqual({ success: true });
+    });
+
+    it('should always return success true', () => {
+      const result = {
+        avatarId: 'avatar-789',
+        driverId: 'driver-999',
+      };
+
+      const response = presenter.transform(result);
+
+      expect(response.success).toBe(true);
+    });
+  });
+
+  describe('reset', () => {
+    it('should clear the model', () => {
+      presenter.transform({ avatarId: 'avatar-123', driverId: 'driver-456' });
+      expect(presenter.getResponseModel()).not.toBeNull();
+
+      presenter.reset();
+      expect(presenter.getResponseModel()).toBeNull();
+    });
+  });
+
+  describe('responseModel', () => {
+    it('should throw error when accessed before transform()', () => {
+      expect(() => presenter.responseModel).toThrow('Presenter not presented');
+    });
+
+    it('should return model after transform()', () => {
+      presenter.transform({ avatarId: 'avatar-123', driverId: 'driver-456' });
+      expect(presenter.responseModel).toEqual({ success: true });
+    });
+  });
+
+  describe('getResponseModel', () => {
+    it('should return null before transform()', () => {
+      expect(presenter.getResponseModel()).toBeNull();
+    });
+
+    it('should return model after transform()', () => {
+      presenter.transform({ avatarId: 'avatar-123', driverId: 'driver-456' });
+      expect(presenter.getResponseModel()).toEqual({ success: true });
+    });
+  });
+});

apps/api/src/domain/media/presenters/UploadMediaPresenter.test.ts

@@ -0,0 +1,92 @@
+import { UploadMediaPresenter } from './UploadMediaPresenter';
+
+describe('UploadMediaPresenter', () => {
+  let presenter: UploadMediaPresenter;
+
+  beforeEach(() => {
+    presenter = new UploadMediaPresenter();
+  });
+
+  describe('transform', () => {
+    it('should map result with URL to response model', () => {
+      const result = {
+        mediaId: 'media-123',
+        url: 'https://example.com/uploaded-file.png',
+      };
+
+      const response = presenter.transform(result);
+
+      expect(response).toEqual({
+        success: true,
+        mediaId: 'media-123',
+        url: 'https://example.com/uploaded-file.png',
+      });
+    });
+
+    it('should map result without URL to response model', () => {
+      const result = {
+        mediaId: 'media-123',
+        url: undefined,
+      };
+
+      const response = presenter.transform(result);
+
+      expect(response).toEqual({
+        success: true,
+        mediaId: 'media-123',
+      });
+      expect(response.url).toBeUndefined();
+    });
+
+    it('should always set success to true', () => {
+      const result = {
+        mediaId: 'media-456',
+        url: 'https://example.com/test.jpg',
+      };
+
+      const response = presenter.transform(result);
+
+      expect(response.success).toBe(true);
+    });
+  });
+
+  describe('reset', () => {
+    it('should clear the model', () => {
+      presenter.transform({ mediaId: 'media-123', url: 'https://example.com/file.png' });
+      expect(presenter.getResponseModel()).not.toBeNull();
+
+      presenter.reset();
+      expect(presenter.getResponseModel()).toBeNull();
+    });
+  });
+
+  describe('responseModel', () => {
+    it('should throw error when accessed before transform()', () => {
+      expect(() => presenter.responseModel).toThrow('Presenter not presented');
+    });
+
+    it('should return model after transform()', () => {
+      presenter.transform({ mediaId: 'media-123', url: 'https://example.com/file.png' });
+      expect(presenter.responseModel).toEqual({
+        success: true,
+        mediaId: 'media-123',
+        url: 'https://example.com/file.png',
+      });
+    });
+  });
+
+  describe('getResponseModel', () => {
+    it('should return null before transform()', () => {
+      expect(presenter.getResponseModel()).toBeNull();
+    });
+
+    it('should return model after transform()', () => {
+      presenter.transform({ mediaId: 'media-123', url: 'https://example.com/file.png' });
+      expect(presenter.getResponseModel()).toEqual({
+        success: true,
+        mediaId: 'media-123',
+        url: 'https://example.com/file.png',
+      });
+    });
+  });
+});