gridpilot.gg/tests/contracts/media/MediaRepository.contract.ts

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();
    });
  });
}