harden media

adapters/racing/persistence/inmemory/InMemoryDriverRepository.test.ts

@@ -2,6 +2,7 @@ import { vi, describe, it, expect, beforeEach } from 'vitest';
 import { InMemoryDriverRepository } from './InMemoryDriverRepository';
 import { Driver } from '@core/racing/domain/entities/Driver';
 import type { Logger } from '@core/shared/application';
+import { MediaReference } from '@core/domain/media/MediaReference';
 
 describe('InMemoryDriverRepository', () => {
   let repository: InMemoryDriverRepository;
@@ -17,13 +18,23 @@ describe('InMemoryDriverRepository', () => {
     repository = new InMemoryDriverRepository(mockLogger);
   });
 
-  const createTestDriver = (id: string, iracingId: string, name: string, country: string) => {
-    return Driver.create({
+  const createTestDriver = (id: string, iracingId: string, name: string, country: string, avatarRef?: MediaReference) => {
+    const props: {
+      id: string;
+      iracingId: string;
+      name: string;
+      country: string;
+      avatarRef?: MediaReference;
+    } = {
       id,
       iracingId,
       name,
       country,
-    });
+    };
+    if (avatarRef !== undefined) {
+      props.avatarRef = avatarRef;
+    }
+    return Driver.create(props);
   };
 
   describe('constructor', () => {
@@ -188,4 +199,115 @@ describe('InMemoryDriverRepository', () => {
       expect(result).toBe(false);
     });
   });
+
+  describe('serialization with MediaReference', () => {
+    it('should serialize driver with uploaded avatarRef', async () => {
+      const driver = createTestDriver('1', '12345', 'Test Driver', 'US', MediaReference.createUploaded('media-123'));
+      await repository.create(driver);
+
+      const serialized = repository.serialize(driver);
+      expect(serialized.avatarRef).toEqual({ type: 'uploaded', mediaId: 'media-123' });
+    });
+
+    it('should serialize driver with system-default avatarRef', async () => {
+      const driver = createTestDriver('1', '12345', 'Test Driver', 'US', MediaReference.createSystemDefault('avatar'));
+      await repository.create(driver);
+
+      const serialized = repository.serialize(driver);
+      expect(serialized.avatarRef).toEqual({ type: 'system-default', variant: 'avatar' });
+    });
+
+    it('should serialize driver with generated avatarRef', async () => {
+      const driver = createTestDriver('1', '12345', 'Test Driver', 'US', MediaReference.createGenerated('gen-123'));
+      await repository.create(driver);
+
+      const serialized = repository.serialize(driver);
+      expect(serialized.avatarRef).toEqual({ type: 'generated', generationRequestId: 'gen-123' });
+    });
+
+    it('should deserialize driver with uploaded avatarRef', () => {
+      const data = {
+        id: '1',
+        iracingId: '12345',
+        name: 'Test Driver',
+        country: 'US',
+        bio: null,
+        joinedAt: new Date().toISOString(),
+        category: null,
+        avatarRef: { type: 'uploaded', mediaId: 'media-123' },
+      };
+
+      const driver = repository.deserialize(data);
+      expect(driver.id).toBe('1');
+      expect(driver.avatarRef.type).toBe('uploaded');
+      expect(driver.avatarRef.mediaId).toBe('media-123');
+    });
+
+    it('should deserialize driver with system-default avatarRef', () => {
+      const data = {
+        id: '1',
+        iracingId: '12345',
+        name: 'Test Driver',
+        country: 'US',
+        bio: null,
+        joinedAt: new Date().toISOString(),
+        category: null,
+        avatarRef: { type: 'system-default', variant: 'avatar' },
+      };
+
+      const driver = repository.deserialize(data);
+      expect(driver.id).toBe('1');
+      expect(driver.avatarRef.type).toBe('system-default');
+      expect(driver.avatarRef.variant).toBe('avatar');
+    });
+
+    it('should deserialize driver with generated avatarRef', () => {
+      const data = {
+        id: '1',
+        iracingId: '12345',
+        name: 'Test Driver',
+        country: 'US',
+        bio: null,
+        joinedAt: new Date().toISOString(),
+        category: null,
+        avatarRef: { type: 'generated', generationRequestId: 'gen-123' },
+      };
+
+      const driver = repository.deserialize(data);
+      expect(driver.id).toBe('1');
+      expect(driver.avatarRef.type).toBe('generated');
+      expect(driver.avatarRef.generationRequestId).toBe('gen-123');
+    });
+
+    it('should deserialize driver without avatarRef (backward compatibility)', () => {
+      const data = {
+        id: '1',
+        iracingId: '12345',
+        name: 'Test Driver',
+        country: 'US',
+        bio: null,
+        joinedAt: new Date().toISOString(),
+        category: null,
+      };
+
+      const driver = repository.deserialize(data);
+      expect(driver.id).toBe('1');
+      expect(driver.avatarRef.type).toBe('system-default');
+      expect(driver.avatarRef.variant).toBe('avatar');
+    });
+
+    it('should roundtrip serialize and deserialize with avatarRef', async () => {
+      const originalDriver = createTestDriver('1', '12345', 'Test Driver', 'US', MediaReference.createUploaded('media-456'));
+      await repository.create(originalDriver);
+
+      const serialized = repository.serialize(originalDriver);
+      const deserialized = repository.deserialize(serialized);
+
+      expect(deserialized.id).toBe(originalDriver.id);
+      expect(deserialized.iracingId.toString()).toBe(originalDriver.iracingId.toString());
+      expect(deserialized.name.toString()).toBe(originalDriver.name.toString());
+      expect(deserialized.country.toString()).toBe(originalDriver.country.toString());
+      expect(deserialized.avatarRef.equals(originalDriver.avatarRef)).toBe(true);
+    });
+  });
 });