adapter tests

tests/contracts/media/MediaRepository.contract.ts

@@ -0,0 +1,118 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { Media } from '../../../core/media/domain/entities/Media';
+import { MediaRepository } from '../../../core/media/domain/repositories/MediaRepository';
+
+export function runMediaRepositoryContract(
+  factory: () => Promise<{
+    repository: MediaRepository;
+    cleanup?: () => Promise<void>;
+  }>
+) {
+  describe('MediaRepository Contract', () => {
+    let repository: MediaRepository;
+    let cleanup: (() => Promise<void>) | undefined;
+
+    beforeEach(async () => {
+      const result = await factory();
+      repository = result.repository;
+      cleanup = result.cleanup;
+    });
+
+    afterEach(async () => {
+      if (cleanup) {
+        await cleanup();
+      }
+    });
+
+    it('should save and find a media entity by ID', async () => {
+      const media = Media.create({
+        id: 'media-1',
+        filename: 'test.jpg',
+        originalName: 'test.jpg',
+        mimeType: 'image/jpeg',
+        size: 1024,
+        url: 'https://example.com/test.jpg',
+        type: 'image',
+        uploadedBy: 'user-1',
+      });
+
+      await repository.save(media);
+      const found = await repository.findById('media-1');
+
+      expect(found).toBeDefined();
+      expect(found?.id).toBe(media.id);
+      expect(found?.filename).toBe(media.filename);
+    });
+
+    it('should return null when finding a non-existent media entity', async () => {
+      const found = await repository.findById('non-existent');
+      expect(found).toBeNull();
+    });
+
+    it('should find all media entities uploaded by a specific user', async () => {
+      const user1 = 'user-1';
+      const user2 = 'user-2';
+
+      const media1 = Media.create({
+        id: 'm1',
+        filename: 'f1.jpg',
+        originalName: 'f1.jpg',
+        mimeType: 'image/jpeg',
+        size: 100,
+        url: 'https://example.com/url1',
+        type: 'image',
+        uploadedBy: user1,
+      });
+
+      const media2 = Media.create({
+        id: 'm2',
+        filename: 'f2.jpg',
+        originalName: 'f2.jpg',
+        mimeType: 'image/jpeg',
+        size: 200,
+        url: 'https://example.com/url2',
+        type: 'image',
+        uploadedBy: user1,
+      });
+
+      const media3 = Media.create({
+        id: 'm3',
+        filename: 'f3.jpg',
+        originalName: 'f3.jpg',
+        mimeType: 'image/jpeg',
+        size: 300,
+        url: 'https://example.com/url3',
+        type: 'image',
+        uploadedBy: user2,
+      });
+
+      await repository.save(media1);
+      await repository.save(media2);
+      await repository.save(media3);
+
+      const user1Media = await repository.findByUploadedBy(user1);
+      expect(user1Media).toHaveLength(2);
+      expect(user1Media.map(m => m.id)).toContain('m1');
+      expect(user1Media.map(m => m.id)).toContain('m2');
+    });
+
+    it('should delete a media entity', async () => {
+      const media = Media.create({
+        id: 'to-delete',
+        filename: 'del.jpg',
+        originalName: 'del.jpg',
+        mimeType: 'image/jpeg',
+        size: 100,
+        url: 'https://example.com/url',
+        type: 'image',
+        uploadedBy: 'user',
+      });
+
+      await repository.save(media);
+      await repository.delete('to-delete');
+
+      const found = await repository.findById('to-delete');
+      expect(found).toBeNull();
+    });
+  });
+}