view data tests

core/admin/infrastructure/typeorm/mappers/AdminUserOrmMapper.test.ts

@@ -0,0 +1,408 @@
+import { describe, expect, it } from 'vitest';
+import { AdminUser } from '@core/admin/domain/entities/AdminUser';
+import { AdminUserOrmEntity } from '../entities/AdminUserOrmEntity';
+import { AdminUserOrmMapper } from './AdminUserOrmMapper';
+import { TypeOrmAdminSchemaError } from '../errors/TypeOrmAdminSchemaError';
+
+describe('AdminUserOrmMapper', () => {
+  describe('TDD - Test First', () => {
+    describe('toDomain', () => {
+      it('should map valid ORM entity to domain entity', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = 'user-123';
+        entity.email = 'test@example.com';
+        entity.displayName = 'Test User';
+        entity.roles = ['owner'];
+        entity.status = 'active';
+        entity.createdAt = new Date('2024-01-01');
+        entity.updatedAt = new Date('2024-01-02');
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act
+        const domain = mapper.toDomain(entity);
+
+        // Assert
+        expect(domain.id.value).toBe('user-123');
+        expect(domain.email.value).toBe('test@example.com');
+        expect(domain.displayName).toBe('Test User');
+        expect(domain.roles).toHaveLength(1);
+        expect(domain.roles[0]!.value).toBe('owner');
+        expect(domain.status.value).toBe('active');
+        expect(domain.createdAt).toEqual(new Date('2024-01-01'));
+        expect(domain.updatedAt).toEqual(new Date('2024-01-02'));
+      });
+
+      it('should map entity with optional fields', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = 'user-123';
+        entity.email = 'test@example.com';
+        entity.displayName = 'Test User';
+        entity.roles = ['user'];
+        entity.status = 'active';
+        entity.createdAt = new Date('2024-01-01');
+        entity.updatedAt = new Date('2024-01-02');
+        entity.primaryDriverId = 'driver-456';
+        entity.lastLoginAt = new Date('2024-01-03');
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act
+        const domain = mapper.toDomain(entity);
+
+        // Assert
+        expect(domain.primaryDriverId).toBe('driver-456');
+        expect(domain.lastLoginAt).toEqual(new Date('2024-01-03'));
+      });
+
+      it('should handle null optional fields', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = 'user-123';
+        entity.email = 'test@example.com';
+        entity.displayName = 'Test User';
+        entity.roles = ['user'];
+        entity.status = 'active';
+        entity.createdAt = new Date('2024-01-01');
+        entity.updatedAt = new Date('2024-01-02');
+        entity.primaryDriverId = null;
+        entity.lastLoginAt = null;
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act
+        const domain = mapper.toDomain(entity);
+
+        // Assert
+        expect(domain.primaryDriverId).toBeUndefined();
+        expect(domain.lastLoginAt).toBeUndefined();
+      });
+
+      it('should throw error for missing id', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = '';
+        entity.email = 'test@example.com';
+        entity.displayName = 'Test User';
+        entity.roles = ['user'];
+        entity.status = 'active';
+        entity.createdAt = new Date('2024-01-01');
+        entity.updatedAt = new Date('2024-01-02');
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act & Assert
+        expect(() => mapper.toDomain(entity)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => mapper.toDomain(entity)).toThrow('Field id must be a non-empty string');
+      });
+
+      it('should throw error for missing email', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = 'user-123';
+        entity.email = '';
+        entity.displayName = 'Test User';
+        entity.roles = ['user'];
+        entity.status = 'active';
+        entity.createdAt = new Date('2024-01-01');
+        entity.updatedAt = new Date('2024-01-02');
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act & Assert
+        expect(() => mapper.toDomain(entity)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => mapper.toDomain(entity)).toThrow('Field email must be a non-empty string');
+      });
+
+      it('should throw error for missing displayName', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = 'user-123';
+        entity.email = 'test@example.com';
+        entity.displayName = '';
+        entity.roles = ['user'];
+        entity.status = 'active';
+        entity.createdAt = new Date('2024-01-01');
+        entity.updatedAt = new Date('2024-01-02');
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act & Assert
+        expect(() => mapper.toDomain(entity)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => mapper.toDomain(entity)).toThrow('Field displayName must be a non-empty string');
+      });
+
+      it('should throw error for invalid roles array', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = 'user-123';
+        entity.email = 'test@example.com';
+        entity.displayName = 'Test User';
+        entity.roles = null as unknown as string[];
+        entity.status = 'active';
+        entity.createdAt = new Date('2024-01-01');
+        entity.updatedAt = new Date('2024-01-02');
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act & Assert
+        expect(() => mapper.toDomain(entity)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => mapper.toDomain(entity)).toThrow('Field roles must be an array of strings');
+      });
+
+      it('should throw error for invalid roles array items', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = 'user-123';
+        entity.email = 'test@example.com';
+        entity.displayName = 'Test User';
+        entity.roles = ['user', 123 as unknown as string];
+        entity.status = 'active';
+        entity.createdAt = new Date('2024-01-01');
+        entity.updatedAt = new Date('2024-01-02');
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act & Assert
+        expect(() => mapper.toDomain(entity)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => mapper.toDomain(entity)).toThrow('Field roles must be an array of strings');
+      });
+
+      it('should throw error for missing status', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = 'user-123';
+        entity.email = 'test@example.com';
+        entity.displayName = 'Test User';
+        entity.roles = ['user'];
+        entity.status = '';
+        entity.createdAt = new Date('2024-01-01');
+        entity.updatedAt = new Date('2024-01-02');
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act & Assert
+        expect(() => mapper.toDomain(entity)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => mapper.toDomain(entity)).toThrow('Field status must be a non-empty string');
+      });
+
+      it('should throw error for invalid createdAt', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = 'user-123';
+        entity.email = 'test@example.com';
+        entity.displayName = 'Test User';
+        entity.roles = ['user'];
+        entity.status = 'active';
+        entity.createdAt = new Date('invalid') as unknown as Date;
+        entity.updatedAt = new Date('2024-01-02');
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act & Assert
+        expect(() => mapper.toDomain(entity)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => mapper.toDomain(entity)).toThrow('Field createdAt must be a valid Date');
+      });
+
+      it('should throw error for invalid updatedAt', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = 'user-123';
+        entity.email = 'test@example.com';
+        entity.displayName = 'Test User';
+        entity.roles = ['user'];
+        entity.status = 'active';
+        entity.createdAt = new Date('2024-01-01');
+        entity.updatedAt = new Date('invalid') as unknown as Date;
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act & Assert
+        expect(() => mapper.toDomain(entity)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => mapper.toDomain(entity)).toThrow('Field updatedAt must be a valid Date');
+      });
+
+      it('should throw error for invalid primaryDriverId type', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = 'user-123';
+        entity.email = 'test@example.com';
+        entity.displayName = 'Test User';
+        entity.roles = ['user'];
+        entity.status = 'active';
+        entity.createdAt = new Date('2024-01-01');
+        entity.updatedAt = new Date('2024-01-02');
+        entity.primaryDriverId = 123 as unknown as string;
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act & Assert
+        expect(() => mapper.toDomain(entity)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => mapper.toDomain(entity)).toThrow('Field primaryDriverId must be a string or undefined');
+      });
+
+      it('should throw error for invalid lastLoginAt type', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = 'user-123';
+        entity.email = 'test@example.com';
+        entity.displayName = 'Test User';
+        entity.roles = ['user'];
+        entity.status = 'active';
+        entity.createdAt = new Date('2024-01-01');
+        entity.updatedAt = new Date('2024-01-02');
+        entity.lastLoginAt = 'invalid' as unknown as Date;
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act & Assert
+        expect(() => mapper.toDomain(entity)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => mapper.toDomain(entity)).toThrow('Field lastLoginAt must be a valid Date');
+      });
+
+      it('should handle multiple roles', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = 'user-123';
+        entity.email = 'test@example.com';
+        entity.displayName = 'Test User';
+        entity.roles = ['owner', 'admin'];
+        entity.status = 'active';
+        entity.createdAt = new Date('2024-01-01');
+        entity.updatedAt = new Date('2024-01-02');
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act
+        const domain = mapper.toDomain(entity);
+
+        // Assert
+        expect(domain.roles).toHaveLength(2);
+        expect(domain.roles.map(r => r.value)).toContain('owner');
+        expect(domain.roles.map(r => r.value)).toContain('admin');
+      });
+    });
+
+    describe('toOrmEntity', () => {
+      it('should map domain entity to ORM entity', () => {
+        // Arrange
+        const domain = AdminUser.create({
+          id: 'user-123',
+          email: 'test@example.com',
+          displayName: 'Test User',
+          roles: ['owner'],
+          status: 'active',
+          createdAt: new Date('2024-01-01'),
+          updatedAt: new Date('2024-01-02'),
+        });
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act
+        const entity = mapper.toOrmEntity(domain);
+
+        // Assert
+        expect(entity.id).toBe('user-123');
+        expect(entity.email).toBe('test@example.com');
+        expect(entity.displayName).toBe('Test User');
+        expect(entity.roles).toEqual(['owner']);
+        expect(entity.status).toBe('active');
+        expect(entity.createdAt).toEqual(new Date('2024-01-01'));
+        expect(entity.updatedAt).toEqual(new Date('2024-01-02'));
+      });
+
+      it('should map domain entity with optional fields', () => {
+        // Arrange
+        const domain = AdminUser.create({
+          id: 'user-123',
+          email: 'test@example.com',
+          displayName: 'Test User',
+          roles: ['user'],
+          status: 'active',
+          createdAt: new Date('2024-01-01'),
+          updatedAt: new Date('2024-01-02'),
+          primaryDriverId: 'driver-456',
+          lastLoginAt: new Date('2024-01-03'),
+        });
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act
+        const entity = mapper.toOrmEntity(domain);
+
+        // Assert
+        expect(entity.primaryDriverId).toBe('driver-456');
+        expect(entity.lastLoginAt).toEqual(new Date('2024-01-03'));
+      });
+
+      it('should handle domain entity without optional fields', () => {
+        // Arrange
+        const domain = AdminUser.create({
+          id: 'user-123',
+          email: 'test@example.com',
+          displayName: 'Test User',
+          roles: ['user'],
+          status: 'active',
+          createdAt: new Date('2024-01-01'),
+          updatedAt: new Date('2024-01-02'),
+        });
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act
+        const entity = mapper.toOrmEntity(domain);
+
+        // Assert
+        expect(entity.primaryDriverId).toBeUndefined();
+        expect(entity.lastLoginAt).toBeUndefined();
+      });
+
+      it('should map domain entity with multiple roles', () => {
+        // Arrange
+        const domain = AdminUser.create({
+          id: 'user-123',
+          email: 'test@example.com',
+          displayName: 'Test User',
+          roles: ['owner', 'admin'],
+          status: 'active',
+          createdAt: new Date('2024-01-01'),
+          updatedAt: new Date('2024-01-02'),
+        });
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act
+        const entity = mapper.toOrmEntity(domain);
+
+        // Assert
+        expect(entity.roles).toEqual(['owner', 'admin']);
+      });
+    });
+
+    describe('toStored', () => {
+      it('should call toDomain for stored entity', () => {
+        // Arrange
+        const entity = new AdminUserOrmEntity();
+        entity.id = 'user-123';
+        entity.email = 'test@example.com';
+        entity.displayName = 'Test User';
+        entity.roles = ['owner'];
+        entity.status = 'active';
+        entity.createdAt = new Date('2024-01-01');
+        entity.updatedAt = new Date('2024-01-02');
+
+        const mapper = new AdminUserOrmMapper();
+
+        // Act
+        const domain = mapper.toStored(entity);
+
+        // Assert
+        expect(domain.id.value).toBe('user-123');
+        expect(domain.email.value).toBe('test@example.com');
+        expect(domain.displayName).toBe('Test User');
+      });
+    });
+  });
+});

core/admin/infrastructure/typeorm/schema/TypeOrmAdminSchemaGuards.test.ts

@@ -0,0 +1,253 @@
+import { describe, expect, it } from 'vitest';
+import {
+  assertNonEmptyString,
+  assertStringArray,
+  assertDate,
+  assertOptionalDate,
+  assertOptionalString,
+} from './TypeOrmAdminSchemaGuards';
+import { TypeOrmAdminSchemaError } from '../errors/TypeOrmAdminSchemaError';
+
+describe('TypeOrmAdminSchemaGuards', () => {
+  describe('TDD - Test First', () => {
+    describe('assertNonEmptyString', () => {
+      it('should not throw for valid non-empty string', () => {
+        // Arrange & Act & Assert
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', 'valid string')).not.toThrow();
+      });
+
+      it('should throw for empty string', () => {
+        // Arrange & Act & Assert
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', '')).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', '')).toThrow('Field fieldName must be a non-empty string');
+      });
+
+      it('should throw for string with only whitespace', () => {
+        // Arrange & Act & Assert
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', '   ')).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', '   ')).toThrow('Field fieldName must be a non-empty string');
+      });
+
+      it('should throw for null', () => {
+        // Arrange & Act & Assert
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', null)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', null)).toThrow('Field fieldName must be a non-empty string');
+      });
+
+      it('should throw for undefined', () => {
+        // Arrange & Act & Assert
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', undefined)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', undefined)).toThrow('Field fieldName must be a non-empty string');
+      });
+
+      it('should throw for number', () => {
+        // Arrange & Act & Assert
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', 123)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', 123)).toThrow('Field fieldName must be a non-empty string');
+      });
+
+      it('should throw for object', () => {
+        // Arrange & Act & Assert
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', {})).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', {})).toThrow('Field fieldName must be a non-empty string');
+      });
+
+      it('should throw for array', () => {
+        // Arrange & Act & Assert
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', [])).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertNonEmptyString('TestEntity', 'fieldName', [])).toThrow('Field fieldName must be a non-empty string');
+      });
+
+      it('should include entity name in error message', () => {
+        // Arrange & Act & Assert
+        expect(() => assertNonEmptyString('AdminUser', 'email', '')).toThrow('[TypeOrmAdminSchemaError] AdminUser.email: INVALID_STRING - Field email must be a non-empty string');
+      });
+    });
+
+    describe('assertStringArray', () => {
+      it('should not throw for valid string array', () => {
+        // Arrange & Act & Assert
+        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', 'b', 'c'])).not.toThrow();
+      });
+
+      it('should not throw for empty array', () => {
+        // Arrange & Act & Assert
+        expect(() => assertStringArray('TestEntity', 'fieldName', [])).not.toThrow();
+      });
+
+      it('should throw for non-array', () => {
+        // Arrange & Act & Assert
+        expect(() => assertStringArray('TestEntity', 'fieldName', 'not an array')).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertStringArray('TestEntity', 'fieldName', 'not an array')).toThrow('Field fieldName must be an array of strings');
+      });
+
+      it('should throw for null', () => {
+        // Arrange & Act & Assert
+        expect(() => assertStringArray('TestEntity', 'fieldName', null)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertStringArray('TestEntity', 'fieldName', null)).toThrow('Field fieldName must be an array of strings');
+      });
+
+      it('should throw for undefined', () => {
+        // Arrange & Act & Assert
+        expect(() => assertStringArray('TestEntity', 'fieldName', undefined)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertStringArray('TestEntity', 'fieldName', undefined)).toThrow('Field fieldName must be an array of strings');
+      });
+
+      it('should throw for array with non-string items', () => {
+        // Arrange & Act & Assert
+        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', 123, 'c'])).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', 123, 'c'])).toThrow('Field fieldName must be an array of strings');
+      });
+
+      it('should throw for array with null items', () => {
+        // Arrange & Act & Assert
+        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', null, 'c'])).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', null, 'c'])).toThrow('Field fieldName must be an array of strings');
+      });
+
+      it('should throw for array with undefined items', () => {
+        // Arrange & Act & Assert
+        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', undefined, 'c'])).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', undefined, 'c'])).toThrow('Field fieldName must be an array of strings');
+      });
+
+      it('should throw for array with object items', () => {
+        // Arrange & Act & Assert
+        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', {}, 'c'])).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertStringArray('TestEntity', 'fieldName', ['a', {}, 'c'])).toThrow('Field fieldName must be an array of strings');
+      });
+
+      it('should include entity name in error message', () => {
+        // Arrange & Act & Assert
+        expect(() => assertStringArray('AdminUser', 'roles', null)).toThrow('[TypeOrmAdminSchemaError] AdminUser.roles: INVALID_STRING_ARRAY - Field roles must be an array of strings');
+      });
+    });
+
+    describe('assertDate', () => {
+      it('should not throw for valid Date', () => {
+        // Arrange & Act & Assert
+        expect(() => assertDate('TestEntity', 'fieldName', new Date())).not.toThrow();
+      });
+
+      it('should not throw for Date with valid timestamp', () => {
+        // Arrange & Act & Assert
+        expect(() => assertDate('TestEntity', 'fieldName', new Date('2024-01-01'))).not.toThrow();
+      });
+
+      it('should throw for null', () => {
+        // Arrange & Act & Assert
+        expect(() => assertDate('TestEntity', 'fieldName', null)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertDate('TestEntity', 'fieldName', null)).toThrow('Field fieldName must be a valid Date');
+      });
+
+      it('should throw for undefined', () => {
+        // Arrange & Act & Assert
+        expect(() => assertDate('TestEntity', 'fieldName', undefined)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertDate('TestEntity', 'fieldName', undefined)).toThrow('Field fieldName must be a valid Date');
+      });
+
+      it('should throw for string', () => {
+        // Arrange & Act & Assert
+        expect(() => assertDate('TestEntity', 'fieldName', '2024-01-01')).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertDate('TestEntity', 'fieldName', '2024-01-01')).toThrow('Field fieldName must be a valid Date');
+      });
+
+      it('should throw for number', () => {
+        // Arrange & Act & Assert
+        expect(() => assertDate('TestEntity', 'fieldName', 1234567890)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertDate('TestEntity', 'fieldName', 1234567890)).toThrow('Field fieldName must be a valid Date');
+      });
+
+      it('should throw for object', () => {
+        // Arrange & Act & Assert
+        expect(() => assertDate('TestEntity', 'fieldName', {})).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertDate('TestEntity', 'fieldName', {})).toThrow('Field fieldName must be a valid Date');
+      });
+
+      it('should throw for invalid Date (NaN)', () => {
+        // Arrange & Act & Assert
+        expect(() => assertDate('TestEntity', 'fieldName', new Date('invalid'))).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertDate('TestEntity', 'fieldName', new Date('invalid'))).toThrow('Field fieldName must be a valid Date');
+      });
+
+      it('should include entity name in error message', () => {
+        // Arrange & Act & Assert
+        expect(() => assertDate('AdminUser', 'createdAt', null)).toThrow('[TypeOrmAdminSchemaError] AdminUser.createdAt: INVALID_DATE - Field createdAt must be a valid Date');
+      });
+    });
+
+    describe('assertOptionalDate', () => {
+      it('should not throw for valid Date', () => {
+        // Arrange & Act & Assert
+        expect(() => assertOptionalDate('TestEntity', 'fieldName', new Date())).not.toThrow();
+      });
+
+      it('should not throw for null', () => {
+        // Arrange & Act & Assert
+        expect(() => assertOptionalDate('TestEntity', 'fieldName', null)).not.toThrow();
+      });
+
+      it('should not throw for undefined', () => {
+        // Arrange & Act & Assert
+        expect(() => assertOptionalDate('TestEntity', 'fieldName', undefined)).not.toThrow();
+      });
+
+      it('should throw for invalid Date', () => {
+        // Arrange & Act & Assert
+        expect(() => assertOptionalDate('TestEntity', 'fieldName', new Date('invalid'))).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertOptionalDate('TestEntity', 'fieldName', new Date('invalid'))).toThrow('Field fieldName must be a valid Date');
+      });
+
+      it('should throw for string', () => {
+        // Arrange & Act & Assert
+        expect(() => assertOptionalDate('TestEntity', 'fieldName', '2024-01-01')).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertOptionalDate('TestEntity', 'fieldName', '2024-01-01')).toThrow('Field fieldName must be a valid Date');
+      });
+
+      it('should include entity name in error message', () => {
+        // Arrange & Act & Assert
+        expect(() => assertOptionalDate('AdminUser', 'lastLoginAt', new Date('invalid'))).toThrow('[TypeOrmAdminSchemaError] AdminUser.lastLoginAt: INVALID_DATE - Field lastLoginAt must be a valid Date');
+      });
+    });
+
+    describe('assertOptionalString', () => {
+      it('should not throw for valid string', () => {
+        // Arrange & Act & Assert
+        expect(() => assertOptionalString('TestEntity', 'fieldName', 'valid string')).not.toThrow();
+      });
+
+      it('should not throw for null', () => {
+        // Arrange & Act & Assert
+        expect(() => assertOptionalString('TestEntity', 'fieldName', null)).not.toThrow();
+      });
+
+      it('should not throw for undefined', () => {
+        // Arrange & Act & Assert
+        expect(() => assertOptionalString('TestEntity', 'fieldName', undefined)).not.toThrow();
+      });
+
+      it('should throw for number', () => {
+        // Arrange & Act & Assert
+        expect(() => assertOptionalString('TestEntity', 'fieldName', 123)).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertOptionalString('TestEntity', 'fieldName', 123)).toThrow('Field fieldName must be a string or undefined');
+      });
+
+      it('should throw for object', () => {
+        // Arrange & Act & Assert
+        expect(() => assertOptionalString('TestEntity', 'fieldName', {})).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertOptionalString('TestEntity', 'fieldName', {})).toThrow('Field fieldName must be a string or undefined');
+      });
+
+      it('should throw for array', () => {
+        // Arrange & Act & Assert
+        expect(() => assertOptionalString('TestEntity', 'fieldName', [])).toThrow(TypeOrmAdminSchemaError);
+        expect(() => assertOptionalString('TestEntity', 'fieldName', [])).toThrow('Field fieldName must be a string or undefined');
+      });
+
+      it('should include entity name in error message', () => {
+        // Arrange & Act & Assert
+        expect(() => assertOptionalString('AdminUser', 'primaryDriverId', 123)).toThrow('[TypeOrmAdminSchemaError] AdminUser.primaryDriverId: INVALID_OPTIONAL_STRING - Field primaryDriverId must be a string or undefined');
+      });
+    });
+  });
+});

core/eslint-rules/domain-no-application.test.js

@@ -0,0 +1,116 @@
+const { RuleTester } = require('eslint');
+const rule = require('./domain-no-application');
+
+const ruleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser'),
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: 'module',
+    ecmaFeatures: {
+      jsx: false,
+    },
+  },
+});
+
+ruleTester.run('domain-no-application', rule, {
+  valid: [
+    // Domain file importing from domain
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import { UserId } from './UserId';",
+    },
+    // Domain file importing from shared
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import { ValueObject } from '../shared/ValueObject';",
+    },
+    // Domain file importing from ports
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import { UserRepository } from '../ports/UserRepository';",
+    },
+    // Non-domain file importing from application
+    {
+      filename: '/path/to/core/application/user/CreateUser.ts',
+      code: "import { CreateUserCommand } from './CreateUserCommand';",
+    },
+    // Non-domain file importing from application
+    {
+      filename: '/path/to/core/application/user/CreateUser.ts',
+      code: "import { UserService } from '../services/UserService';",
+    },
+    // Domain file with no imports
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "export class User {}",
+    },
+    // Domain file with multiple imports, none from application
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: `
+        import { UserId } from './UserId';
+        import { UserName } from './UserName';
+        import { ValueObject } from '../shared/ValueObject';
+      `,
+    },
+  ],
+
+  invalid: [
+    // Domain file importing from application
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import { CreateUserCommand } from '../application/user/CreateUserCommand';",
+      errors: [
+        {
+          messageId: 'forbiddenImport',
+          data: {
+            source: '../application/user/CreateUserCommand',
+          },
+        },
+      ],
+    },
+    // Domain file importing from application with different path
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import { UserService } from '../../application/services/UserService';",
+      errors: [
+        {
+          messageId: 'forbiddenImport',
+          data: {
+            source: '../../application/services/UserService',
+          },
+        },
+      ],
+    },
+    // Domain file importing from application with absolute path
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import { CreateUserCommand } from 'core/application/user/CreateUserCommand';",
+      errors: [
+        {
+          messageId: 'forbiddenImport',
+          data: {
+            source: 'core/application/user/CreateUserCommand',
+          },
+        },
+      ],
+    },
+    // Domain file with multiple imports, one from application
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: `
+        import { UserId } from './UserId';
+        import { CreateUserCommand } from '../application/user/CreateUserCommand';
+        import { UserName } from './UserName';
+      `,
+      errors: [
+        {
+          messageId: 'forbiddenImport',
+          data: {
+            source: '../application/user/CreateUserCommand',
+          },
+        },
+      ],
+    },
+  ],
+});

core/eslint-rules/index.test.js

@@ -0,0 +1,79 @@
+const index = require('./index');
+
+describe('eslint-rules index', () => {
+  describe('rules', () => {
+    it('should export no-index-files rule', () => {
+      expect(index.rules['no-index-files']).toBeDefined();
+      expect(index.rules['no-index-files'].meta).toBeDefined();
+      expect(index.rules['no-index-files'].create).toBeDefined();
+    });
+
+    it('should export no-framework-imports rule', () => {
+      expect(index.rules['no-framework-imports']).toBeDefined();
+      expect(index.rules['no-framework-imports'].meta).toBeDefined();
+      expect(index.rules['no-framework-imports'].create).toBeDefined();
+    });
+
+    it('should export domain-no-application rule', () => {
+      expect(index.rules['domain-no-application']).toBeDefined();
+      expect(index.rules['domain-no-application'].meta).toBeDefined();
+      expect(index.rules['domain-no-application'].create).toBeDefined();
+    });
+
+    it('should have exactly 3 rules', () => {
+      expect(Object.keys(index.rules)).toHaveLength(3);
+    });
+  });
+
+  describe('configs', () => {
+    it('should export recommended config', () => {
+      expect(index.configs.recommended).toBeDefined();
+    });
+
+    it('recommended config should have gridpilot-core-rules plugin', () => {
+      expect(index.configs.recommended.plugins).toContain('gridpilot-core-rules');
+    });
+
+    it('recommended config should enable all rules', () => {
+      expect(index.configs.recommended.rules['gridpilot-core-rules/no-index-files']).toBe('error');
+      expect(index.configs.recommended.rules['gridpilot-core-rules/no-framework-imports']).toBe('error');
+      expect(index.configs.recommended.rules['gridpilot-core-rules/domain-no-application']).toBe('error');
+    });
+
+    it('recommended config should have exactly 3 rules', () => {
+      expect(Object.keys(index.configs.recommended.rules)).toHaveLength(3);
+    });
+  });
+
+  describe('rule metadata', () => {
+    it('no-index-files should have correct metadata', () => {
+      const rule = index.rules['no-index-files'];
+      expect(rule.meta.type).toBe('problem');
+      expect(rule.meta.docs.category).toBe('Best Practices');
+      expect(rule.meta.docs.recommended).toBe(true);
+      expect(rule.meta.fixable).toBe(null);
+      expect(rule.meta.schema).toEqual([]);
+      expect(rule.meta.messages.indexFile).toBeDefined();
+    });
+
+    it('no-framework-imports should have correct metadata', () => {
+      const rule = index.rules['no-framework-imports'];
+      expect(rule.meta.type).toBe('problem');
+      expect(rule.meta.docs.category).toBe('Architecture');
+      expect(rule.meta.docs.recommended).toBe(true);
+      expect(rule.meta.fixable).toBe(null);
+      expect(rule.meta.schema).toEqual([]);
+      expect(rule.meta.messages.frameworkImport).toBeDefined();
+    });
+
+    it('domain-no-application should have correct metadata', () => {
+      const rule = index.rules['domain-no-application'];
+      expect(rule.meta.type).toBe('problem');
+      expect(rule.meta.docs.category).toBe('Architecture');
+      expect(rule.meta.docs.recommended).toBe(true);
+      expect(rule.meta.fixable).toBe(null);
+      expect(rule.meta.schema).toEqual([]);
+      expect(rule.meta.messages.forbiddenImport).toBeDefined();
+    });
+  });
+});

core/eslint-rules/no-framework-imports.test.js

@@ -0,0 +1,166 @@
+const { RuleTester } = require('eslint');
+const rule = require('./no-framework-imports');
+
+const ruleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser'),
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: 'module',
+    ecmaFeatures: {
+      jsx: false,
+    },
+  },
+});
+
+ruleTester.run('no-framework-imports', rule, {
+  valid: [
+    // Import from domain
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import { UserId } from './UserId';",
+    },
+    // Import from application
+    {
+      filename: '/path/to/core/application/user/CreateUser.ts',
+      code: "import { CreateUserCommand } from './CreateUserCommand';",
+    },
+    // Import from shared
+    {
+      filename: '/path/to/core/shared/ValueObject.ts',
+      code: "import { ValueObject } from './ValueObject';",
+    },
+    // Import from ports
+    {
+      filename: '/path/to/core/ports/UserRepository.ts',
+      code: "import { User } from '../domain/user/User';",
+    },
+    // Import from external packages (not frameworks)
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import { v4 as uuidv4 } from 'uuid';",
+    },
+    // Import from internal packages
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import { SomeUtil } from '@core/shared/SomeUtil';",
+    },
+    // No imports
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "export class User {}",
+    },
+    // Multiple valid imports
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: `
+        import { UserId } from './UserId';
+        import { UserName } from './UserName';
+        import { ValueObject } from '../shared/ValueObject';
+      `,
+    },
+  ],
+
+  invalid: [
+    // Import from @nestjs
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import { Injectable } from '@nestjs/common';",
+      errors: [
+        {
+          messageId: 'frameworkImport',
+          data: {
+            source: '@nestjs/common',
+          },
+        },
+      ],
+    },
+    // Import from @nestjs/core
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import { Module } from '@nestjs/core';",
+      errors: [
+        {
+          messageId: 'frameworkImport',
+          data: {
+            source: '@nestjs/core',
+          },
+        },
+      ],
+    },
+    // Import from express
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import express from 'express';",
+      errors: [
+        {
+          messageId: 'frameworkImport',
+          data: {
+            source: 'express',
+          },
+        },
+      ],
+    },
+    // Import from react
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import React from 'react';",
+      errors: [
+        {
+          messageId: 'frameworkImport',
+          data: {
+            source: 'react',
+          },
+        },
+      ],
+    },
+    // Import from next
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import { useRouter } from 'next/router';",
+      errors: [
+        {
+          messageId: 'frameworkImport',
+          data: {
+            source: 'next/router',
+          },
+        },
+      ],
+    },
+    // Import from @nestjs with subpath
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "import { Controller } from '@nestjs/common';",
+      errors: [
+        {
+          messageId: 'frameworkImport',
+          data: {
+            source: '@nestjs/common',
+          },
+        },
+      ],
+    },
+    // Multiple framework imports
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: `
+        import { Injectable } from '@nestjs/common';
+        import { UserId } from './UserId';
+        import React from 'react';
+      `,
+      errors: [
+        {
+          messageId: 'frameworkImport',
+          data: {
+            source: '@nestjs/common',
+          },
+        },
+        {
+          messageId: 'frameworkImport',
+          data: {
+            source: 'react',
+          },
+        },
+      ],
+    },
+  ],
+});

core/eslint-rules/no-index-files.test.js

@@ -0,0 +1,131 @@
+const { RuleTester } = require('eslint');
+const rule = require('./no-index-files');
+
+const ruleTester = new RuleTester({
+  parser: require.resolve('@typescript-eslint/parser'),
+  parserOptions: {
+    ecmaVersion: 2020,
+    sourceType: 'module',
+    ecmaFeatures: {
+      jsx: false,
+    },
+  },
+});
+
+ruleTester.run('no-index-files', rule, {
+  valid: [
+    // Regular file in domain
+    {
+      filename: '/path/to/core/domain/user/User.ts',
+      code: "export class User {}",
+    },
+    // Regular file in application
+    {
+      filename: '/path/to/core/application/user/CreateUser.ts',
+      code: "export class CreateUser {}",
+    },
+    // Regular file in shared
+    {
+      filename: '/path/to/core/shared/ValueObject.ts',
+      code: "export class ValueObject {}",
+    },
+    // Regular file in ports
+    {
+      filename: '/path/to/core/ports/UserRepository.ts',
+      code: "export interface UserRepository {}",
+    },
+    // File with index in the middle of the path
+    {
+      filename: '/path/to/core/domain/user/index/User.ts',
+      code: "export class User {}",
+    },
+    // File with index in the name but not at the end
+    {
+      filename: '/path/to/core/domain/user/indexHelper.ts',
+      code: "export class IndexHelper {}",
+    },
+    // Root index.ts is allowed
+    {
+      filename: '/path/to/core/index.ts',
+      code: "export * from './domain';",
+    },
+    // File with index.ts in the middle of the path
+    {
+      filename: '/path/to/core/domain/index/User.ts',
+      code: "export class User {}",
+    },
+  ],
+
+  invalid: [
+    // index.ts in domain
+    {
+      filename: '/path/to/core/domain/user/index.ts',
+      code: "export * from './User';",
+      errors: [
+        {
+          messageId: 'indexFile',
+        },
+      ],
+    },
+    // index.ts in application
+    {
+      filename: '/path/to/core/application/user/index.ts',
+      code: "export * from './CreateUser';",
+      errors: [
+        {
+          messageId: 'indexFile',
+        },
+      ],
+    },
+    // index.ts in shared
+    {
+      filename: '/path/to/core/shared/index.ts',
+      code: "export * from './ValueObject';",
+      errors: [
+        {
+          messageId: 'indexFile',
+        },
+      ],
+    },
+    // index.ts in ports
+    {
+      filename: '/path/to/core/ports/index.ts',
+      code: "export * from './UserRepository';",
+      errors: [
+        {
+          messageId: 'indexFile',
+        },
+      ],
+    },
+    // index.ts with Windows path separator
+    {
+      filename: 'C:\\path\\to\\core\\domain\\user\\index.ts',
+      code: "export * from './User';",
+      errors: [
+        {
+          messageId: 'indexFile',
+        },
+      ],
+    },
+    // index.ts at the start of path
+    {
+      filename: 'index.ts',
+      code: "export * from './domain';",
+      errors: [
+        {
+          messageId: 'indexFile',
+        },
+      ],
+    },
+    // index.ts in nested directory
+    {
+      filename: '/path/to/core/domain/user/profile/index.ts',
+      code: "export * from './Profile';",
+      errors: [
+        {
+          messageId: 'indexFile',
+        },
+      ],
+    },
+  ],
+});

core/identity/application/queries/GetUserRatingLedgerQuery.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Application Query Tests: GetUserRatingLedgerQuery
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { GetUserRatingLedgerQueryHandler } from './GetUserRatingLedgerQuery';
+import { RatingEventRepository } from '../../domain/repositories/RatingEventRepository';
+
+// Mock repository
+const createMockRepository = () => ({
+  save: vi.fn(),
+  findByUserId: vi.fn(),
+  findByIds: vi.fn(),
+  getAllByUserId: vi.fn(),
+  findEventsPaginated: vi.fn(),
+});
+
+describe('GetUserRatingLedgerQueryHandler', () => {
+  let handler: GetUserRatingLedgerQueryHandler;
+  let mockRepository: ReturnType<typeof createMockRepository>;
+
+  beforeEach(() => {
+    mockRepository = createMockRepository();
+    handler = new GetUserRatingLedgerQueryHandler(mockRepository as unknown as RatingEventRepository);
+    vi.clearAllMocks();
+  });
+
+  it('should query repository with default pagination', async () => {
+    mockRepository.findEventsPaginated.mockResolvedValue({
+      items: [],
+      total: 0,
+      limit: 20,
+      offset: 0,
+      hasMore: false,
+    });
+
+    await handler.execute({ userId: 'user-1' });
+
+    expect(mockRepository.findEventsPaginated).toHaveBeenCalledWith('user-1', {
+      limit: 20,
+      offset: 0,
+    });
+  });
+
+  it('should query repository with custom pagination', async () => {
+    mockRepository.findEventsPaginated.mockResolvedValue({
+      items: [],
+      total: 0,
+      limit: 50,
+      offset: 100,
+      hasMore: false,
+    });
+
+    await handler.execute({
+      userId: 'user-1',
+      limit: 50,
+      offset: 100,
+    });
+
+    expect(mockRepository.findEventsPaginated).toHaveBeenCalledWith('user-1', {
+      limit: 50,
+      offset: 100,
+    });
+  });
+
+  it('should query repository with filters', async () => {
+    mockRepository.findEventsPaginated.mockResolvedValue({
+      items: [],
+      total: 0,
+      limit: 20,
+      offset: 0,
+      hasMore: false,
+    });
+
+    const filter: any = {
+      dimensions: ['trust'],
+      sourceTypes: ['vote'],
+      from: '2026-01-01T00:00:00Z',
+      to: '2026-01-31T23:59:59Z',
+      reasonCodes: ['VOTE_POSITIVE'],
+    };
+
+    await handler.execute({
+      userId: 'user-1',
+      filter,
+    });
+
+    expect(mockRepository.findEventsPaginated).toHaveBeenCalledWith('user-1', {
+      limit: 20,
+      offset: 0,
+      filter: {
+        dimensions: ['trust'],
+        sourceTypes: ['vote'],
+        from: new Date('2026-01-01T00:00:00Z'),
+        to: new Date('2026-01-31T23:59:59Z'),
+        reasonCodes: ['VOTE_POSITIVE'],
+      },
+    });
+  });
+
+  it('should map domain entities to DTOs', async () => {
+    const mockEvent = {
+      id: { value: 'event-1' },
+      userId: 'user-1',
+      dimension: { value: 'trust' },
+      delta: { value: 5 },
+      occurredAt: new Date('2026-01-15T12:00:00Z'),
+      createdAt: new Date('2026-01-15T12:00:00Z'),
+      source: 'admin_vote',
+      reason: 'VOTE_POSITIVE',
+      visibility: 'public',
+      weight: 1.0,
+    };
+
+    mockRepository.findEventsPaginated.mockResolvedValue({
+      items: [mockEvent],
+      total: 1,
+      limit: 20,
+      offset: 0,
+      hasMore: false,
+    });
+
+    const result = await handler.execute({ userId: 'user-1' });
+
+    expect(result.entries).toHaveLength(1);
+    expect(result.entries[0]).toEqual({
+      id: 'event-1',
+      userId: 'user-1',
+      dimension: 'trust',
+      delta: 5,
+      occurredAt: '2026-01-15T12:00:00.000Z',
+      createdAt: '2026-01-15T12:00:00.000Z',
+      source: 'admin_vote',
+      reason: 'VOTE_POSITIVE',
+      visibility: 'public',
+      weight: 1.0,
+    });
+  });
+
+  it('should handle pagination metadata in result', async () => {
+    mockRepository.findEventsPaginated.mockResolvedValue({
+      items: [],
+      total: 100,
+      limit: 20,
+      offset: 20,
+      hasMore: true,
+      nextOffset: 40,
+    });
+
+    const result = await handler.execute({ userId: 'user-1', limit: 20, offset: 20 });
+
+    expect(result.pagination).toEqual({
+      total: 100,
+      limit: 20,
+      offset: 20,
+      hasMore: true,
+      nextOffset: 40,
+    });
+  });
+});

core/identity/application/use-cases/CastAdminVoteUseCase.test.ts

@@ -0,0 +1,399 @@
+/**
+ * Application Use Case Tests: CastAdminVoteUseCase
+ * 
+ * Tests for casting votes in admin vote sessions
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { CastAdminVoteUseCase } from './CastAdminVoteUseCase';
+import { AdminVoteSessionRepository } from '../../domain/repositories/AdminVoteSessionRepository';
+import { AdminVoteSession } from '../../domain/entities/AdminVoteSession';
+
+// Mock repository
+const createMockRepository = () => ({
+  save: vi.fn(),
+  findById: vi.fn(),
+  findActiveForAdmin: vi.fn(),
+  findByAdminAndLeague: vi.fn(),
+  findByLeague: vi.fn(),
+  findClosedUnprocessed: vi.fn(),
+});
+
+describe('CastAdminVoteUseCase', () => {
+  let useCase: CastAdminVoteUseCase;
+  let mockRepository: ReturnType<typeof createMockRepository>;
+
+  beforeEach(() => {
+    mockRepository = createMockRepository();
+    useCase = new CastAdminVoteUseCase(mockRepository);
+  });
+
+  describe('Input validation', () => {
+    it('should reject when voteSessionId is missing', async () => {
+      const result = await useCase.execute({
+        voteSessionId: '',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('voteSessionId is required');
+    });
+
+    it('should reject when voterId is missing', async () => {
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: '',
+        positive: true,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('voterId is required');
+    });
+
+    it('should reject when positive is not a boolean', async () => {
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: 'true' as any,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('positive must be a boolean value');
+    });
+
+    it('should reject when votedAt is not a valid date', async () => {
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+        votedAt: 'invalid-date',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('votedAt must be a valid date if provided');
+    });
+
+    it('should accept valid input with all fields', async () => {
+      mockRepository.findById.mockResolvedValue({
+        id: 'session-123',
+        isVotingWindowOpen: vi.fn().mockReturnValue(true),
+        castVote: vi.fn(),
+      });
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+        votedAt: '2024-01-01T00:00:00Z',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.errors).toBeUndefined();
+    });
+
+    it('should accept valid input without optional votedAt', async () => {
+      mockRepository.findById.mockResolvedValue({
+        id: 'session-123',
+        isVotingWindowOpen: vi.fn().mockReturnValue(true),
+        castVote: vi.fn(),
+      });
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.errors).toBeUndefined();
+    });
+  });
+
+  describe('Session lookup', () => {
+    it('should reject when vote session is not found', async () => {
+      mockRepository.findById.mockResolvedValue(null);
+
+      const result = await useCase.execute({
+        voteSessionId: 'non-existent-session',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Vote session not found');
+    });
+
+    it('should find session by ID when provided', async () => {
+      const mockSession = {
+        id: 'session-123',
+        isVotingWindowOpen: vi.fn().mockReturnValue(true),
+        castVote: vi.fn(),
+      };
+      mockRepository.findById.mockResolvedValue(mockSession);
+
+      await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(mockRepository.findById).toHaveBeenCalledWith('session-123');
+    });
+  });
+
+  describe('Voting window validation', () => {
+    it('should reject when voting window is not open', async () => {
+      const mockSession = {
+        id: 'session-123',
+        isVotingWindowOpen: vi.fn().mockReturnValue(false),
+        castVote: vi.fn(),
+      };
+      mockRepository.findById.mockResolvedValue(mockSession);
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Vote session is not open for voting');
+      expect(mockSession.isVotingWindowOpen).toHaveBeenCalled();
+    });
+
+    it('should accept when voting window is open', async () => {
+      const mockSession = {
+        id: 'session-123',
+        isVotingWindowOpen: vi.fn().mockReturnValue(true),
+        castVote: vi.fn(),
+      };
+      mockRepository.findById.mockResolvedValue(mockSession);
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(mockSession.isVotingWindowOpen).toHaveBeenCalled();
+    });
+
+    it('should use current time when votedAt is not provided', async () => {
+      const mockSession = {
+        id: 'session-123',
+        isVotingWindowOpen: vi.fn().mockReturnValue(true),
+        castVote: vi.fn(),
+      };
+      mockRepository.findById.mockResolvedValue(mockSession);
+
+      await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(mockSession.isVotingWindowOpen).toHaveBeenCalledWith(expect.any(Date));
+    });
+
+    it('should use provided votedAt when available', async () => {
+      const mockSession = {
+        id: 'session-123',
+        isVotingWindowOpen: vi.fn().mockReturnValue(true),
+        castVote: vi.fn(),
+      };
+      mockRepository.findById.mockResolvedValue(mockSession);
+
+      const votedAt = new Date('2024-01-01T12:00:00Z');
+      await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+        votedAt: votedAt.toISOString(),
+      });
+
+      expect(mockSession.isVotingWindowOpen).toHaveBeenCalledWith(votedAt);
+    });
+  });
+
+  describe('Vote casting', () => {
+    it('should cast positive vote when session is open', async () => {
+      const mockSession = {
+        id: 'session-123',
+        isVotingWindowOpen: vi.fn().mockReturnValue(true),
+        castVote: vi.fn(),
+      };
+      mockRepository.findById.mockResolvedValue(mockSession);
+
+      await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(mockSession.castVote).toHaveBeenCalledWith('voter-123', true, expect.any(Date));
+    });
+
+    it('should cast negative vote when session is open', async () => {
+      const mockSession = {
+        id: 'session-123',
+        isVotingWindowOpen: vi.fn().mockReturnValue(true),
+        castVote: vi.fn(),
+      };
+      mockRepository.findById.mockResolvedValue(mockSession);
+
+      await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: false,
+      });
+
+      expect(mockSession.castVote).toHaveBeenCalledWith('voter-123', false, expect.any(Date));
+    });
+
+    it('should save updated session after casting vote', async () => {
+      const mockSession = {
+        id: 'session-123',
+        isVotingWindowOpen: vi.fn().mockReturnValue(true),
+        castVote: vi.fn(),
+      };
+      mockRepository.findById.mockResolvedValue(mockSession);
+
+      await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(mockRepository.save).toHaveBeenCalledWith(mockSession);
+    });
+
+    it('should return success when vote is cast', async () => {
+      const mockSession = {
+        id: 'session-123',
+        isVotingWindowOpen: vi.fn().mockReturnValue(true),
+        castVote: vi.fn(),
+      };
+      mockRepository.findById.mockResolvedValue(mockSession);
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.voteSessionId).toBe('session-123');
+      expect(result.voterId).toBe('voter-123');
+      expect(result.errors).toBeUndefined();
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should handle repository errors gracefully', async () => {
+      mockRepository.findById.mockRejectedValue(new Error('Database error'));
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Failed to cast vote: Database error');
+    });
+
+    it('should handle unexpected errors gracefully', async () => {
+      mockRepository.findById.mockRejectedValue('Unknown error');
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Failed to cast vote: Unknown error');
+    });
+
+    it('should handle save errors gracefully', async () => {
+      const mockSession = {
+        id: 'session-123',
+        isVotingWindowOpen: vi.fn().mockReturnValue(true),
+        castVote: vi.fn(),
+      };
+      mockRepository.findById.mockResolvedValue(mockSession);
+      mockRepository.save.mockRejectedValue(new Error('Save failed'));
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Failed to cast vote: Save failed');
+    });
+  });
+
+  describe('Return values', () => {
+    it('should return voteSessionId in success response', async () => {
+      const mockSession = {
+        id: 'session-123',
+        isVotingWindowOpen: vi.fn().mockReturnValue(true),
+        castVote: vi.fn(),
+      };
+      mockRepository.findById.mockResolvedValue(mockSession);
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(result.voteSessionId).toBe('session-123');
+    });
+
+    it('should return voterId in success response', async () => {
+      const mockSession = {
+        id: 'session-123',
+        isVotingWindowOpen: vi.fn().mockReturnValue(true),
+        castVote: vi.fn(),
+      };
+      mockRepository.findById.mockResolvedValue(mockSession);
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(result.voterId).toBe('voter-123');
+    });
+
+    it('should return voteSessionId in error response', async () => {
+      mockRepository.findById.mockResolvedValue(null);
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(result.voteSessionId).toBe('session-123');
+    });
+
+    it('should return voterId in error response', async () => {
+      mockRepository.findById.mockResolvedValue(null);
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-123',
+        voterId: 'voter-123',
+        positive: true,
+      });
+
+      expect(result.voterId).toBe('voter-123');
+    });
+  });
+});

core/identity/application/use-cases/OpenAdminVoteSessionUseCase.test.ts

@@ -0,0 +1,251 @@
+/**
+ * Application Use Case Tests: OpenAdminVoteSessionUseCase
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { OpenAdminVoteSessionUseCase } from './OpenAdminVoteSessionUseCase';
+import { AdminVoteSessionRepository } from '../../domain/repositories/AdminVoteSessionRepository';
+import { AdminVoteSession } from '../../domain/entities/AdminVoteSession';
+
+// Mock repository
+const createMockRepository = () => ({
+  save: vi.fn(),
+  findById: vi.fn(),
+  findActiveForAdmin: vi.fn(),
+  findByAdminAndLeague: vi.fn(),
+  findByLeague: vi.fn(),
+  findClosedUnprocessed: vi.fn(),
+});
+
+describe('OpenAdminVoteSessionUseCase', () => {
+  let useCase: OpenAdminVoteSessionUseCase;
+  let mockRepository: ReturnType<typeof createMockRepository>;
+
+  beforeEach(() => {
+    mockRepository = createMockRepository();
+    useCase = new OpenAdminVoteSessionUseCase(mockRepository as unknown as AdminVoteSessionRepository);
+    vi.clearAllMocks();
+  });
+
+  describe('Input validation', () => {
+    it('should reject when voteSessionId is missing', async () => {
+      const result = await useCase.execute({
+        voteSessionId: '',
+        leagueId: 'league-1',
+        adminId: 'admin-1',
+        startDate: '2026-01-01',
+        endDate: '2026-01-07',
+        eligibleVoters: ['voter-1'],
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('voteSessionId is required');
+    });
+
+    it('should reject when leagueId is missing', async () => {
+      const result = await useCase.execute({
+        voteSessionId: 'session-1',
+        leagueId: '',
+        adminId: 'admin-1',
+        startDate: '2026-01-01',
+        endDate: '2026-01-07',
+        eligibleVoters: ['voter-1'],
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('leagueId is required');
+    });
+
+    it('should reject when adminId is missing', async () => {
+      const result = await useCase.execute({
+        voteSessionId: 'session-1',
+        leagueId: 'league-1',
+        adminId: '',
+        startDate: '2026-01-01',
+        endDate: '2026-01-07',
+        eligibleVoters: ['voter-1'],
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('adminId is required');
+    });
+
+    it('should reject when startDate is missing', async () => {
+      const result = await useCase.execute({
+        voteSessionId: 'session-1',
+        leagueId: 'league-1',
+        adminId: 'admin-1',
+        startDate: '',
+        endDate: '2026-01-07',
+        eligibleVoters: ['voter-1'],
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('startDate is required');
+    });
+
+    it('should reject when endDate is missing', async () => {
+      const result = await useCase.execute({
+        voteSessionId: 'session-1',
+        leagueId: 'league-1',
+        adminId: 'admin-1',
+        startDate: '2026-01-01',
+        endDate: '',
+        eligibleVoters: ['voter-1'],
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('endDate is required');
+    });
+
+    it('should reject when startDate is invalid', async () => {
+      const result = await useCase.execute({
+        voteSessionId: 'session-1',
+        leagueId: 'league-1',
+        adminId: 'admin-1',
+        startDate: 'invalid-date',
+        endDate: '2026-01-07',
+        eligibleVoters: ['voter-1'],
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('startDate must be a valid date');
+    });
+
+    it('should reject when endDate is invalid', async () => {
+      const result = await useCase.execute({
+        voteSessionId: 'session-1',
+        leagueId: 'league-1',
+        adminId: 'admin-1',
+        startDate: '2026-01-01',
+        endDate: 'invalid-date',
+        eligibleVoters: ['voter-1'],
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('endDate must be a valid date');
+    });
+
+    it('should reject when startDate is after endDate', async () => {
+      const result = await useCase.execute({
+        voteSessionId: 'session-1',
+        leagueId: 'league-1',
+        adminId: 'admin-1',
+        startDate: '2026-01-07',
+        endDate: '2026-01-01',
+        eligibleVoters: ['voter-1'],
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('startDate must be before endDate');
+    });
+
+    it('should reject when eligibleVoters is empty', async () => {
+      const result = await useCase.execute({
+        voteSessionId: 'session-1',
+        leagueId: 'league-1',
+        adminId: 'admin-1',
+        startDate: '2026-01-01',
+        endDate: '2026-01-07',
+        eligibleVoters: [],
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('At least one eligible voter is required');
+    });
+
+    it('should reject when eligibleVoters has duplicates', async () => {
+      const result = await useCase.execute({
+        voteSessionId: 'session-1',
+        leagueId: 'league-1',
+        adminId: 'admin-1',
+        startDate: '2026-01-01',
+        endDate: '2026-01-07',
+        eligibleVoters: ['voter-1', 'voter-1'],
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Duplicate eligible voters are not allowed');
+    });
+  });
+
+  describe('Business rules', () => {
+    it('should reject when session ID already exists', async () => {
+      mockRepository.findById.mockResolvedValue({ id: 'session-1' } as any);
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-1',
+        leagueId: 'league-1',
+        adminId: 'admin-1',
+        startDate: '2026-01-01',
+        endDate: '2026-01-07',
+        eligibleVoters: ['voter-1'],
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Vote session with this ID already exists');
+    });
+
+    it('should reject when there is an overlapping active session', async () => {
+      mockRepository.findById.mockResolvedValue(null);
+      mockRepository.findActiveForAdmin.mockResolvedValue([
+        {
+          startDate: new Date('2026-01-05'),
+          endDate: new Date('2026-01-10'),
+        }
+      ] as any);
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-1',
+        leagueId: 'league-1',
+        adminId: 'admin-1',
+        startDate: '2026-01-01',
+        endDate: '2026-01-07',
+        eligibleVoters: ['voter-1'],
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors).toContain('Active vote session already exists for this admin in this league with overlapping dates');
+    });
+
+    it('should create and save a new session when valid', async () => {
+      mockRepository.findById.mockResolvedValue(null);
+      mockRepository.findActiveForAdmin.mockResolvedValue([]);
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-1',
+        leagueId: 'league-1',
+        adminId: 'admin-1',
+        startDate: '2026-01-01',
+        endDate: '2026-01-07',
+        eligibleVoters: ['voter-1', 'voter-2'],
+      });
+
+      expect(result.success).toBe(true);
+      expect(mockRepository.save).toHaveBeenCalled();
+      const savedSession = mockRepository.save.mock.calls[0][0];
+      expect(savedSession).toBeInstanceOf(AdminVoteSession);
+      expect(savedSession.id).toBe('session-1');
+      expect(savedSession.leagueId).toBe('league-1');
+      expect(savedSession.adminId).toBe('admin-1');
+    });
+  });
+
+  describe('Error handling', () => {
+    it('should handle repository errors gracefully', async () => {
+      mockRepository.findById.mockRejectedValue(new Error('Database error'));
+
+      const result = await useCase.execute({
+        voteSessionId: 'session-1',
+        leagueId: 'league-1',
+        adminId: 'admin-1',
+        startDate: '2026-01-01',
+        endDate: '2026-01-07',
+        eligibleVoters: ['voter-1'],
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.errors?.[0]).toContain('Failed to open vote session: Database error');
+    });
+  });
+});

core/identity/domain/entities/Company.test.ts

@@ -0,0 +1,241 @@
+/**
+ * Domain Entity Tests: Company
+ * 
+ * Tests for Company entity business rules and invariants
+ */
+
+import { describe, it, expect } from 'vitest';
+import { Company } from './Company';
+import { UserId } from '../value-objects/UserId';
+
+describe('Company', () => {
+  describe('Creation', () => {
+    it('should create a company with valid properties', () => {
+      const userId = UserId.fromString('user-123');
+      const company = Company.create({
+        name: 'Acme Racing Team',
+        ownerUserId: userId,
+        contactEmail: 'contact@acme.com',
+      });
+
+      expect(company.getName()).toBe('Acme Racing Team');
+      expect(company.getOwnerUserId()).toEqual(userId);
+      expect(company.getContactEmail()).toBe('contact@acme.com');
+      expect(company.getId()).toBeDefined();
+      expect(company.getCreatedAt()).toBeInstanceOf(Date);
+    });
+
+    it('should create a company without optional contact email', () => {
+      const userId = UserId.fromString('user-123');
+      const company = Company.create({
+        name: 'Acme Racing Team',
+        ownerUserId: userId,
+      });
+
+      expect(company.getContactEmail()).toBeUndefined();
+    });
+
+    it('should generate unique IDs for different companies', () => {
+      const userId = UserId.fromString('user-123');
+      const company1 = Company.create({
+        name: 'Team A',
+        ownerUserId: userId,
+      });
+      const company2 = Company.create({
+        name: 'Team B',
+        ownerUserId: userId,
+      });
+
+      expect(company1.getId()).not.toBe(company2.getId());
+    });
+  });
+
+  describe('Rehydration', () => {
+    it('should rehydrate company from stored data', () => {
+      const userId = UserId.fromString('user-123');
+      const createdAt = new Date('2024-01-01');
+      
+      const company = Company.rehydrate({
+        id: 'comp-123',
+        name: 'Acme Racing Team',
+        ownerUserId: 'user-123',
+        contactEmail: 'contact@acme.com',
+        createdAt,
+      });
+
+      expect(company.getId()).toBe('comp-123');
+      expect(company.getName()).toBe('Acme Racing Team');
+      expect(company.getOwnerUserId()).toEqual(userId);
+      expect(company.getContactEmail()).toBe('contact@acme.com');
+      expect(company.getCreatedAt()).toEqual(createdAt);
+    });
+
+    it('should rehydrate company without contact email', () => {
+      const createdAt = new Date('2024-01-01');
+      
+      const company = Company.rehydrate({
+        id: 'comp-123',
+        name: 'Acme Racing Team',
+        ownerUserId: 'user-123',
+        createdAt,
+      });
+
+      expect(company.getContactEmail()).toBeUndefined();
+    });
+  });
+
+  describe('Validation', () => {
+    it('should throw error when company name is empty', () => {
+      const userId = UserId.fromString('user-123');
+      
+      expect(() => {
+        Company.create({
+          name: '',
+          ownerUserId: userId,
+        });
+      }).toThrow('Company name cannot be empty');
+    });
+
+    it('should throw error when company name is only whitespace', () => {
+      const userId = UserId.fromString('user-123');
+      
+      expect(() => {
+        Company.create({
+          name: '   ',
+          ownerUserId: userId,
+        });
+      }).toThrow('Company name cannot be empty');
+    });
+
+    it('should throw error when company name is too short', () => {
+      const userId = UserId.fromString('user-123');
+      
+      expect(() => {
+        Company.create({
+          name: 'A',
+          ownerUserId: userId,
+        });
+      }).toThrow('Company name must be at least 2 characters long');
+    });
+
+    it('should throw error when company name is too long', () => {
+      const userId = UserId.fromString('user-123');
+      const longName = 'A'.repeat(101);
+      
+      expect(() => {
+        Company.create({
+          name: longName,
+          ownerUserId: userId,
+        });
+      }).toThrow('Company name must be no more than 100 characters');
+    });
+
+    it('should accept company name with exactly 2 characters', () => {
+      const userId = UserId.fromString('user-123');
+      
+      const company = Company.create({
+        name: 'AB',
+        ownerUserId: userId,
+      });
+
+      expect(company.getName()).toBe('AB');
+    });
+
+    it('should accept company name with exactly 100 characters', () => {
+      const userId = UserId.fromString('user-123');
+      const longName = 'A'.repeat(100);
+      
+      const company = Company.create({
+        name: longName,
+        ownerUserId: userId,
+      });
+
+      expect(company.getName()).toBe(longName);
+    });
+
+    it('should trim whitespace from company name during validation', () => {
+      const userId = UserId.fromString('user-123');
+      
+      const company = Company.create({
+        name: '  Acme Racing Team  ',
+        ownerUserId: userId,
+      });
+
+      // Note: The current implementation doesn't trim, it just validates
+      // So this test documents the current behavior
+      expect(company.getName()).toBe('  Acme Racing Team  ');
+    });
+  });
+
+  describe('Business Rules', () => {
+    it('should maintain immutability of properties', () => {
+      const userId = UserId.fromString('user-123');
+      const company = Company.create({
+        name: 'Acme Racing Team',
+        ownerUserId: userId,
+        contactEmail: 'contact@acme.com',
+      });
+
+      const originalName = company.getName();
+      const originalEmail = company.getContactEmail();
+      
+      // Try to modify (should not work due to readonly properties)
+      // This is more of a TypeScript compile-time check, but we can verify runtime behavior
+      expect(company.getName()).toBe(originalName);
+      expect(company.getContactEmail()).toBe(originalEmail);
+    });
+
+    it('should handle special characters in company name', () => {
+      const userId = UserId.fromString('user-123');
+      
+      const company = Company.create({
+        name: 'Acme & Sons Racing, LLC',
+        ownerUserId: userId,
+      });
+
+      expect(company.getName()).toBe('Acme & Sons Racing, LLC');
+    });
+
+    it('should handle unicode characters in company name', () => {
+      const userId = UserId.fromString('user-123');
+      
+      const company = Company.create({
+        name: 'Räcing Tëam Ñumber Øne',
+        ownerUserId: userId,
+      });
+
+      expect(company.getName()).toBe('Räcing Tëam Ñumber Øne');
+    });
+  });
+
+  describe('Edge Cases', () => {
+    it('should handle rehydration with null contact email', () => {
+      const createdAt = new Date('2024-01-01');
+      
+      const company = Company.rehydrate({
+        id: 'comp-123',
+        name: 'Acme Racing Team',
+        ownerUserId: 'user-123',
+        contactEmail: null as any,
+        createdAt,
+      });
+
+      // The entity stores null as null, not undefined
+      expect(company.getContactEmail()).toBeNull();
+    });
+
+    it('should handle rehydration with undefined contact email', () => {
+      const createdAt = new Date('2024-01-01');
+      
+      const company = Company.rehydrate({
+        id: 'comp-123',
+        name: 'Acme Racing Team',
+        ownerUserId: 'user-123',
+        contactEmail: undefined,
+        createdAt,
+      });
+
+      expect(company.getContactEmail()).toBeUndefined();
+    });
+  });
+});

core/identity/domain/errors/IdentityDomainError.test.ts

@@ -0,0 +1,221 @@
+/**
+ * Domain Error Tests: IdentityDomainError
+ * 
+ * Tests for domain error classes and their behavior
+ */
+
+import { describe, it, expect } from 'vitest';
+import { IdentityDomainError, IdentityDomainValidationError, IdentityDomainInvariantError } from './IdentityDomainError';
+
+describe('IdentityDomainError', () => {
+  describe('IdentityDomainError (base class)', () => {
+    it('should create an error with correct properties', () => {
+      const error = new IdentityDomainValidationError('Test error message');
+
+      expect(error.message).toBe('Test error message');
+      expect(error.type).toBe('domain');
+      expect(error.context).toBe('identity-domain');
+      expect(error.kind).toBe('validation');
+    });
+
+    it('should be an instance of Error', () => {
+      const error = new IdentityDomainValidationError('Test error');
+      expect(error instanceof Error).toBe(true);
+    });
+
+    it('should be an instance of IdentityDomainError', () => {
+      const error = new IdentityDomainValidationError('Test error');
+      expect(error instanceof IdentityDomainError).toBe(true);
+    });
+
+    it('should have correct stack trace', () => {
+      const error = new IdentityDomainValidationError('Test error');
+      expect(error.stack).toBeDefined();
+      expect(error.stack).toContain('IdentityDomainError');
+    });
+
+    it('should handle empty error message', () => {
+      const error = new IdentityDomainValidationError('');
+      expect(error.message).toBe('');
+    });
+
+    it('should handle error message with special characters', () => {
+      const error = new IdentityDomainValidationError('Error: Invalid input @#$%^&*()');
+      expect(error.message).toBe('Error: Invalid input @#$%^&*()');
+    });
+
+    it('should handle error message with newlines', () => {
+      const error = new IdentityDomainValidationError('Error line 1\nError line 2');
+      expect(error.message).toBe('Error line 1\nError line 2');
+    });
+  });
+
+  describe('IdentityDomainValidationError', () => {
+    it('should create a validation error with correct kind', () => {
+      const error = new IdentityDomainValidationError('Invalid email format');
+
+      expect(error.kind).toBe('validation');
+      expect(error.type).toBe('domain');
+      expect(error.context).toBe('identity-domain');
+    });
+
+    it('should be an instance of IdentityDomainValidationError', () => {
+      const error = new IdentityDomainValidationError('Invalid email format');
+      expect(error instanceof IdentityDomainValidationError).toBe(true);
+    });
+
+    it('should be an instance of IdentityDomainError', () => {
+      const error = new IdentityDomainValidationError('Invalid email format');
+      expect(error instanceof IdentityDomainError).toBe(true);
+    });
+
+    it('should handle validation error with empty message', () => {
+      const error = new IdentityDomainValidationError('');
+      expect(error.kind).toBe('validation');
+      expect(error.message).toBe('');
+    });
+
+    it('should handle validation error with complex message', () => {
+      const error = new IdentityDomainValidationError(
+        'Validation failed: Email must be at least 6 characters long and contain a valid domain'
+      );
+      expect(error.kind).toBe('validation');
+      expect(error.message).toBe(
+        'Validation failed: Email must be at least 6 characters long and contain a valid domain'
+      );
+    });
+  });
+
+  describe('IdentityDomainInvariantError', () => {
+    it('should create an invariant error with correct kind', () => {
+      const error = new IdentityDomainInvariantError('User must have a valid email');
+
+      expect(error.kind).toBe('invariant');
+      expect(error.type).toBe('domain');
+      expect(error.context).toBe('identity-domain');
+    });
+
+    it('should be an instance of IdentityDomainInvariantError', () => {
+      const error = new IdentityDomainInvariantError('User must have a valid email');
+      expect(error instanceof IdentityDomainInvariantError).toBe(true);
+    });
+
+    it('should be an instance of IdentityDomainError', () => {
+      const error = new IdentityDomainInvariantError('User must have a valid email');
+      expect(error instanceof IdentityDomainError).toBe(true);
+    });
+
+    it('should handle invariant error with empty message', () => {
+      const error = new IdentityDomainInvariantError('');
+      expect(error.kind).toBe('invariant');
+      expect(error.message).toBe('');
+    });
+
+    it('should handle invariant error with complex message', () => {
+      const error = new IdentityDomainInvariantError(
+        'Invariant violation: User rating must be between 0 and 100'
+      );
+      expect(error.kind).toBe('invariant');
+      expect(error.message).toBe(
+        'Invariant violation: User rating must be between 0 and 100'
+      );
+    });
+  });
+
+  describe('Error hierarchy', () => {
+    it('should maintain correct error hierarchy for validation errors', () => {
+      const error = new IdentityDomainValidationError('Test');
+
+      expect(error instanceof IdentityDomainValidationError).toBe(true);
+      expect(error instanceof IdentityDomainError).toBe(true);
+      expect(error instanceof Error).toBe(true);
+    });
+
+    it('should maintain correct error hierarchy for invariant errors', () => {
+      const error = new IdentityDomainInvariantError('Test');
+
+      expect(error instanceof IdentityDomainInvariantError).toBe(true);
+      expect(error instanceof IdentityDomainError).toBe(true);
+      expect(error instanceof Error).toBe(true);
+    });
+
+    it('should allow catching as IdentityDomainError', () => {
+      const error = new IdentityDomainValidationError('Test');
+
+      try {
+        throw error;
+      } catch (e) {
+        expect(e instanceof IdentityDomainError).toBe(true);
+        expect((e as IdentityDomainError).kind).toBe('validation');
+      }
+    });
+
+    it('should allow catching as Error', () => {
+      const error = new IdentityDomainInvariantError('Test');
+
+      try {
+        throw error;
+      } catch (e) {
+        expect(e instanceof Error).toBe(true);
+        expect((e as Error).message).toBe('Test');
+      }
+    });
+  });
+
+  describe('Error properties', () => {
+    it('should have consistent type property', () => {
+      const validationError = new IdentityDomainValidationError('Test');
+      const invariantError = new IdentityDomainInvariantError('Test');
+
+      expect(validationError.type).toBe('domain');
+      expect(invariantError.type).toBe('domain');
+    });
+
+    it('should have consistent context property', () => {
+      const validationError = new IdentityDomainValidationError('Test');
+      const invariantError = new IdentityDomainInvariantError('Test');
+
+      expect(validationError.context).toBe('identity-domain');
+      expect(invariantError.context).toBe('identity-domain');
+    });
+
+    it('should have different kind properties', () => {
+      const validationError = new IdentityDomainValidationError('Test');
+      const invariantError = new IdentityDomainInvariantError('Test');
+
+      expect(validationError.kind).toBe('validation');
+      expect(invariantError.kind).toBe('invariant');
+    });
+  });
+
+  describe('Error usage patterns', () => {
+    it('should be usable in try-catch blocks', () => {
+      expect(() => {
+        throw new IdentityDomainValidationError('Invalid input');
+      }).toThrow(IdentityDomainValidationError);
+    });
+
+    it('should be usable with error instanceof checks', () => {
+      const error = new IdentityDomainValidationError('Test');
+
+      expect(error instanceof IdentityDomainValidationError).toBe(true);
+      expect(error instanceof IdentityDomainError).toBe(true);
+      expect(error instanceof Error).toBe(true);
+    });
+
+    it('should be usable with error type narrowing', () => {
+      const error: IdentityDomainError = new IdentityDomainValidationError('Test');
+
+      if (error.kind === 'validation') {
+        expect(error instanceof IdentityDomainValidationError).toBe(true);
+      }
+    });
+
+    it('should support error message extraction', () => {
+      const errorMessage = 'User email is required';
+      const error = new IdentityDomainValidationError(errorMessage);
+
+      expect(error.message).toBe(errorMessage);
+    });
+  });
+});

core/identity/domain/services/PasswordHashingService.test.ts

@@ -0,0 +1,216 @@
+/**
+ * Domain Service Tests: PasswordHashingService
+ * 
+ * Tests for password hashing and verification business logic
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest';
+import { PasswordHashingService } from './PasswordHashingService';
+
+describe('PasswordHashingService', () => {
+  let service: PasswordHashingService;
+
+  beforeEach(() => {
+    service = new PasswordHashingService();
+  });
+
+  describe('hash', () => {
+    it('should hash a plain text password', async () => {
+      const plainPassword = 'mySecurePassword123';
+      const hash = await service.hash(plainPassword);
+
+      expect(hash).toBeDefined();
+      expect(typeof hash).toBe('string');
+      expect(hash.length).toBeGreaterThan(0);
+      // Hash should not be the same as the plain password
+      expect(hash).not.toBe(plainPassword);
+    });
+
+    it('should produce different hashes for the same password (with salt)', async () => {
+      const plainPassword = 'mySecurePassword123';
+      const hash1 = await service.hash(plainPassword);
+      const hash2 = await service.hash(plainPassword);
+
+      // Due to salting, hashes should be different
+      expect(hash1).not.toBe(hash2);
+    });
+
+    it('should handle empty string password', async () => {
+      const hash = await service.hash('');
+      expect(hash).toBeDefined();
+      expect(typeof hash).toBe('string');
+    });
+
+    it('should handle special characters in password', async () => {
+      const specialPassword = 'P@ssw0rd!#$%^&*()_+-=[]{}|;:,.<>?';
+      const hash = await service.hash(specialPassword);
+
+      expect(hash).toBeDefined();
+      expect(typeof hash).toBe('string');
+    });
+
+    it('should handle unicode characters in password', async () => {
+      const unicodePassword = 'Pässwörd!🔒';
+      const hash = await service.hash(unicodePassword);
+
+      expect(hash).toBeDefined();
+      expect(typeof hash).toBe('string');
+    });
+
+    it('should handle very long passwords', async () => {
+      const longPassword = 'a'.repeat(1000);
+      const hash = await service.hash(longPassword);
+
+      expect(hash).toBeDefined();
+      expect(typeof hash).toBe('string');
+    });
+
+    it('should handle whitespace-only password', async () => {
+      const whitespacePassword = '   ';
+      const hash = await service.hash(whitespacePassword);
+
+      expect(hash).toBeDefined();
+      expect(typeof hash).toBe('string');
+    });
+  });
+
+  describe('verify', () => {
+    it('should verify correct password against hash', async () => {
+      const plainPassword = 'mySecurePassword123';
+      const hash = await service.hash(plainPassword);
+
+      const isValid = await service.verify(plainPassword, hash);
+      expect(isValid).toBe(true);
+    });
+
+    it('should reject incorrect password', async () => {
+      const plainPassword = 'mySecurePassword123';
+      const hash = await service.hash(plainPassword);
+
+      const isValid = await service.verify('wrongPassword', hash);
+      expect(isValid).toBe(false);
+    });
+
+    it('should reject empty password against hash', async () => {
+      const plainPassword = 'mySecurePassword123';
+      const hash = await service.hash(plainPassword);
+
+      const isValid = await service.verify('', hash);
+      expect(isValid).toBe(false);
+    });
+
+    it('should handle verification with special characters', async () => {
+      const specialPassword = 'P@ssw0rd!#$%^&*()_+-=[]{}|;:,.<>?';
+      const hash = await service.hash(specialPassword);
+
+      const isValid = await service.verify(specialPassword, hash);
+      expect(isValid).toBe(true);
+    });
+
+    it('should handle verification with unicode characters', async () => {
+      const unicodePassword = 'Pässwörd!🔒';
+      const hash = await service.hash(unicodePassword);
+
+      const isValid = await service.verify(unicodePassword, hash);
+      expect(isValid).toBe(true);
+    });
+
+    it('should handle verification with very long passwords', async () => {
+      const longPassword = 'a'.repeat(1000);
+      const hash = await service.hash(longPassword);
+
+      const isValid = await service.verify(longPassword, hash);
+      expect(isValid).toBe(true);
+    });
+
+    it('should handle verification with whitespace-only password', async () => {
+      const whitespacePassword = '   ';
+      const hash = await service.hash(whitespacePassword);
+
+      const isValid = await service.verify(whitespacePassword, hash);
+      expect(isValid).toBe(true);
+    });
+
+    it('should reject verification with null hash', async () => {
+      // bcrypt throws an error when hash is null, which is expected behavior
+      await expect(service.verify('password', null as any)).rejects.toThrow();
+    });
+
+    it('should reject verification with empty hash', async () => {
+      const isValid = await service.verify('password', '');
+      expect(isValid).toBe(false);
+    });
+
+    it('should reject verification with invalid hash format', async () => {
+      const isValid = await service.verify('password', 'invalid-hash-format');
+      expect(isValid).toBe(false);
+    });
+  });
+
+  describe('Hash Consistency', () => {
+    it('should consistently verify the same password-hash pair', async () => {
+      const plainPassword = 'testPassword123';
+      const hash = await service.hash(plainPassword);
+
+      // Verify multiple times
+      const result1 = await service.verify(plainPassword, hash);
+      const result2 = await service.verify(plainPassword, hash);
+      const result3 = await service.verify(plainPassword, hash);
+
+      expect(result1).toBe(true);
+      expect(result2).toBe(true);
+      expect(result3).toBe(true);
+    });
+
+    it('should consistently reject wrong password', async () => {
+      const plainPassword = 'testPassword123';
+      const wrongPassword = 'wrongPassword';
+      const hash = await service.hash(plainPassword);
+
+      // Verify multiple times with wrong password
+      const result1 = await service.verify(wrongPassword, hash);
+      const result2 = await service.verify(wrongPassword, hash);
+      const result3 = await service.verify(wrongPassword, hash);
+
+      expect(result1).toBe(false);
+      expect(result2).toBe(false);
+      expect(result3).toBe(false);
+    });
+  });
+
+  describe('Security Properties', () => {
+    it('should not leak information about the original password from hash', async () => {
+      const password1 = 'password123';
+      const password2 = 'password456';
+      
+      const hash1 = await service.hash(password1);
+      const hash2 = await service.hash(password2);
+
+      // Hashes should be different
+      expect(hash1).not.toBe(hash2);
+      
+      // Neither hash should contain the original password
+      expect(hash1).not.toContain(password1);
+      expect(hash2).not.toContain(password2);
+    });
+
+    it('should handle case sensitivity correctly', async () => {
+      const password1 = 'Password';
+      const password2 = 'password';
+      
+      const hash1 = await service.hash(password1);
+      const hash2 = await service.hash(password2);
+
+      // Should be treated as different passwords
+      const isValid1 = await service.verify(password1, hash1);
+      const isValid2 = await service.verify(password2, hash2);
+      const isCrossValid1 = await service.verify(password1, hash2);
+      const isCrossValid2 = await service.verify(password2, hash1);
+
+      expect(isValid1).toBe(true);
+      expect(isValid2).toBe(true);
+      expect(isCrossValid1).toBe(false);
+      expect(isCrossValid2).toBe(false);
+    });
+  });
+});

core/identity/domain/types/EmailAddress.test.ts

@@ -0,0 +1,338 @@
+/**
+ * Domain Types Tests: EmailAddress
+ * 
+ * Tests for email validation and disposable email detection
+ */
+
+import { describe, it, expect } from 'vitest';
+import { validateEmail, isDisposableEmail, DISPOSABLE_DOMAINS } from './EmailAddress';
+
+describe('EmailAddress', () => {
+  describe('validateEmail', () => {
+    describe('Valid emails', () => {
+      it('should validate standard email format', () => {
+        const result = validateEmail('user@example.com');
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.email).toBe('user@example.com');
+        }
+      });
+
+      it('should validate email with subdomain', () => {
+        const result = validateEmail('user@mail.example.com');
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.email).toBe('user@mail.example.com');
+        }
+      });
+
+      it('should validate email with plus sign', () => {
+        const result = validateEmail('user+tag@example.com');
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.email).toBe('user+tag@example.com');
+        }
+      });
+
+      it('should validate email with numbers', () => {
+        const result = validateEmail('user123@example.com');
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.email).toBe('user123@example.com');
+        }
+      });
+
+      it('should validate email with hyphens', () => {
+        const result = validateEmail('user-name@example.com');
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.email).toBe('user-name@example.com');
+        }
+      });
+
+      it('should validate email with underscores', () => {
+        const result = validateEmail('user_name@example.com');
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.email).toBe('user_name@example.com');
+        }
+      });
+
+      it('should validate email with dots in local part', () => {
+        const result = validateEmail('user.name@example.com');
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.email).toBe('user.name@example.com');
+        }
+      });
+
+      it('should validate email with uppercase letters', () => {
+        const result = validateEmail('User@Example.com');
+        expect(result.success).toBe(true);
+        if (result.success) {
+          // Should be normalized to lowercase
+          expect(result.email).toBe('user@example.com');
+        }
+      });
+
+      it('should validate email with leading/trailing whitespace', () => {
+        const result = validateEmail('  user@example.com  ');
+        expect(result.success).toBe(true);
+        if (result.success) {
+          // Should be trimmed
+          expect(result.email).toBe('user@example.com');
+        }
+      });
+
+      it('should validate minimum length email (6 chars)', () => {
+        const result = validateEmail('a@b.cd');
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.email).toBe('a@b.cd');
+        }
+      });
+
+      it('should validate maximum length email (254 chars)', () => {
+        const localPart = 'a'.repeat(64);
+        const domain = 'example.com';
+        const email = `${localPart}@${domain}`;
+        const result = validateEmail(email);
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.email).toBe(email);
+        }
+      });
+    });
+
+    describe('Invalid emails', () => {
+      it('should reject empty string', () => {
+        const result = validateEmail('');
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error).toBeDefined();
+        }
+      });
+
+      it('should reject whitespace-only string', () => {
+        const result = validateEmail('   ');
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error).toBeDefined();
+        }
+      });
+
+      it('should reject email without @ symbol', () => {
+        const result = validateEmail('userexample.com');
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error).toBeDefined();
+        }
+      });
+
+      it('should reject email without domain', () => {
+        const result = validateEmail('user@');
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error).toBeDefined();
+        }
+      });
+
+      it('should reject email without local part', () => {
+        const result = validateEmail('@example.com');
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error).toBeDefined();
+        }
+      });
+
+      it('should reject email with multiple @ symbols', () => {
+        const result = validateEmail('user@domain@com');
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error).toBeDefined();
+        }
+      });
+
+      it('should reject email with spaces in local part', () => {
+        const result = validateEmail('user name@example.com');
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error).toBeDefined();
+        }
+      });
+
+      it('should reject email with spaces in domain', () => {
+        const result = validateEmail('user@ex ample.com');
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error).toBeDefined();
+        }
+      });
+
+      it('should reject email with invalid characters', () => {
+        const result = validateEmail('user#name@example.com');
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error).toBeDefined();
+        }
+      });
+
+      it('should reject email that is too short', () => {
+        const result = validateEmail('a@b.c');
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error).toBeDefined();
+        }
+      });
+
+      it('should accept email that is exactly 254 characters', () => {
+        // The maximum email length is 254 characters
+        const localPart = 'a'.repeat(64);
+        const domain = 'example.com';
+        const email = `${localPart}@${domain}`;
+        const result = validateEmail(email);
+        expect(result.success).toBe(true);
+        if (result.success) {
+          expect(result.email).toBe(email);
+        }
+      });
+
+      it('should reject email without TLD', () => {
+        const result = validateEmail('user@example');
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error).toBeDefined();
+        }
+      });
+
+      it('should reject email with invalid TLD format', () => {
+        const result = validateEmail('user@example.');
+        expect(result.success).toBe(false);
+        if (!result.success) {
+          expect(result.error).toBeDefined();
+        }
+      });
+    });
+
+    describe('Edge cases', () => {
+      it('should handle null input gracefully', () => {
+        const result = validateEmail(null as any);
+        expect(result.success).toBe(false);
+      });
+
+      it('should handle undefined input gracefully', () => {
+        const result = validateEmail(undefined as any);
+        expect(result.success).toBe(false);
+      });
+
+      it('should handle non-string input gracefully', () => {
+        const result = validateEmail(123 as any);
+        expect(result.success).toBe(false);
+      });
+    });
+  });
+
+  describe('isDisposableEmail', () => {
+    describe('Disposable email domains', () => {
+      it('should detect tempmail.com as disposable', () => {
+        expect(isDisposableEmail('user@tempmail.com')).toBe(true);
+      });
+
+      it('should detect throwaway.email as disposable', () => {
+        expect(isDisposableEmail('user@throwaway.email')).toBe(true);
+      });
+
+      it('should detect guerrillamail.com as disposable', () => {
+        expect(isDisposableEmail('user@guerrillamail.com')).toBe(true);
+      });
+
+      it('should detect mailinator.com as disposable', () => {
+        expect(isDisposableEmail('user@mailinator.com')).toBe(true);
+      });
+
+      it('should detect 10minutemail.com as disposable', () => {
+        expect(isDisposableEmail('user@10minutemail.com')).toBe(true);
+      });
+
+      it('should detect disposable domains case-insensitively', () => {
+        expect(isDisposableEmail('user@TEMPMAIL.COM')).toBe(true);
+        expect(isDisposableEmail('user@TempMail.Com')).toBe(true);
+      });
+
+      it('should detect disposable domains with subdomains', () => {
+        // The current implementation only checks the exact domain, not subdomains
+        // So this test documents the current behavior
+        expect(isDisposableEmail('user@subdomain.tempmail.com')).toBe(false);
+      });
+    });
+
+    describe('Non-disposable email domains', () => {
+      it('should not detect gmail.com as disposable', () => {
+        expect(isDisposableEmail('user@gmail.com')).toBe(false);
+      });
+
+      it('should not detect yahoo.com as disposable', () => {
+        expect(isDisposableEmail('user@yahoo.com')).toBe(false);
+      });
+
+      it('should not detect outlook.com as disposable', () => {
+        expect(isDisposableEmail('user@outlook.com')).toBe(false);
+      });
+
+      it('should not detect company domains as disposable', () => {
+        expect(isDisposableEmail('user@example.com')).toBe(false);
+        expect(isDisposableEmail('user@company.com')).toBe(false);
+      });
+
+      it('should not detect custom domains as disposable', () => {
+        expect(isDisposableEmail('user@mydomain.com')).toBe(false);
+      });
+    });
+
+    describe('Edge cases', () => {
+      it('should handle email without domain', () => {
+        expect(isDisposableEmail('user@')).toBe(false);
+      });
+
+      it('should handle email without @ symbol', () => {
+        expect(isDisposableEmail('user')).toBe(false);
+      });
+
+      it('should handle empty string', () => {
+        expect(isDisposableEmail('')).toBe(false);
+      });
+
+      it('should handle null input', () => {
+        // The current implementation throws an error when given null
+        // This is expected behavior - the function expects a string
+        expect(() => isDisposableEmail(null as any)).toThrow();
+      });
+  
+      it('should handle undefined input', () => {
+        // The current implementation throws an error when given undefined
+        // This is expected behavior - the function expects a string
+        expect(() => isDisposableEmail(undefined as any)).toThrow();
+      });
+    });
+  });
+
+  describe('DISPOSABLE_DOMAINS', () => {
+    it('should contain expected disposable domains', () => {
+      expect(DISPOSABLE_DOMAINS.has('tempmail.com')).toBe(true);
+      expect(DISPOSABLE_DOMAINS.has('throwaway.email')).toBe(true);
+      expect(DISPOSABLE_DOMAINS.has('guerrillamail.com')).toBe(true);
+      expect(DISPOSABLE_DOMAINS.has('mailinator.com')).toBe(true);
+      expect(DISPOSABLE_DOMAINS.has('10minutemail.com')).toBe(true);
+    });
+
+    it('should not contain non-disposable domains', () => {
+      expect(DISPOSABLE_DOMAINS.has('gmail.com')).toBe(false);
+      expect(DISPOSABLE_DOMAINS.has('yahoo.com')).toBe(false);
+      expect(DISPOSABLE_DOMAINS.has('outlook.com')).toBe(false);
+    });
+
+    it('should be a Set', () => {
+      expect(DISPOSABLE_DOMAINS instanceof Set).toBe(true);
+    });
+  });
+});

core/media/application/use-cases/GetUploadedMediaUseCase.test.ts

@@ -0,0 +1,128 @@
+import { Result } from '@core/shared/domain/Result';
+import { describe, expect, it, vi, type Mock } from 'vitest';
+import type { MediaStoragePort } from '../ports/MediaStoragePort';
+import { GetUploadedMediaUseCase } from './GetUploadedMediaUseCase';
+
+describe('GetUploadedMediaUseCase', () => {
+  let mediaStorage: {
+    getBytes: Mock;
+    getMetadata: Mock;
+  };
+  let useCase: GetUploadedMediaUseCase;
+
+  beforeEach(() => {
+    mediaStorage = {
+      getBytes: vi.fn(),
+      getMetadata: vi.fn(),
+    };
+
+    useCase = new GetUploadedMediaUseCase(
+      mediaStorage as unknown as MediaStoragePort,
+    );
+  });
+
+  it('returns null when media is not found', async () => {
+    mediaStorage.getBytes.mockResolvedValue(null);
+
+    const input = { storageKey: 'missing-key' };
+    const result = await useCase.execute(input);
+
+    expect(mediaStorage.getBytes).toHaveBeenCalledWith('missing-key');
+    expect(result).toBeInstanceOf(Result);
+    expect(result.isOk()).toBe(true);
+    expect(result.unwrap()).toBe(null);
+  });
+
+  it('returns media bytes and content type when found', async () => {
+    const mockBytes = Buffer.from('test data');
+    const mockMetadata = { size: 9, contentType: 'image/png' };
+
+    mediaStorage.getBytes.mockResolvedValue(mockBytes);
+    mediaStorage.getMetadata.mockResolvedValue(mockMetadata);
+
+    const input = { storageKey: 'media-key' };
+    const result = await useCase.execute(input);
+
+    expect(mediaStorage.getBytes).toHaveBeenCalledWith('media-key');
+    expect(mediaStorage.getMetadata).toHaveBeenCalledWith('media-key');
+    expect(result.isOk()).toBe(true);
+
+    const successResult = result.unwrap();
+    expect(successResult).not.toBeNull();
+    expect(successResult!.bytes).toBeInstanceOf(Buffer);
+    expect(successResult!.bytes.toString()).toBe('test data');
+    expect(successResult!.contentType).toBe('image/png');
+  });
+
+  it('returns default content type when metadata is null', async () => {
+    const mockBytes = Buffer.from('test data');
+
+    mediaStorage.getBytes.mockResolvedValue(mockBytes);
+    mediaStorage.getMetadata.mockResolvedValue(null);
+
+    const input = { storageKey: 'media-key' };
+    const result = await useCase.execute(input);
+
+    expect(result.isOk()).toBe(true);
+
+    const successResult = result.unwrap();
+    expect(successResult!.contentType).toBe('application/octet-stream');
+  });
+
+  it('returns default content type when metadata has no contentType', async () => {
+    const mockBytes = Buffer.from('test data');
+    const mockMetadata = { size: 9 };
+
+    mediaStorage.getBytes.mockResolvedValue(mockBytes);
+    mediaStorage.getMetadata.mockResolvedValue(mockMetadata as any);
+
+    const input = { storageKey: 'media-key' };
+    const result = await useCase.execute(input);
+
+    expect(result.isOk()).toBe(true);
+
+    const successResult = result.unwrap();
+    expect(successResult!.contentType).toBe('application/octet-stream');
+  });
+
+  it('handles storage errors by returning error', async () => {
+    mediaStorage.getBytes.mockRejectedValue(new Error('Storage error'));
+
+    const input = { storageKey: 'media-key' };
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr();
+    expect(err.message).toBe('Storage error');
+  });
+
+  it('handles getMetadata errors by returning error', async () => {
+    const mockBytes = Buffer.from('test data');
+
+    mediaStorage.getBytes.mockResolvedValue(mockBytes);
+    mediaStorage.getMetadata.mockRejectedValue(new Error('Metadata error'));
+
+    const input = { storageKey: 'media-key' };
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr();
+    expect(err.message).toBe('Metadata error');
+  });
+
+  it('returns bytes as Buffer', async () => {
+    const mockBytes = new Uint8Array([0x48, 0x65, 0x6c, 0x6c, 0x6f]); // "Hello"
+
+    mediaStorage.getBytes.mockResolvedValue(mockBytes);
+    mediaStorage.getMetadata.mockResolvedValue({ size: 5, contentType: 'text/plain' });
+
+    const input = { storageKey: 'media-key' };
+    const result = await useCase.execute(input);
+
+    expect(result.isOk()).toBe(true);
+
+    const successResult = result.unwrap();
+    expect(successResult!.bytes).toBeInstanceOf(Buffer);
+    expect(successResult!.bytes.toString()).toBe('Hello');
+  });
+});

core/media/application/use-cases/ResolveMediaReferenceUseCase.test.ts

@@ -0,0 +1,103 @@
+import { Result } from '@core/shared/domain/Result';
+import { describe, expect, it, vi, type Mock } from 'vitest';
+import type { MediaResolverPort } from '@core/ports/media/MediaResolverPort';
+import { ResolveMediaReferenceUseCase } from './ResolveMediaReferenceUseCase';
+
+describe('ResolveMediaReferenceUseCase', () => {
+  let mediaResolver: {
+    resolve: Mock;
+  };
+  let useCase: ResolveMediaReferenceUseCase;
+
+  beforeEach(() => {
+    mediaResolver = {
+      resolve: vi.fn(),
+    };
+
+    useCase = new ResolveMediaReferenceUseCase(
+      mediaResolver as unknown as MediaResolverPort,
+    );
+  });
+
+  it('returns resolved path when media reference is resolved', async () => {
+    mediaResolver.resolve.mockResolvedValue('/resolved/path/to/media.png');
+
+    const input = { reference: { type: 'team', id: 'team-123' } };
+    const result = await useCase.execute(input);
+
+    expect(mediaResolver.resolve).toHaveBeenCalledWith({ type: 'team', id: 'team-123' });
+    expect(result.isOk()).toBe(true);
+
+    const successResult = result.unwrap();
+    expect(successResult).toBe('/resolved/path/to/media.png');
+  });
+
+  it('returns null when media reference resolves to null', async () => {
+    mediaResolver.resolve.mockResolvedValue(null);
+
+    const input = { reference: { type: 'team', id: 'team-123' } };
+    const result = await useCase.execute(input);
+
+    expect(mediaResolver.resolve).toHaveBeenCalledWith({ type: 'team', id: 'team-123' });
+    expect(result.isOk()).toBe(true);
+
+    const successResult = result.unwrap();
+    expect(successResult).toBe(null);
+  });
+
+  it('returns empty string when media reference resolves to empty string', async () => {
+    mediaResolver.resolve.mockResolvedValue('');
+
+    const input = { reference: { type: 'team', id: 'team-123' } };
+    const result = await useCase.execute(input);
+
+    expect(mediaResolver.resolve).toHaveBeenCalledWith({ type: 'team', id: 'team-123' });
+    expect(result.isOk()).toBe(true);
+
+    const successResult = result.unwrap();
+    expect(successResult).toBe('');
+  });
+
+  it('handles resolver errors by returning error', async () => {
+    mediaResolver.resolve.mockRejectedValue(new Error('Resolver error'));
+
+    const input = { reference: { type: 'team', id: 'team-123' } };
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr();
+    expect(err.message).toBe('Resolver error');
+  });
+
+  it('handles non-Error exceptions by wrapping in Error', async () => {
+    mediaResolver.resolve.mockRejectedValue('string error');
+
+    const input = { reference: { type: 'team', id: 'team-123' } };
+    const result = await useCase.execute(input);
+
+    expect(result.isErr()).toBe(true);
+    const err = result.unwrapErr();
+    expect(err.message).toBe('string error');
+  });
+
+  it('resolves different reference types', async () => {
+    const testCases = [
+      { type: 'team', id: 'team-123' },
+      { type: 'league', id: 'league-456' },
+      { type: 'driver', id: 'driver-789' },
+    ];
+
+    for (const reference of testCases) {
+      mediaResolver.resolve.mockResolvedValue(`/resolved/${reference.type}/${reference.id}.png`);
+
+      const input = { reference };
+      const result = await useCase.execute(input);
+
+      expect(mediaResolver.resolve).toHaveBeenCalledWith(reference);
+      expect(result.isOk()).toBe(true);
+
+      const successResult = result.unwrap();
+      expect(successResult).toBe(`/resolved/${reference.type}/${reference.id}.png`);
+    }
+  });
+});

core/media/domain/entities/Avatar.test.ts

@@ -1,7 +1,182 @@
-import * as mod from '@core/media/domain/entities/Avatar';
+import { Avatar } from './Avatar';
+import { MediaUrl } from '../value-objects/MediaUrl';
 
-describe('media/domain/entities/Avatar.ts', () => {
-  it('imports', () => {
-    expect(mod).toBeTruthy();
+describe('Avatar', () => {
+  describe('create', () => {
+    it('creates a new avatar with required properties', () => {
+      const avatar = Avatar.create({
+        id: 'avatar-1',
+        driverId: 'driver-1',
+        mediaUrl: 'https://example.com/avatar.png',
+      });
+
+      expect(avatar.id).toBe('avatar-1');
+      expect(avatar.driverId).toBe('driver-1');
+      expect(avatar.mediaUrl).toBeInstanceOf(MediaUrl);
+      expect(avatar.mediaUrl.value).toBe('https://example.com/avatar.png');
+      expect(avatar.isActive).toBe(true);
+      expect(avatar.selectedAt).toBeInstanceOf(Date);
+    });
+
+    it('throws error when driverId is missing', () => {
+      expect(() =>
+        Avatar.create({
+          id: 'avatar-1',
+          driverId: '',
+          mediaUrl: 'https://example.com/avatar.png',
+        })
+      ).toThrow('Driver ID is required');
+    });
+
+    it('throws error when mediaUrl is missing', () => {
+      expect(() =>
+        Avatar.create({
+          id: 'avatar-1',
+          driverId: 'driver-1',
+          mediaUrl: '',
+        })
+      ).toThrow('Media URL is required');
+    });
+
+    it('throws error when mediaUrl is invalid', () => {
+      expect(() =>
+        Avatar.create({
+          id: 'avatar-1',
+          driverId: 'driver-1',
+          mediaUrl: 'invalid-url',
+        })
+      ).toThrow();
+    });
+  });
+
+  describe('reconstitute', () => {
+    it('reconstitutes an avatar from props', () => {
+      const selectedAt = new Date('2024-01-01T00:00:00.000Z');
+      const avatar = Avatar.reconstitute({
+        id: 'avatar-1',
+        driverId: 'driver-1',
+        mediaUrl: 'https://example.com/avatar.png',
+        selectedAt,
+        isActive: true,
+      });
+
+      expect(avatar.id).toBe('avatar-1');
+      expect(avatar.driverId).toBe('driver-1');
+      expect(avatar.mediaUrl.value).toBe('https://example.com/avatar.png');
+      expect(avatar.selectedAt).toEqual(selectedAt);
+      expect(avatar.isActive).toBe(true);
+    });
+
+    it('reconstitutes an inactive avatar', () => {
+      const avatar = Avatar.reconstitute({
+        id: 'avatar-1',
+        driverId: 'driver-1',
+        mediaUrl: 'https://example.com/avatar.png',
+        selectedAt: new Date(),
+        isActive: false,
+      });
+
+      expect(avatar.isActive).toBe(false);
+    });
+  });
+
+  describe('deactivate', () => {
+    it('deactivates an active avatar', () => {
+      const avatar = Avatar.create({
+        id: 'avatar-1',
+        driverId: 'driver-1',
+        mediaUrl: 'https://example.com/avatar.png',
+      });
+
+      expect(avatar.isActive).toBe(true);
+
+      avatar.deactivate();
+
+      expect(avatar.isActive).toBe(false);
+    });
+
+    it('can deactivate an already inactive avatar', () => {
+      const avatar = Avatar.reconstitute({
+        id: 'avatar-1',
+        driverId: 'driver-1',
+        mediaUrl: 'https://example.com/avatar.png',
+        selectedAt: new Date(),
+        isActive: false,
+      });
+
+      avatar.deactivate();
+
+      expect(avatar.isActive).toBe(false);
+    });
+  });
+
+  describe('toProps', () => {
+    it('returns correct props for a new avatar', () => {
+      const avatar = Avatar.create({
+        id: 'avatar-1',
+        driverId: 'driver-1',
+        mediaUrl: 'https://example.com/avatar.png',
+      });
+
+      const props = avatar.toProps();
+
+      expect(props.id).toBe('avatar-1');
+      expect(props.driverId).toBe('driver-1');
+      expect(props.mediaUrl).toBe('https://example.com/avatar.png');
+      expect(props.selectedAt).toBeInstanceOf(Date);
+      expect(props.isActive).toBe(true);
+    });
+
+    it('returns correct props for an inactive avatar', () => {
+      const selectedAt = new Date('2024-01-01T00:00:00.000Z');
+      const avatar = Avatar.reconstitute({
+        id: 'avatar-1',
+        driverId: 'driver-1',
+        mediaUrl: 'https://example.com/avatar.png',
+        selectedAt,
+        isActive: false,
+      });
+
+      const props = avatar.toProps();
+
+      expect(props.id).toBe('avatar-1');
+      expect(props.driverId).toBe('driver-1');
+      expect(props.mediaUrl).toBe('https://example.com/avatar.png');
+      expect(props.selectedAt).toEqual(selectedAt);
+      expect(props.isActive).toBe(false);
+    });
+  });
+
+  describe('value object validation', () => {
+    it('validates mediaUrl as MediaUrl value object', () => {
+      const avatar = Avatar.create({
+        id: 'avatar-1',
+        driverId: 'driver-1',
+        mediaUrl: 'https://example.com/avatar.png',
+      });
+
+      expect(avatar.mediaUrl).toBeInstanceOf(MediaUrl);
+      expect(avatar.mediaUrl.value).toBe('https://example.com/avatar.png');
+    });
+
+    it('accepts data URI for mediaUrl', () => {
+      const avatar = Avatar.create({
+        id: 'avatar-1',
+        driverId: 'driver-1',
+        mediaUrl: 'data:image/png;base64,abc',
+      });
+
+      expect(avatar.mediaUrl.value).toBe('data:image/png;base64,abc');
+    });
+
+    it('accepts root-relative path for mediaUrl', () => {
+      const avatar = Avatar.create({
+        id: 'avatar-1',
+        driverId: 'driver-1',
+        mediaUrl: '/images/avatar.png',
+      });
+
+      expect(avatar.mediaUrl.value).toBe('/images/avatar.png');
+    });
   });
 });

core/media/domain/entities/AvatarGenerationRequest.test.ts

@@ -1,7 +1,476 @@
-import * as mod from '@core/media/domain/entities/AvatarGenerationRequest';
+import { AvatarGenerationRequest } from './AvatarGenerationRequest';
+import { MediaUrl } from '../value-objects/MediaUrl';
 
-describe('media/domain/entities/AvatarGenerationRequest.ts', () => {
-  it('imports', () => {
-    expect(mod).toBeTruthy();
+describe('AvatarGenerationRequest', () => {
+  describe('create', () => {
+    it('creates a new request with required properties', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+        style: 'realistic',
+      });
+
+      expect(request.id).toBe('req-1');
+      expect(request.userId).toBe('user-1');
+      expect(request.facePhotoUrl).toBeInstanceOf(MediaUrl);
+      expect(request.facePhotoUrl.value).toBe('data:image/png;base64,abc');
+      expect(request.suitColor).toBe('red');
+      expect(request.style).toBe('realistic');
+      expect(request.status).toBe('pending');
+      expect(request.generatedAvatarUrls).toEqual([]);
+      expect(request.selectedAvatarIndex).toBeUndefined();
+      expect(request.errorMessage).toBeUndefined();
+      expect(request.createdAt).toBeInstanceOf(Date);
+      expect(request.updatedAt).toBeInstanceOf(Date);
+    });
+
+    it('creates request with default style when not provided', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'blue',
+      });
+
+      expect(request.style).toBe('realistic');
+    });
+
+    it('throws error when userId is missing', () => {
+      expect(() =>
+        AvatarGenerationRequest.create({
+          id: 'req-1',
+          userId: '',
+          facePhotoUrl: 'data:image/png;base64,abc',
+          suitColor: 'red',
+        })
+      ).toThrow('User ID is required');
+    });
+
+    it('throws error when facePhotoUrl is missing', () => {
+      expect(() =>
+        AvatarGenerationRequest.create({
+          id: 'req-1',
+          userId: 'user-1',
+          facePhotoUrl: '',
+          suitColor: 'red',
+        })
+      ).toThrow('Face photo URL is required');
+    });
+
+    it('throws error when facePhotoUrl is invalid', () => {
+      expect(() =>
+        AvatarGenerationRequest.create({
+          id: 'req-1',
+          userId: 'user-1',
+          facePhotoUrl: 'invalid-url',
+          suitColor: 'red',
+        })
+      ).toThrow();
+    });
+  });
+
+  describe('reconstitute', () => {
+    it('reconstitutes a request from props', () => {
+      const createdAt = new Date('2024-01-01T00:00:00.000Z');
+      const updatedAt = new Date('2024-01-01T01:00:00.000Z');
+      const request = AvatarGenerationRequest.reconstitute({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+        style: 'realistic',
+        status: 'pending',
+        generatedAvatarUrls: [],
+        createdAt,
+        updatedAt,
+      });
+
+      expect(request.id).toBe('req-1');
+      expect(request.userId).toBe('user-1');
+      expect(request.facePhotoUrl.value).toBe('data:image/png;base64,abc');
+      expect(request.suitColor).toBe('red');
+      expect(request.style).toBe('realistic');
+      expect(request.status).toBe('pending');
+      expect(request.generatedAvatarUrls).toEqual([]);
+      expect(request.selectedAvatarIndex).toBeUndefined();
+      expect(request.errorMessage).toBeUndefined();
+      expect(request.createdAt).toEqual(createdAt);
+      expect(request.updatedAt).toEqual(updatedAt);
+    });
+
+    it('reconstitutes a request with selected avatar', () => {
+      const request = AvatarGenerationRequest.reconstitute({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+        style: 'realistic',
+        status: 'completed',
+        generatedAvatarUrls: ['https://example.com/a.png', 'https://example.com/b.png'],
+        selectedAvatarIndex: 1,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      });
+
+      expect(request.selectedAvatarIndex).toBe(1);
+      expect(request.selectedAvatarUrl).toBe('https://example.com/b.png');
+    });
+
+    it('reconstitutes a failed request', () => {
+      const request = AvatarGenerationRequest.reconstitute({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+        style: 'realistic',
+        status: 'failed',
+        generatedAvatarUrls: [],
+        errorMessage: 'Generation failed',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      });
+
+      expect(request.status).toBe('failed');
+      expect(request.errorMessage).toBe('Generation failed');
+    });
+  });
+
+  describe('status transitions', () => {
+    it('transitions from pending to validating', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+      });
+
+      expect(request.status).toBe('pending');
+
+      request.markAsValidating();
+
+      expect(request.status).toBe('validating');
+    });
+
+    it('transitions from validating to generating', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+      });
+      request.markAsValidating();
+
+      request.markAsGenerating();
+
+      expect(request.status).toBe('generating');
+    });
+
+    it('throws error when marking as validating from non-pending status', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+      });
+      request.markAsValidating();
+
+      expect(() => request.markAsValidating()).toThrow('Can only start validation from pending status');
+    });
+
+    it('throws error when marking as generating from non-validating status', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+      });
+
+      expect(() => request.markAsGenerating()).toThrow('Can only start generation from validating status');
+    });
+
+    it('completes request with avatars', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+      });
+      request.markAsValidating();
+      request.markAsGenerating();
+
+      request.completeWithAvatars(['https://example.com/a.png', 'https://example.com/b.png']);
+
+      expect(request.status).toBe('completed');
+      expect(request.generatedAvatarUrls).toEqual(['https://example.com/a.png', 'https://example.com/b.png']);
+    });
+
+    it('throws error when completing with empty avatar list', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+      });
+      request.markAsValidating();
+      request.markAsGenerating();
+
+      expect(() => request.completeWithAvatars([])).toThrow('At least one avatar URL is required');
+    });
+
+    it('fails request with error message', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+      });
+      request.markAsValidating();
+
+      request.fail('Face validation failed');
+
+      expect(request.status).toBe('failed');
+      expect(request.errorMessage).toBe('Face validation failed');
+    });
+  });
+
+  describe('avatar selection', () => {
+    it('selects avatar when request is completed', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+      });
+      request.markAsValidating();
+      request.markAsGenerating();
+      request.completeWithAvatars(['https://example.com/a.png', 'https://example.com/b.png']);
+
+      request.selectAvatar(1);
+
+      expect(request.selectedAvatarIndex).toBe(1);
+      expect(request.selectedAvatarUrl).toBe('https://example.com/b.png');
+    });
+
+    it('throws error when selecting avatar from non-completed request', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+      });
+      request.markAsValidating();
+
+      expect(() => request.selectAvatar(0)).toThrow('Can only select avatar when generation is completed');
+    });
+
+    it('throws error when selecting invalid index', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+      });
+      request.markAsValidating();
+      request.markAsGenerating();
+      request.completeWithAvatars(['https://example.com/a.png', 'https://example.com/b.png']);
+
+      expect(() => request.selectAvatar(-1)).toThrow('Invalid avatar index');
+      expect(() => request.selectAvatar(2)).toThrow('Invalid avatar index');
+    });
+
+    it('returns undefined for selectedAvatarUrl when no avatar selected', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+      });
+      request.markAsValidating();
+      request.markAsGenerating();
+      request.completeWithAvatars(['https://example.com/a.png', 'https://example.com/b.png']);
+
+      expect(request.selectedAvatarUrl).toBeUndefined();
+    });
+  });
+
+  describe('buildPrompt', () => {
+    it('builds prompt for red suit, realistic style', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+        style: 'realistic',
+      });
+
+      const prompt = request.buildPrompt();
+
+      expect(prompt).toContain('vibrant racing red');
+      expect(prompt).toContain('photorealistic, professional motorsport portrait');
+      expect(prompt).toContain('racing driver');
+      expect(prompt).toContain('racing suit');
+      expect(prompt).toContain('helmet');
+    });
+
+    it('builds prompt for blue suit, cartoon style', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'blue',
+        style: 'cartoon',
+      });
+
+      const prompt = request.buildPrompt();
+
+      expect(prompt).toContain('deep motorsport blue');
+      expect(prompt).toContain('stylized cartoon racing character');
+    });
+
+    it('builds prompt for pixel-art style', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'green',
+        style: 'pixel-art',
+      });
+
+      const prompt = request.buildPrompt();
+
+      expect(prompt).toContain('racing green');
+      expect(prompt).toContain('8-bit pixel art retro racing avatar');
+    });
+
+    it('builds prompt for all suit colors', () => {
+      const colors = ['red', 'blue', 'green', 'yellow', 'orange', 'purple', 'black', 'white', 'pink', 'cyan'] as const;
+
+      colors.forEach((color) => {
+        const request = AvatarGenerationRequest.create({
+          id: 'req-1',
+          userId: 'user-1',
+          facePhotoUrl: 'data:image/png;base64,abc',
+          suitColor: color,
+        });
+
+        const prompt = request.buildPrompt();
+
+        expect(prompt).toContain(color);
+      });
+    });
+  });
+
+  describe('toProps', () => {
+    it('returns correct props for a new request', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+        style: 'realistic',
+      });
+
+      const props = request.toProps();
+
+      expect(props.id).toBe('req-1');
+      expect(props.userId).toBe('user-1');
+      expect(props.facePhotoUrl).toBe('data:image/png;base64,abc');
+      expect(props.suitColor).toBe('red');
+      expect(props.style).toBe('realistic');
+      expect(props.status).toBe('pending');
+      expect(props.generatedAvatarUrls).toEqual([]);
+      expect(props.selectedAvatarIndex).toBeUndefined();
+      expect(props.errorMessage).toBeUndefined();
+      expect(props.createdAt).toBeInstanceOf(Date);
+      expect(props.updatedAt).toBeInstanceOf(Date);
+    });
+
+    it('returns correct props for a completed request with selected avatar', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+        style: 'realistic',
+      });
+      request.markAsValidating();
+      request.markAsGenerating();
+      request.completeWithAvatars(['https://example.com/a.png', 'https://example.com/b.png']);
+      request.selectAvatar(1);
+
+      const props = request.toProps();
+
+      expect(props.id).toBe('req-1');
+      expect(props.userId).toBe('user-1');
+      expect(props.facePhotoUrl).toBe('data:image/png;base64,abc');
+      expect(props.suitColor).toBe('red');
+      expect(props.style).toBe('realistic');
+      expect(props.status).toBe('completed');
+      expect(props.generatedAvatarUrls).toEqual(['https://example.com/a.png', 'https://example.com/b.png']);
+      expect(props.selectedAvatarIndex).toBe(1);
+      expect(props.errorMessage).toBeUndefined();
+    });
+
+    it('returns correct props for a failed request', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+        style: 'realistic',
+      });
+      request.markAsValidating();
+      request.fail('Face validation failed');
+
+      const props = request.toProps();
+
+      expect(props.id).toBe('req-1');
+      expect(props.userId).toBe('user-1');
+      expect(props.facePhotoUrl).toBe('data:image/png;base64,abc');
+      expect(props.suitColor).toBe('red');
+      expect(props.style).toBe('realistic');
+      expect(props.status).toBe('failed');
+      expect(props.generatedAvatarUrls).toEqual([]);
+      expect(props.selectedAvatarIndex).toBeUndefined();
+      expect(props.errorMessage).toBe('Face validation failed');
+    });
+  });
+
+  describe('value object validation', () => {
+    it('validates facePhotoUrl as MediaUrl value object', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'data:image/png;base64,abc',
+        suitColor: 'red',
+      });
+
+      expect(request.facePhotoUrl).toBeInstanceOf(MediaUrl);
+      expect(request.facePhotoUrl.value).toBe('data:image/png;base64,abc');
+    });
+
+    it('accepts http URL for facePhotoUrl', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: 'https://example.com/face.png',
+        suitColor: 'red',
+      });
+
+      expect(request.facePhotoUrl.value).toBe('https://example.com/face.png');
+    });
+
+    it('accepts root-relative path for facePhotoUrl', () => {
+      const request = AvatarGenerationRequest.create({
+        id: 'req-1',
+        userId: 'user-1',
+        facePhotoUrl: '/images/face.png',
+        suitColor: 'red',
+      });
+
+      expect(request.facePhotoUrl.value).toBe('/images/face.png');
+    });
   });
 });

core/media/domain/entities/Media.test.ts

@@ -1,7 +1,307 @@
-import * as mod from '@core/media/domain/entities/Media';
+import { Media } from './Media';
+import { MediaUrl } from '../value-objects/MediaUrl';
 
-describe('media/domain/entities/Media.ts', () => {
-  it('imports', () => {
-    expect(mod).toBeTruthy();
+describe('Media', () => {
+  describe('create', () => {
+    it('creates a new media with required properties', () => {
+      const media = Media.create({
+        id: 'media-1',
+        filename: 'avatar.png',
+        originalName: 'avatar.png',
+        mimeType: 'image/png',
+        size: 123,
+        url: 'https://example.com/avatar.png',
+        type: 'image',
+        uploadedBy: 'user-1',
+      });
+
+      expect(media.id).toBe('media-1');
+      expect(media.filename).toBe('avatar.png');
+      expect(media.originalName).toBe('avatar.png');
+      expect(media.mimeType).toBe('image/png');
+      expect(media.size).toBe(123);
+      expect(media.url).toBeInstanceOf(MediaUrl);
+      expect(media.url.value).toBe('https://example.com/avatar.png');
+      expect(media.type).toBe('image');
+      expect(media.uploadedBy).toBe('user-1');
+      expect(media.uploadedAt).toBeInstanceOf(Date);
+      expect(media.metadata).toBeUndefined();
+    });
+
+    it('creates media with metadata', () => {
+      const media = Media.create({
+        id: 'media-1',
+        filename: 'avatar.png',
+        originalName: 'avatar.png',
+        mimeType: 'image/png',
+        size: 123,
+        url: 'https://example.com/avatar.png',
+        type: 'image',
+        uploadedBy: 'user-1',
+        metadata: { width: 100, height: 100 },
+      });
+
+      expect(media.metadata).toEqual({ width: 100, height: 100 });
+    });
+
+    it('throws error when filename is missing', () => {
+      expect(() =>
+        Media.create({
+          id: 'media-1',
+          filename: '',
+          originalName: 'avatar.png',
+          mimeType: 'image/png',
+          size: 123,
+          url: 'https://example.com/avatar.png',
+          type: 'image',
+          uploadedBy: 'user-1',
+        })
+      ).toThrow('Filename is required');
+    });
+
+    it('throws error when url is missing', () => {
+      expect(() =>
+        Media.create({
+          id: 'media-1',
+          filename: 'avatar.png',
+          originalName: 'avatar.png',
+          mimeType: 'image/png',
+          size: 123,
+          url: '',
+          type: 'image',
+          uploadedBy: 'user-1',
+        })
+      ).toThrow('URL is required');
+    });
+
+    it('throws error when uploadedBy is missing', () => {
+      expect(() =>
+        Media.create({
+          id: 'media-1',
+          filename: 'avatar.png',
+          originalName: 'avatar.png',
+          mimeType: 'image/png',
+          size: 123,
+          url: 'https://example.com/avatar.png',
+          type: 'image',
+          uploadedBy: '',
+        })
+      ).toThrow('Uploaded by is required');
+    });
+
+    it('throws error when url is invalid', () => {
+      expect(() =>
+        Media.create({
+          id: 'media-1',
+          filename: 'avatar.png',
+          originalName: 'avatar.png',
+          mimeType: 'image/png',
+          size: 123,
+          url: 'invalid-url',
+          type: 'image',
+          uploadedBy: 'user-1',
+        })
+      ).toThrow();
+    });
+  });
+
+  describe('reconstitute', () => {
+    it('reconstitutes a media from props', () => {
+      const uploadedAt = new Date('2024-01-01T00:00:00.000Z');
+      const media = Media.reconstitute({
+        id: 'media-1',
+        filename: 'avatar.png',
+        originalName: 'avatar.png',
+        mimeType: 'image/png',
+        size: 123,
+        url: 'https://example.com/avatar.png',
+        type: 'image',
+        uploadedBy: 'user-1',
+        uploadedAt,
+      });
+
+      expect(media.id).toBe('media-1');
+      expect(media.filename).toBe('avatar.png');
+      expect(media.originalName).toBe('avatar.png');
+      expect(media.mimeType).toBe('image/png');
+      expect(media.size).toBe(123);
+      expect(media.url.value).toBe('https://example.com/avatar.png');
+      expect(media.type).toBe('image');
+      expect(media.uploadedBy).toBe('user-1');
+      expect(media.uploadedAt).toEqual(uploadedAt);
+      expect(media.metadata).toBeUndefined();
+    });
+
+    it('reconstitutes a media with metadata', () => {
+      const media = Media.reconstitute({
+        id: 'media-1',
+        filename: 'avatar.png',
+        originalName: 'avatar.png',
+        mimeType: 'image/png',
+        size: 123,
+        url: 'https://example.com/avatar.png',
+        type: 'image',
+        uploadedBy: 'user-1',
+        uploadedAt: new Date(),
+        metadata: { width: 100, height: 100 },
+      });
+
+      expect(media.metadata).toEqual({ width: 100, height: 100 });
+    });
+
+    it('reconstitutes a video media', () => {
+      const media = Media.reconstitute({
+        id: 'media-1',
+        filename: 'video.mp4',
+        originalName: 'video.mp4',
+        mimeType: 'video/mp4',
+        size: 1024,
+        url: 'https://example.com/video.mp4',
+        type: 'video',
+        uploadedBy: 'user-1',
+        uploadedAt: new Date(),
+      });
+
+      expect(media.type).toBe('video');
+    });
+
+    it('reconstitutes a document media', () => {
+      const media = Media.reconstitute({
+        id: 'media-1',
+        filename: 'document.pdf',
+        originalName: 'document.pdf',
+        mimeType: 'application/pdf',
+        size: 2048,
+        url: 'https://example.com/document.pdf',
+        type: 'document',
+        uploadedBy: 'user-1',
+        uploadedAt: new Date(),
+      });
+
+      expect(media.type).toBe('document');
+    });
+  });
+
+  describe('toProps', () => {
+    it('returns correct props for a new media', () => {
+      const media = Media.create({
+        id: 'media-1',
+        filename: 'avatar.png',
+        originalName: 'avatar.png',
+        mimeType: 'image/png',
+        size: 123,
+        url: 'https://example.com/avatar.png',
+        type: 'image',
+        uploadedBy: 'user-1',
+      });
+
+      const props = media.toProps();
+
+      expect(props.id).toBe('media-1');
+      expect(props.filename).toBe('avatar.png');
+      expect(props.originalName).toBe('avatar.png');
+      expect(props.mimeType).toBe('image/png');
+      expect(props.size).toBe(123);
+      expect(props.url).toBe('https://example.com/avatar.png');
+      expect(props.type).toBe('image');
+      expect(props.uploadedBy).toBe('user-1');
+      expect(props.uploadedAt).toBeInstanceOf(Date);
+      expect(props.metadata).toBeUndefined();
+    });
+
+    it('returns correct props for a media with metadata', () => {
+      const media = Media.create({
+        id: 'media-1',
+        filename: 'avatar.png',
+        originalName: 'avatar.png',
+        mimeType: 'image/png',
+        size: 123,
+        url: 'https://example.com/avatar.png',
+        type: 'image',
+        uploadedBy: 'user-1',
+        metadata: { width: 100, height: 100 },
+      });
+
+      const props = media.toProps();
+
+      expect(props.metadata).toEqual({ width: 100, height: 100 });
+    });
+
+    it('returns correct props for a reconstituted media', () => {
+      const uploadedAt = new Date('2024-01-01T00:00:00.000Z');
+      const media = Media.reconstitute({
+        id: 'media-1',
+        filename: 'avatar.png',
+        originalName: 'avatar.png',
+        mimeType: 'image/png',
+        size: 123,
+        url: 'https://example.com/avatar.png',
+        type: 'image',
+        uploadedBy: 'user-1',
+        uploadedAt,
+        metadata: { width: 100, height: 100 },
+      });
+
+      const props = media.toProps();
+
+      expect(props.id).toBe('media-1');
+      expect(props.filename).toBe('avatar.png');
+      expect(props.originalName).toBe('avatar.png');
+      expect(props.mimeType).toBe('image/png');
+      expect(props.size).toBe(123);
+      expect(props.url).toBe('https://example.com/avatar.png');
+      expect(props.type).toBe('image');
+      expect(props.uploadedBy).toBe('user-1');
+      expect(props.uploadedAt).toEqual(uploadedAt);
+      expect(props.metadata).toEqual({ width: 100, height: 100 });
+    });
+  });
+
+  describe('value object validation', () => {
+    it('validates url as MediaUrl value object', () => {
+      const media = Media.create({
+        id: 'media-1',
+        filename: 'avatar.png',
+        originalName: 'avatar.png',
+        mimeType: 'image/png',
+        size: 123,
+        url: 'https://example.com/avatar.png',
+        type: 'image',
+        uploadedBy: 'user-1',
+      });
+
+      expect(media.url).toBeInstanceOf(MediaUrl);
+      expect(media.url.value).toBe('https://example.com/avatar.png');
+    });
+
+    it('accepts data URI for url', () => {
+      const media = Media.create({
+        id: 'media-1',
+        filename: 'avatar.png',
+        originalName: 'avatar.png',
+        mimeType: 'image/png',
+        size: 123,
+        url: 'data:image/png;base64,abc',
+        type: 'image',
+        uploadedBy: 'user-1',
+      });
+
+      expect(media.url.value).toBe('data:image/png;base64,abc');
+    });
+
+    it('accepts root-relative path for url', () => {
+      const media = Media.create({
+        id: 'media-1',
+        filename: 'avatar.png',
+        originalName: 'avatar.png',
+        mimeType: 'image/png',
+        size: 123,
+        url: '/images/avatar.png',
+        type: 'image',
+        uploadedBy: 'user-1',
+      });
+
+      expect(media.url.value).toBe('/images/avatar.png');
+    });
   });
 });

core/media/domain/services/MediaGenerationService.test.ts

@@ -0,0 +1,223 @@
+import { MediaGenerationService } from './MediaGenerationService';
+
+describe('MediaGenerationService', () => {
+  let service: MediaGenerationService;
+
+  beforeEach(() => {
+    service = new MediaGenerationService();
+  });
+
+  describe('generateTeamLogo', () => {
+    it('generates a deterministic logo URL for a team', () => {
+      const url1 = service.generateTeamLogo('team-123');
+      const url2 = service.generateTeamLogo('team-123');
+
+      expect(url1).toBe(url2);
+      expect(url1).toContain('https://picsum.photos/seed/team-123/200/200');
+    });
+
+    it('generates different URLs for different team IDs', () => {
+      const url1 = service.generateTeamLogo('team-123');
+      const url2 = service.generateTeamLogo('team-456');
+
+      expect(url1).not.toBe(url2);
+    });
+
+    it('generates URL with correct format', () => {
+      const url = service.generateTeamLogo('team-123');
+
+      expect(url).toMatch(/^https:\/\/picsum\.photos\/seed\/team-123\/200\/200$/);
+    });
+  });
+
+  describe('generateLeagueLogo', () => {
+    it('generates a deterministic logo URL for a league', () => {
+      const url1 = service.generateLeagueLogo('league-123');
+      const url2 = service.generateLeagueLogo('league-123');
+
+      expect(url1).toBe(url2);
+      expect(url1).toContain('https://picsum.photos/seed/l-league-123/200/200');
+    });
+
+    it('generates different URLs for different league IDs', () => {
+      const url1 = service.generateLeagueLogo('league-123');
+      const url2 = service.generateLeagueLogo('league-456');
+
+      expect(url1).not.toBe(url2);
+    });
+
+    it('generates URL with correct format', () => {
+      const url = service.generateLeagueLogo('league-123');
+
+      expect(url).toMatch(/^https:\/\/picsum\.photos\/seed\/l-league-123\/200\/200$/);
+    });
+  });
+
+  describe('generateDriverAvatar', () => {
+    it('generates a deterministic avatar URL for a driver', () => {
+      const url1 = service.generateDriverAvatar('driver-123');
+      const url2 = service.generateDriverAvatar('driver-123');
+
+      expect(url1).toBe(url2);
+      expect(url1).toContain('https://i.pravatar.cc/150?u=driver-123');
+    });
+
+    it('generates different URLs for different driver IDs', () => {
+      const url1 = service.generateDriverAvatar('driver-123');
+      const url2 = service.generateDriverAvatar('driver-456');
+
+      expect(url1).not.toBe(url2);
+    });
+
+    it('generates URL with correct format', () => {
+      const url = service.generateDriverAvatar('driver-123');
+
+      expect(url).toMatch(/^https:\/\/i\.pravatar\.cc\/150\?u=driver-123$/);
+    });
+  });
+
+  describe('generateLeagueCover', () => {
+    it('generates a deterministic cover URL for a league', () => {
+      const url1 = service.generateLeagueCover('league-123');
+      const url2 = service.generateLeagueCover('league-123');
+
+      expect(url1).toBe(url2);
+      expect(url1).toContain('https://picsum.photos/seed/c-league-123/800/200');
+    });
+
+    it('generates different URLs for different league IDs', () => {
+      const url1 = service.generateLeagueCover('league-123');
+      const url2 = service.generateLeagueCover('league-456');
+
+      expect(url1).not.toBe(url2);
+    });
+
+    it('generates URL with correct format', () => {
+      const url = service.generateLeagueCover('league-123');
+
+      expect(url).toMatch(/^https:\/\/picsum\.photos\/seed\/c-league-123\/800\/200$/);
+    });
+  });
+
+  describe('generateDefaultPNG', () => {
+    it('generates a PNG buffer for a variant', () => {
+      const buffer = service.generateDefaultPNG('test-variant');
+
+      expect(buffer).toBeInstanceOf(Buffer);
+      expect(buffer.length).toBeGreaterThan(0);
+    });
+
+    it('generates deterministic PNG for same variant', () => {
+      const buffer1 = service.generateDefaultPNG('test-variant');
+      const buffer2 = service.generateDefaultPNG('test-variant');
+
+      expect(buffer1.equals(buffer2)).toBe(true);
+    });
+
+    it('generates different PNGs for different variants', () => {
+      const buffer1 = service.generateDefaultPNG('variant-1');
+      const buffer2 = service.generateDefaultPNG('variant-2');
+
+      expect(buffer1.equals(buffer2)).toBe(false);
+    });
+
+    it('generates valid PNG header', () => {
+      const buffer = service.generateDefaultPNG('test-variant');
+
+      // PNG signature: 89 50 4E 47 0D 0A 1A 0A
+      expect(buffer[0]).toBe(0x89);
+      expect(buffer[1]).toBe(0x50); // 'P'
+      expect(buffer[2]).toBe(0x4E); // 'N'
+      expect(buffer[3]).toBe(0x47); // 'G'
+      expect(buffer[4]).toBe(0x0D);
+      expect(buffer[5]).toBe(0x0A);
+      expect(buffer[6]).toBe(0x1A);
+      expect(buffer[7]).toBe(0x0A);
+    });
+
+    it('generates PNG with IHDR chunk', () => {
+      const buffer = service.generateDefaultPNG('test-variant');
+
+      // IHDR chunk starts at byte 8
+      // Length: 13 (0x00 0x00 0x00 0x0D)
+      expect(buffer[8]).toBe(0x00);
+      expect(buffer[9]).toBe(0x00);
+      expect(buffer[10]).toBe(0x00);
+      expect(buffer[11]).toBe(0x0D);
+      // Type: IHDR (0x49 0x48 0x44 0x52)
+      expect(buffer[12]).toBe(0x49); // 'I'
+      expect(buffer[13]).toBe(0x48); // 'H'
+      expect(buffer[14]).toBe(0x44); // 'D'
+      expect(buffer[15]).toBe(0x52); // 'R'
+    });
+
+    it('generates PNG with 1x1 dimensions', () => {
+      const buffer = service.generateDefaultPNG('test-variant');
+
+      // Width: 1 (0x00 0x00 0x00 0x01) at byte 16
+      expect(buffer[16]).toBe(0x00);
+      expect(buffer[17]).toBe(0x00);
+      expect(buffer[18]).toBe(0x00);
+      expect(buffer[19]).toBe(0x01);
+      // Height: 1 (0x00 0x00 0x00 0x01) at byte 20
+      expect(buffer[20]).toBe(0x00);
+      expect(buffer[21]).toBe(0x00);
+      expect(buffer[22]).toBe(0x00);
+      expect(buffer[23]).toBe(0x01);
+    });
+
+    it('generates PNG with RGB color type', () => {
+      const buffer = service.generateDefaultPNG('test-variant');
+
+      // Color type: RGB (0x02) at byte 25
+      expect(buffer[25]).toBe(0x02);
+    });
+
+    it('generates PNG with RGB pixel data', () => {
+      const buffer = service.generateDefaultPNG('test-variant');
+
+      // RGB pixel data should be present in IDAT chunk
+      // IDAT chunk starts after IHDR (byte 37)
+      // We should find RGB values somewhere in the buffer
+      const hasRGB = buffer.some((byte, index) => {
+        // Check if we have a sequence that looks like RGB data
+        // This is a simplified check
+        return index > 37 && index < buffer.length - 10;
+      });
+
+      expect(hasRGB).toBe(true);
+    });
+  });
+
+  describe('deterministic generation', () => {
+    it('generates same team logo for same team ID across different instances', () => {
+      const service1 = new MediaGenerationService();
+      const service2 = new MediaGenerationService();
+
+      const url1 = service1.generateTeamLogo('team-123');
+      const url2 = service2.generateTeamLogo('team-123');
+
+      expect(url1).toBe(url2);
+    });
+
+    it('generates same driver avatar for same driver ID across different instances', () => {
+      const service1 = new MediaGenerationService();
+      const service2 = new MediaGenerationService();
+
+      const url1 = service1.generateDriverAvatar('driver-123');
+      const url2 = service2.generateDriverAvatar('driver-123');
+
+      expect(url1).toBe(url2);
+    });
+
+    it('generates same PNG for same variant across different instances', () => {
+      const service1 = new MediaGenerationService();
+      const service2 = new MediaGenerationService();
+
+      const buffer1 = service1.generateDefaultPNG('test-variant');
+      const buffer2 = service2.generateDefaultPNG('test-variant');
+
+      expect(buffer1.equals(buffer2)).toBe(true);
+    });
+  });
+});

core/media/domain/value-objects/AvatarId.test.ts

@@ -1,7 +1,83 @@
-import * as mod from '@core/media/domain/value-objects/AvatarId';
+import { AvatarId } from './AvatarId';
 
-describe('media/domain/value-objects/AvatarId.ts', () => {
-  it('imports', () => {
-    expect(mod).toBeTruthy();
+describe('AvatarId', () => {
+  describe('create', () => {
+    it('creates from valid string', () => {
+      const avatarId = AvatarId.create('avatar-123');
+
+      expect(avatarId.toString()).toBe('avatar-123');
+    });
+
+    it('trims whitespace', () => {
+      const avatarId = AvatarId.create('  avatar-123  ');
+
+      expect(avatarId.toString()).toBe('avatar-123');
+    });
+
+    it('throws error when empty', () => {
+      expect(() => AvatarId.create('')).toThrow('Avatar ID cannot be empty');
+    });
+
+    it('throws error when only whitespace', () => {
+      expect(() => AvatarId.create('   ')).toThrow('Avatar ID cannot be empty');
+    });
+
+    it('throws error when null', () => {
+      expect(() => AvatarId.create(null as any)).toThrow('Avatar ID cannot be empty');
+    });
+
+    it('throws error when undefined', () => {
+      expect(() => AvatarId.create(undefined as any)).toThrow('Avatar ID cannot be empty');
+    });
+  });
+
+  describe('toString', () => {
+    it('returns the string value', () => {
+      const avatarId = AvatarId.create('avatar-123');
+
+      expect(avatarId.toString()).toBe('avatar-123');
+    });
+  });
+
+  describe('equals', () => {
+    it('returns true for equal avatar IDs', () => {
+      const avatarId1 = AvatarId.create('avatar-123');
+      const avatarId2 = AvatarId.create('avatar-123');
+
+      expect(avatarId1.equals(avatarId2)).toBe(true);
+    });
+
+    it('returns false for different avatar IDs', () => {
+      const avatarId1 = AvatarId.create('avatar-123');
+      const avatarId2 = AvatarId.create('avatar-456');
+
+      expect(avatarId1.equals(avatarId2)).toBe(false);
+    });
+
+    it('returns false for different case', () => {
+      const avatarId1 = AvatarId.create('avatar-123');
+      const avatarId2 = AvatarId.create('AVATAR-123');
+
+      expect(avatarId1.equals(avatarId2)).toBe(false);
+    });
+  });
+
+  describe('value object equality', () => {
+    it('implements value-based equality', () => {
+      const avatarId1 = AvatarId.create('avatar-123');
+      const avatarId2 = AvatarId.create('avatar-123');
+      const avatarId3 = AvatarId.create('avatar-456');
+
+      expect(avatarId1.equals(avatarId2)).toBe(true);
+      expect(avatarId1.equals(avatarId3)).toBe(false);
+    });
+
+    it('maintains equality after toString', () => {
+      const avatarId1 = AvatarId.create('avatar-123');
+      const avatarId2 = AvatarId.create('avatar-123');
+
+      expect(avatarId1.toString()).toBe(avatarId2.toString());
+      expect(avatarId1.equals(avatarId2)).toBe(true);
+    });
   });
 });

package-lock.json

@@ -256,6 +256,7 @@
       "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.27.tgz",
       "integrity": "sha512-cisd7gxkzjBKU2GgdYrTdtQx1SORymWyaAFhaxQPK9bYO9ot3Y5OikQRvY0VYQtvwjeQnizCINJAenh/V7MK2w==",
       "dev": true,
+      "license": "MIT",
       "dependencies": {
         "@types/prop-types": "*",
         "csstype": "^3.2.2"
@@ -266,6 +267,7 @@
       "resolved": "https://registry.npmjs.org/@types/react-dom/-/react-dom-18.3.7.tgz",
       "integrity": "sha512-MEe3UeoENYVFXzoXEWsvcpg6ZvlrFNlOQ7EOsvhI3CfAXwzPfO8Qwuxd40nepsYKqyyVQnTdEfv68q91yLcKrQ==",
       "dev": true,
+      "license": "MIT",
       "peerDependencies": {
         "@types/react": "^18.0.0"
       }
@@ -4740,7 +4742,8 @@
       "version": "15.7.15",
       "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
       "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==",
-      "dev": true
+      "dev": true,
+      "license": "MIT"
     },
     "node_modules/@types/qs": {
       "version": "6.14.0",

tests/contracts/admin-contract.test.ts

@@ -1,923 +0,0 @@
-/**
- * Contract Validation Tests for Admin Module
- * 
- * These tests validate that the admin API DTOs and OpenAPI spec are consistent
- * and that the generated types will be compatible with the website admin client.
- */
-
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { describe, expect, it } from 'vitest';
-
-interface OpenAPISchema {
-  type?: string;
-  format?: string;
-  $ref?: string;
-  items?: OpenAPISchema;
-  properties?: Record<string, OpenAPISchema>;
-  required?: string[];
-  enum?: string[];
-  nullable?: boolean;
-  description?: string;
-  default?: unknown;
-}
-
-interface OpenAPISpec {
-  openapi: string;
-  info: {
-    title: string;
-    description: string;
-    version: string;
-  };
-  paths: Record<string, any>;
-  components: {
-    schemas: Record<string, OpenAPISchema>;
-  };
-}
-
-describe('Admin Module Contract Validation', () => {
-  const apiRoot = path.join(__dirname, '../..');
-  const openapiPath = path.join(apiRoot, 'apps/api/openapi.json');
-  const generatedTypesDir = path.join(apiRoot, 'apps/website/lib/types/generated');
-  const websiteTypesDir = path.join(apiRoot, 'apps/website/lib/types');
-
-  describe('OpenAPI Spec Integrity for Admin Endpoints', () => {
-    it('should have admin endpoints defined in OpenAPI spec', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      // Check for admin endpoints
-      expect(spec.paths['/admin/users']).toBeDefined();
-      expect(spec.paths['/admin/dashboard/stats']).toBeDefined();
-
-      // Verify GET methods exist
-      expect(spec.paths['/admin/users'].get).toBeDefined();
-      expect(spec.paths['/admin/dashboard/stats'].get).toBeDefined();
-    });
-
-    it('should have ListUsersRequestDto schema defined', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['ListUsersRequestDto'];
-      expect(schema).toBeDefined();
-      expect(schema.type).toBe('object');
-
-      // Verify optional query parameters
-      expect(schema.properties?.role).toBeDefined();
-      expect(schema.properties?.status).toBeDefined();
-      expect(schema.properties?.email).toBeDefined();
-      expect(schema.properties?.search).toBeDefined();
-      expect(schema.properties?.page).toBeDefined();
-      expect(schema.properties?.limit).toBeDefined();
-      expect(schema.properties?.sortBy).toBeDefined();
-      expect(schema.properties?.sortDirection).toBeDefined();
-    });
-
-    it('should have UserResponseDto schema defined', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['UserResponseDto'];
-      expect(schema).toBeDefined();
-      expect(schema.type).toBe('object');
-
-      // Verify required fields
-      expect(schema.required).toContain('id');
-      expect(schema.required).toContain('email');
-      expect(schema.required).toContain('displayName');
-      expect(schema.required).toContain('roles');
-      expect(schema.required).toContain('status');
-      expect(schema.required).toContain('isSystemAdmin');
-      expect(schema.required).toContain('createdAt');
-      expect(schema.required).toContain('updatedAt');
-
-      // Verify field types
-      expect(schema.properties?.id?.type).toBe('string');
-      expect(schema.properties?.email?.type).toBe('string');
-      expect(schema.properties?.displayName?.type).toBe('string');
-      expect(schema.properties?.roles?.type).toBe('array');
-      expect(schema.properties?.status?.type).toBe('string');
-      expect(schema.properties?.isSystemAdmin?.type).toBe('boolean');
-      expect(schema.properties?.createdAt?.type).toBe('string');
-      expect(schema.properties?.updatedAt?.type).toBe('string');
-
-      // Verify optional fields
-      expect(schema.properties?.lastLoginAt).toBeDefined();
-      expect(schema.properties?.lastLoginAt?.nullable).toBe(true);
-      expect(schema.properties?.primaryDriverId).toBeDefined();
-      expect(schema.properties?.primaryDriverId?.nullable).toBe(true);
-    });
-
-    it('should have UserListResponseDto schema defined', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['UserListResponseDto'];
-      expect(schema).toBeDefined();
-      expect(schema.type).toBe('object');
-
-      // Verify required fields
-      expect(schema.required).toContain('users');
-      expect(schema.required).toContain('total');
-      expect(schema.required).toContain('page');
-      expect(schema.required).toContain('limit');
-      expect(schema.required).toContain('totalPages');
-
-      // Verify field types
-      expect(schema.properties?.users?.type).toBe('array');
-      expect(schema.properties?.users?.items?.$ref).toBe('#/components/schemas/UserResponseDto');
-      expect(schema.properties?.total?.type).toBe('number');
-      expect(schema.properties?.page?.type).toBe('number');
-      expect(schema.properties?.limit?.type).toBe('number');
-      expect(schema.properties?.totalPages?.type).toBe('number');
-    });
-
-    it('should have DashboardStatsResponseDto schema defined', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['DashboardStatsResponseDto'];
-      expect(schema).toBeDefined();
-      expect(schema.type).toBe('object');
-
-      // Verify required fields
-      expect(schema.required).toContain('totalUsers');
-      expect(schema.required).toContain('activeUsers');
-      expect(schema.required).toContain('suspendedUsers');
-      expect(schema.required).toContain('deletedUsers');
-      expect(schema.required).toContain('systemAdmins');
-      expect(schema.required).toContain('recentLogins');
-      expect(schema.required).toContain('newUsersToday');
-      expect(schema.required).toContain('userGrowth');
-      expect(schema.required).toContain('roleDistribution');
-      expect(schema.required).toContain('statusDistribution');
-      expect(schema.required).toContain('activityTimeline');
-
-      // Verify field types
-      expect(schema.properties?.totalUsers?.type).toBe('number');
-      expect(schema.properties?.activeUsers?.type).toBe('number');
-      expect(schema.properties?.suspendedUsers?.type).toBe('number');
-      expect(schema.properties?.deletedUsers?.type).toBe('number');
-      expect(schema.properties?.systemAdmins?.type).toBe('number');
-      expect(schema.properties?.recentLogins?.type).toBe('number');
-      expect(schema.properties?.newUsersToday?.type).toBe('number');
-
-      // Verify nested objects
-      expect(schema.properties?.userGrowth?.type).toBe('array');
-      expect(schema.properties?.roleDistribution?.type).toBe('array');
-      expect(schema.properties?.statusDistribution?.type).toBe('object');
-      expect(schema.properties?.activityTimeline?.type).toBe('array');
-    });
-
-    it('should have proper query parameter validation in OpenAPI', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const listUsersPath = spec.paths['/admin/users']?.get;
-      expect(listUsersPath).toBeDefined();
-
-      // Verify query parameters are documented
-      const params = listUsersPath.parameters || [];
-      const paramNames = params.map((p: any) => p.name);
-
-      // These should be query parameters based on the DTO
-      expect(paramNames).toContain('role');
-      expect(paramNames).toContain('status');
-      expect(paramNames).toContain('email');
-      expect(paramNames).toContain('search');
-      expect(paramNames).toContain('page');
-      expect(paramNames).toContain('limit');
-      expect(paramNames).toContain('sortBy');
-      expect(paramNames).toContain('sortDirection');
-    });
-  });
-
-  describe('DTO Consistency', () => {
-    it('should have generated DTO files for admin schemas', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const generatedFiles = await fs.readdir(generatedTypesDir);
-      const generatedDTOs = generatedFiles
-        .filter(f => f.endsWith('.ts'))
-        .map(f => f.replace('.ts', ''));
-
-      // Check for admin-related DTOs
-      const adminDTOs = [
-        'ListUsersRequestDto',
-        'UserResponseDto',
-        'UserListResponseDto',
-        'DashboardStatsResponseDto',
-      ];
-
-      for (const dtoName of adminDTOs) {
-        expect(spec.components.schemas[dtoName]).toBeDefined();
-        expect(generatedDTOs).toContain(dtoName);
-      }
-    });
-
-    it('should have consistent property types between DTOs and schemas', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-      const schemas = spec.components.schemas;
-
-      // Test ListUsersRequestDto
-      const listUsersSchema = schemas['ListUsersRequestDto'];
-      const listUsersDtoPath = path.join(generatedTypesDir, 'ListUsersRequestDto.ts');
-      const listUsersDtoExists = await fs.access(listUsersDtoPath).then(() => true).catch(() => false);
-      
-      if (listUsersDtoExists) {
-        const listUsersDtoContent = await fs.readFile(listUsersDtoPath, 'utf-8');
-        
-        // Check that all properties are present
-        if (listUsersSchema.properties) {
-          for (const propName of Object.keys(listUsersSchema.properties)) {
-            expect(listUsersDtoContent).toContain(propName);
-          }
-        }
-      }
-
-      // Test UserResponseDto
-      const userSchema = schemas['UserResponseDto'];
-      const userDtoPath = path.join(generatedTypesDir, 'UserResponseDto.ts');
-      const userDtoExists = await fs.access(userDtoPath).then(() => true).catch(() => false);
-      
-      if (userDtoExists) {
-        const userDtoContent = await fs.readFile(userDtoPath, 'utf-8');
-        
-        // Check that all required properties are present
-        if (userSchema.required) {
-          for (const requiredProp of userSchema.required) {
-            expect(userDtoContent).toContain(requiredProp);
-          }
-        }
-        
-        // Check that all properties are present
-        if (userSchema.properties) {
-          for (const propName of Object.keys(userSchema.properties)) {
-            expect(userDtoContent).toContain(propName);
-          }
-        }
-      }
-
-      // Test UserListResponseDto
-      const userListSchema = schemas['UserListResponseDto'];
-      const userListDtoPath = path.join(generatedTypesDir, 'UserListResponseDto.ts');
-      const userListDtoExists = await fs.access(userListDtoPath).then(() => true).catch(() => false);
-      
-      if (userListDtoExists) {
-        const userListDtoContent = await fs.readFile(userListDtoPath, 'utf-8');
-        
-        // Check that all required properties are present
-        if (userListSchema.required) {
-          for (const requiredProp of userListSchema.required) {
-            expect(userListDtoContent).toContain(requiredProp);
-          }
-        }
-      }
-
-      // Test DashboardStatsResponseDto
-      const dashboardSchema = schemas['DashboardStatsResponseDto'];
-      const dashboardDtoPath = path.join(generatedTypesDir, 'DashboardStatsResponseDto.ts');
-      const dashboardDtoExists = await fs.access(dashboardDtoPath).then(() => true).catch(() => false);
-      
-      if (dashboardDtoExists) {
-        const dashboardDtoContent = await fs.readFile(dashboardDtoPath, 'utf-8');
-        
-        // Check that all required properties are present
-        if (dashboardSchema.required) {
-          for (const requiredProp of dashboardSchema.required) {
-            expect(dashboardDtoContent).toContain(requiredProp);
-          }
-        }
-      }
-    });
-
-    it('should have TBD admin types defined', async () => {
-      const adminTypesPath = path.join(websiteTypesDir, 'tbd', 'AdminUserDto.ts');
-      const adminTypesExists = await fs.access(adminTypesPath).then(() => true).catch(() => false);
-      
-      expect(adminTypesExists).toBe(true);
-
-      const adminTypesContent = await fs.readFile(adminTypesPath, 'utf-8');
-
-      // Verify UserDto interface
-      expect(adminTypesContent).toContain('export interface AdminUserDto');
-      expect(adminTypesContent).toContain('id: string');
-      expect(adminTypesContent).toContain('email: string');
-      expect(adminTypesContent).toContain('displayName: string');
-      expect(adminTypesContent).toContain('roles: string[]');
-      expect(adminTypesContent).toContain('status: string');
-      expect(adminTypesContent).toContain('isSystemAdmin: boolean');
-      expect(adminTypesContent).toContain('createdAt: string');
-      expect(adminTypesContent).toContain('updatedAt: string');
-      expect(adminTypesContent).toContain('lastLoginAt?: string');
-      expect(adminTypesContent).toContain('primaryDriverId?: string');
-
-      // Verify UserListResponse interface
-      expect(adminTypesContent).toContain('export interface AdminUserListResponseDto');
-      expect(adminTypesContent).toContain('users: AdminUserDto[]');
-      expect(adminTypesContent).toContain('total: number');
-      expect(adminTypesContent).toContain('page: number');
-      expect(adminTypesContent).toContain('limit: number');
-      expect(adminTypesContent).toContain('totalPages: number');
-
-      // Verify DashboardStats interface
-      expect(adminTypesContent).toContain('export interface AdminDashboardStatsDto');
-      expect(adminTypesContent).toContain('totalUsers: number');
-      expect(adminTypesContent).toContain('activeUsers: number');
-      expect(adminTypesContent).toContain('suspendedUsers: number');
-      expect(adminTypesContent).toContain('deletedUsers: number');
-      expect(adminTypesContent).toContain('systemAdmins: number');
-      expect(adminTypesContent).toContain('recentLogins: number');
-      expect(adminTypesContent).toContain('newUsersToday: number');
-
-      // Verify ListUsersQuery interface
-      expect(adminTypesContent).toContain('export interface AdminListUsersQueryDto');
-      expect(adminTypesContent).toContain('role?: string');
-      expect(adminTypesContent).toContain('status?: string');
-      expect(adminTypesContent).toContain('email?: string');
-      expect(adminTypesContent).toContain('search?: string');
-      expect(adminTypesContent).toContain('page?: number');
-      expect(adminTypesContent).toContain('limit?: number');
-      expect(adminTypesContent).toContain("sortBy?: 'email' | 'displayName' | 'createdAt' | 'lastLoginAt' | 'status'");
-      expect(adminTypesContent).toContain("sortDirection?: 'asc' | 'desc'");
-    });
-
-    it('should have admin types re-exported from main types file', async () => {
-      const adminTypesPath = path.join(websiteTypesDir, 'admin.ts');
-      const adminTypesExists = await fs.access(adminTypesPath).then(() => true).catch(() => false);
-      
-      expect(adminTypesExists).toBe(true);
-
-      const adminTypesContent = await fs.readFile(adminTypesPath, 'utf-8');
-
-      // Verify re-exports
-      expect(adminTypesContent).toContain('AdminUserDto as UserDto');
-      expect(adminTypesContent).toContain('AdminUserListResponseDto as UserListResponse');
-      expect(adminTypesContent).toContain('AdminListUsersQueryDto as ListUsersQuery');
-      expect(adminTypesContent).toContain('AdminDashboardStatsDto as DashboardStats');
-    });
-  });
-
-  describe('Admin API Client Contract', () => {
-    it('should have AdminApiClient defined', async () => {
-      const adminApiClientPath = path.join(apiRoot, 'apps/website/lib/api/admin/AdminApiClient.ts');
-      const adminApiClientExists = await fs.access(adminApiClientPath).then(() => true).catch(() => false);
-      
-      expect(adminApiClientExists).toBe(true);
-
-      const adminApiClientContent = await fs.readFile(adminApiClientPath, 'utf-8');
-
-      // Verify class definition
-      expect(adminApiClientContent).toContain('export class AdminApiClient');
-      expect(adminApiClientContent).toContain('extends BaseApiClient');
-
-      // Verify methods exist
-      expect(adminApiClientContent).toContain('async listUsers');
-      expect(adminApiClientContent).toContain('async getUser');
-      expect(adminApiClientContent).toContain('async updateUserRoles');
-      expect(adminApiClientContent).toContain('async updateUserStatus');
-      expect(adminApiClientContent).toContain('async deleteUser');
-      expect(adminApiClientContent).toContain('async createUser');
-      expect(adminApiClientContent).toContain('async getDashboardStats');
-
-      // Verify method signatures
-      expect(adminApiClientContent).toContain('listUsers(query: ListUsersQuery = {})');
-      expect(adminApiClientContent).toContain('getUser(userId: string)');
-      expect(adminApiClientContent).toContain('updateUserRoles(userId: string, roles: string[])');
-      expect(adminApiClientContent).toContain('updateUserStatus(userId: string, status: string)');
-      expect(adminApiClientContent).toContain('deleteUser(userId: string)');
-      expect(adminApiClientContent).toContain('createUser(userData: {');
-      expect(adminApiClientContent).toContain('getDashboardStats()');
-    });
-
-    it('should have proper request construction in listUsers method', async () => {
-      const adminApiClientPath = path.join(apiRoot, 'apps/website/lib/api/admin/AdminApiClient.ts');
-      const adminApiClientContent = await fs.readFile(adminApiClientPath, 'utf-8');
-
-      // Verify query parameter construction
-      expect(adminApiClientContent).toContain('const params = new URLSearchParams()');
-      expect(adminApiClientContent).toContain("params.append('role', query.role)");
-      expect(adminApiClientContent).toContain("params.append('status', query.status)");
-      expect(adminApiClientContent).toContain("params.append('email', query.email)");
-      expect(adminApiClientContent).toContain("params.append('search', query.search)");
-      expect(adminApiClientContent).toContain("params.append('page', query.page.toString())");
-      expect(adminApiClientContent).toContain("params.append('limit', query.limit.toString())");
-      expect(adminApiClientContent).toContain("params.append('sortBy', query.sortBy)");
-      expect(adminApiClientContent).toContain("params.append('sortDirection', query.sortDirection)");
-
-      // Verify endpoint construction
-      expect(adminApiClientContent).toContain("return this.get<UserListResponse>(`/admin/users?${params.toString()}`)");
-    });
-
-    it('should have proper request construction in createUser method', async () => {
-      const adminApiClientPath = path.join(apiRoot, 'apps/website/lib/api/admin/AdminApiClient.ts');
-      const adminApiClientContent = await fs.readFile(adminApiClientPath, 'utf-8');
-
-      // Verify POST request with userData
-      expect(adminApiClientContent).toContain("return this.post<UserDto>(`/admin/users`, userData)");
-    });
-
-    it('should have proper request construction in getDashboardStats method', async () => {
-      const adminApiClientPath = path.join(apiRoot, 'apps/website/lib/api/admin/AdminApiClient.ts');
-      const adminApiClientContent = await fs.readFile(adminApiClientPath, 'utf-8');
-
-      // Verify GET request
-      expect(adminApiClientContent).toContain("return this.get<DashboardStats>(`/admin/dashboard/stats`)");
-    });
-  });
-
-  describe('Request Correctness Tests', () => {
-    it('should validate ListUsersRequestDto query parameters', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['ListUsersRequestDto'];
-
-      // Verify all query parameters are optional (no required fields)
-      expect(schema.required).toBeUndefined();
-
-      // Verify enum values for role
-      expect(schema.properties?.role?.enum).toBeUndefined(); // No enum constraint in DTO
-
-      // Verify enum values for status
-      expect(schema.properties?.status?.enum).toBeUndefined(); // No enum constraint in DTO
-
-      // Verify enum values for sortBy
-      expect(schema.properties?.sortBy?.enum).toEqual([
-        'email',
-        'displayName',
-        'createdAt',
-        'lastLoginAt',
-        'status'
-      ]);
-
-      // Verify enum values for sortDirection
-      expect(schema.properties?.sortDirection?.enum).toEqual(['asc', 'desc']);
-      expect(schema.properties?.sortDirection?.default).toBe('asc');
-
-      // Verify numeric constraints
-      expect(schema.properties?.page?.minimum).toBe(1);
-      expect(schema.properties?.page?.default).toBe(1);
-      expect(schema.properties?.limit?.minimum).toBe(1);
-      expect(schema.properties?.limit?.maximum).toBe(100);
-      expect(schema.properties?.limit?.default).toBe(10);
-    });
-
-    it('should validate UserResponseDto field constraints', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['UserResponseDto'];
-
-      // Verify required fields
-      expect(schema.required).toContain('id');
-      expect(schema.required).toContain('email');
-      expect(schema.required).toContain('displayName');
-      expect(schema.required).toContain('roles');
-      expect(schema.required).toContain('status');
-      expect(schema.required).toContain('isSystemAdmin');
-      expect(schema.required).toContain('createdAt');
-      expect(schema.required).toContain('updatedAt');
-
-      // Verify optional fields are nullable
-      expect(schema.properties?.lastLoginAt?.nullable).toBe(true);
-      expect(schema.properties?.primaryDriverId?.nullable).toBe(true);
-
-      // Verify roles is an array
-      expect(schema.properties?.roles?.type).toBe('array');
-      expect(schema.properties?.roles?.items?.type).toBe('string');
-    });
-
-    it('should validate DashboardStatsResponseDto structure', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['DashboardStatsResponseDto'];
-
-      // Verify all required fields
-      const requiredFields = [
-        'totalUsers',
-        'activeUsers',
-        'suspendedUsers',
-        'deletedUsers',
-        'systemAdmins',
-        'recentLogins',
-        'newUsersToday',
-        'userGrowth',
-        'roleDistribution',
-        'statusDistribution',
-        'activityTimeline'
-      ];
-
-      for (const field of requiredFields) {
-        expect(schema.required).toContain(field);
-      }
-
-      // Verify nested object structures
-      expect(schema.properties?.userGrowth?.items?.$ref).toBe('#/components/schemas/UserGrowthDto');
-      expect(schema.properties?.roleDistribution?.items?.$ref).toBe('#/components/schemas/RoleDistributionDto');
-      expect(schema.properties?.statusDistribution?.$ref).toBe('#/components/schemas/StatusDistributionDto');
-      expect(schema.properties?.activityTimeline?.items?.$ref).toBe('#/components/schemas/ActivityTimelineDto');
-    });
-  });
-
-  describe('Response Handling Tests', () => {
-    it('should handle successful user list response', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const userListSchema = spec.components.schemas['UserListResponseDto'];
-      const userSchema = spec.components.schemas['UserResponseDto'];
-
-      // Verify response structure
-      expect(userListSchema.properties?.users).toBeDefined();
-      expect(userListSchema.properties?.users?.items?.$ref).toBe('#/components/schemas/UserResponseDto');
-
-      // Verify user object has all required fields
-      expect(userSchema.required).toContain('id');
-      expect(userSchema.required).toContain('email');
-      expect(userSchema.required).toContain('displayName');
-      expect(userSchema.required).toContain('roles');
-      expect(userSchema.required).toContain('status');
-      expect(userSchema.required).toContain('isSystemAdmin');
-      expect(userSchema.required).toContain('createdAt');
-      expect(userSchema.required).toContain('updatedAt');
-
-      // Verify optional fields
-      expect(userSchema.properties?.lastLoginAt).toBeDefined();
-      expect(userSchema.properties?.primaryDriverId).toBeDefined();
-    });
-
-    it('should handle successful dashboard stats response', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const dashboardSchema = spec.components.schemas['DashboardStatsResponseDto'];
-
-      // Verify all required fields are present
-      expect(dashboardSchema.required).toContain('totalUsers');
-      expect(dashboardSchema.required).toContain('activeUsers');
-      expect(dashboardSchema.required).toContain('suspendedUsers');
-      expect(dashboardSchema.required).toContain('deletedUsers');
-      expect(dashboardSchema.required).toContain('systemAdmins');
-      expect(dashboardSchema.required).toContain('recentLogins');
-      expect(dashboardSchema.required).toContain('newUsersToday');
-      expect(dashboardSchema.required).toContain('userGrowth');
-      expect(dashboardSchema.required).toContain('roleDistribution');
-      expect(dashboardSchema.required).toContain('statusDistribution');
-      expect(dashboardSchema.required).toContain('activityTimeline');
-
-      // Verify nested objects are properly typed
-      expect(dashboardSchema.properties?.userGrowth?.type).toBe('array');
-      expect(dashboardSchema.properties?.roleDistribution?.type).toBe('array');
-      expect(dashboardSchema.properties?.statusDistribution?.type).toBe('object');
-      expect(dashboardSchema.properties?.activityTimeline?.type).toBe('array');
-    });
-
-    it('should handle optional fields in user response', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const userSchema = spec.components.schemas['UserResponseDto'];
-
-      // Verify optional fields are nullable
-      expect(userSchema.properties?.lastLoginAt?.nullable).toBe(true);
-      expect(userSchema.properties?.primaryDriverId?.nullable).toBe(true);
-
-      // Verify optional fields are not in required array
-      expect(userSchema.required).not.toContain('lastLoginAt');
-      expect(userSchema.required).not.toContain('primaryDriverId');
-    });
-
-    it('should handle pagination fields correctly', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const userListSchema = spec.components.schemas['UserListResponseDto'];
-
-      // Verify pagination fields are required
-      expect(userListSchema.required).toContain('total');
-      expect(userListSchema.required).toContain('page');
-      expect(userListSchema.required).toContain('limit');
-      expect(userListSchema.required).toContain('totalPages');
-
-      // Verify pagination field types
-      expect(userListSchema.properties?.total?.type).toBe('number');
-      expect(userListSchema.properties?.page?.type).toBe('number');
-      expect(userListSchema.properties?.limit?.type).toBe('number');
-      expect(userListSchema.properties?.totalPages?.type).toBe('number');
-    });
-  });
-
-  describe('Error Handling Tests', () => {
-    it('should document 403 Forbidden response for admin endpoints', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const listUsersPath = spec.paths['/admin/users']?.get;
-      const dashboardStatsPath = spec.paths['/admin/dashboard/stats']?.get;
-
-      // Verify 403 response is documented
-      expect(listUsersPath.responses['403']).toBeDefined();
-      expect(dashboardStatsPath.responses['403']).toBeDefined();
-    });
-
-    it('should document 401 Unauthorized response for admin endpoints', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const listUsersPath = spec.paths['/admin/users']?.get;
-      const dashboardStatsPath = spec.paths['/admin/dashboard/stats']?.get;
-
-      // Verify 401 response is documented
-      expect(listUsersPath.responses['401']).toBeDefined();
-      expect(dashboardStatsPath.responses['401']).toBeDefined();
-    });
-
-    it('should document 400 Bad Request response for invalid query parameters', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const listUsersPath = spec.paths['/admin/users']?.get;
-
-      // Verify 400 response is documented
-      expect(listUsersPath.responses['400']).toBeDefined();
-    });
-
-    it('should document 500 Internal Server Error response', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const listUsersPath = spec.paths['/admin/users']?.get;
-      const dashboardStatsPath = spec.paths['/admin/dashboard/stats']?.get;
-
-      // Verify 500 response is documented
-      expect(listUsersPath.responses['500']).toBeDefined();
-      expect(dashboardStatsPath.responses['500']).toBeDefined();
-    });
-
-    it('should document 404 Not Found response for user operations', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      // Check for user-specific endpoints (if they exist)
-      const getUserPath = spec.paths['/admin/users/{userId}']?.get;
-      if (getUserPath) {
-        expect(getUserPath.responses['404']).toBeDefined();
-      }
-    });
-
-    it('should document 409 Conflict response for duplicate operations', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      // Check for create user endpoint (if it exists)
-      const createUserPath = spec.paths['/admin/users']?.post;
-      if (createUserPath) {
-        expect(createUserPath.responses['409']).toBeDefined();
-      }
-    });
-  });
-
-  describe('Semantic Guarantee Tests', () => {
-    it('should maintain ordering guarantees for user list', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const listUsersPath = spec.paths['/admin/users']?.get;
-
-      // Verify sortBy and sortDirection parameters are documented
-      const params = listUsersPath.parameters || [];
-      const sortByParam = params.find((p: any) => p.name === 'sortBy');
-      const sortDirectionParam = params.find((p: any) => p.name === 'sortDirection');
-
-      expect(sortByParam).toBeDefined();
-      expect(sortDirectionParam).toBeDefined();
-
-      // Verify sortDirection has default value
-      expect(sortDirectionParam?.schema?.default).toBe('asc');
-    });
-
-    it('should validate pagination consistency', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const userListSchema = spec.components.schemas['UserListResponseDto'];
-
-      // Verify pagination fields are all required
-      expect(userListSchema.required).toContain('page');
-      expect(userListSchema.required).toContain('limit');
-      expect(userListSchema.required).toContain('total');
-      expect(userListSchema.required).toContain('totalPages');
-
-      // Verify page and limit have constraints
-      const listUsersPath = spec.paths['/admin/users']?.get;
-      const params = listUsersPath.parameters || [];
-      const pageParam = params.find((p: any) => p.name === 'page');
-      const limitParam = params.find((p: any) => p.name === 'limit');
-
-      expect(pageParam?.schema?.minimum).toBe(1);
-      expect(pageParam?.schema?.default).toBe(1);
-      expect(limitParam?.schema?.minimum).toBe(1);
-      expect(limitParam?.schema?.maximum).toBe(100);
-      expect(limitParam?.schema?.default).toBe(10);
-    });
-
-    it('should validate idempotency for user status updates', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      // Check for user status update endpoint (if it exists)
-      const updateUserStatusPath = spec.paths['/admin/users/{userId}/status']?.patch;
-      if (updateUserStatusPath) {
-        // Verify it accepts a status parameter
-        const params = updateUserStatusPath.parameters || [];
-        const statusParam = params.find((p: any) => p.name === 'status');
-        expect(statusParam).toBeDefined();
-      }
-    });
-
-    it('should validate uniqueness constraints for user email', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const userSchema = spec.components.schemas['UserResponseDto'];
-
-      // Verify email is a required field
-      expect(userSchema.required).toContain('email');
-      expect(userSchema.properties?.email?.type).toBe('string');
-
-      // Check for create user endpoint (if it exists)
-      const createUserPath = spec.paths['/admin/users']?.post;
-      if (createUserPath) {
-        // Verify email is required in request body
-        const requestBody = createUserPath.requestBody;
-        if (requestBody && requestBody.content && requestBody.content['application/json']) {
-          const schema = requestBody.content['application/json'].schema;
-          if (schema && schema.$ref) {
-            // This would reference a CreateUserDto which should have email as required
-            expect(schema.$ref).toContain('CreateUserDto');
-          }
-        }
-      }
-    });
-
-    it('should validate consistency between request and response schemas', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const userSchema = spec.components.schemas['UserResponseDto'];
-      const userListSchema = spec.components.schemas['UserListResponseDto'];
-
-      // Verify UserListResponse contains array of UserResponse
-      expect(userListSchema.properties?.users?.items?.$ref).toBe('#/components/schemas/UserResponseDto');
-
-      // Verify UserResponse has consistent field types
-      expect(userSchema.properties?.id?.type).toBe('string');
-      expect(userSchema.properties?.email?.type).toBe('string');
-      expect(userSchema.properties?.displayName?.type).toBe('string');
-      expect(userSchema.properties?.roles?.type).toBe('array');
-      expect(userSchema.properties?.status?.type).toBe('string');
-      expect(userSchema.properties?.isSystemAdmin?.type).toBe('boolean');
-    });
-
-    it('should validate semantic consistency in dashboard stats', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const dashboardSchema = spec.components.schemas['DashboardStatsResponseDto'];
-
-      // Verify totalUsers >= activeUsers + suspendedUsers + deletedUsers
-      // (This is a semantic guarantee that should be enforced by the backend)
-      expect(dashboardSchema.properties?.totalUsers).toBeDefined();
-      expect(dashboardSchema.properties?.activeUsers).toBeDefined();
-      expect(dashboardSchema.properties?.suspendedUsers).toBeDefined();
-      expect(dashboardSchema.properties?.deletedUsers).toBeDefined();
-
-      // Verify systemAdmins is a subset of totalUsers
-      expect(dashboardSchema.properties?.systemAdmins).toBeDefined();
-
-      // Verify recentLogins and newUsersToday are non-negative
-      expect(dashboardSchema.properties?.recentLogins).toBeDefined();
-      expect(dashboardSchema.properties?.newUsersToday).toBeDefined();
-    });
-
-    it('should validate pagination metadata consistency', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const userListSchema = spec.components.schemas['UserListResponseDto'];
-
-      // Verify pagination metadata is always present
-      expect(userListSchema.required).toContain('page');
-      expect(userListSchema.required).toContain('limit');
-      expect(userListSchema.required).toContain('total');
-      expect(userListSchema.required).toContain('totalPages');
-
-      // Verify totalPages calculation is consistent
-      // totalPages should be >= 1 and should be calculated as Math.ceil(total / limit)
-      expect(userListSchema.properties?.totalPages?.type).toBe('number');
-    });
-  });
-
-  describe('Admin Module Integration Tests', () => {
-    it('should have consistent types between API DTOs and website types', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const adminTypesPath = path.join(websiteTypesDir, 'tbd', 'AdminUserDto.ts');
-      const adminTypesContent = await fs.readFile(adminTypesPath, 'utf-8');
-
-      // Verify UserDto interface matches UserResponseDto schema
-      const userSchema = spec.components.schemas['UserResponseDto'];
-      expect(adminTypesContent).toContain('export interface AdminUserDto');
-      
-      // Check all required fields from schema are in interface
-      for (const field of userSchema.required || []) {
-        expect(adminTypesContent).toContain(`${field}:`);
-      }
-
-      // Check all properties from schema are in interface
-      if (userSchema.properties) {
-        for (const propName of Object.keys(userSchema.properties)) {
-          expect(adminTypesContent).toContain(propName);
-        }
-      }
-    });
-
-    it('should have consistent query types between API and website', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const adminTypesPath = path.join(websiteTypesDir, 'tbd', 'AdminUserDto.ts');
-      const adminTypesContent = await fs.readFile(adminTypesPath, 'utf-8');
-
-      // Verify ListUsersQuery interface matches ListUsersRequestDto schema
-      const listUsersSchema = spec.components.schemas['ListUsersRequestDto'];
-      expect(adminTypesContent).toContain('export interface AdminListUsersQueryDto');
-
-      // Check all properties from schema are in interface
-      if (listUsersSchema.properties) {
-        for (const propName of Object.keys(listUsersSchema.properties)) {
-          expect(adminTypesContent).toContain(propName);
-        }
-      }
-    });
-
-    it('should have consistent response types between API and website', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const adminTypesPath = path.join(websiteTypesDir, 'tbd', 'AdminUserDto.ts');
-      const adminTypesContent = await fs.readFile(adminTypesPath, 'utf-8');
-
-      // Verify UserListResponse interface matches UserListResponseDto schema
-      const userListSchema = spec.components.schemas['UserListResponseDto'];
-      expect(adminTypesContent).toContain('export interface AdminUserListResponseDto');
-
-      // Check all required fields from schema are in interface
-      for (const field of userListSchema.required || []) {
-        expect(adminTypesContent).toContain(`${field}:`);
-      }
-
-      // Verify DashboardStats interface matches DashboardStatsResponseDto schema
-      const dashboardSchema = spec.components.schemas['DashboardStatsResponseDto'];
-      expect(adminTypesContent).toContain('export interface AdminDashboardStatsDto');
-
-      // Check all required fields from schema are in interface
-      for (const field of dashboardSchema.required || []) {
-        expect(adminTypesContent).toContain(`${field}:`);
-      }
-    });
-
-    it('should have AdminApiClient methods matching API endpoints', async () => {
-      const adminApiClientPath = path.join(apiRoot, 'apps/website/lib/api/admin/AdminApiClient.ts');
-      const adminApiClientContent = await fs.readFile(adminApiClientPath, 'utf-8');
-
-      // Verify listUsers method exists and uses correct endpoint
-      expect(adminApiClientContent).toContain('async listUsers');
-      expect(adminApiClientContent).toContain("return this.get<UserListResponse>(`/admin/users?${params.toString()}`)");
-
-      // Verify getDashboardStats method exists and uses correct endpoint
-      expect(adminApiClientContent).toContain('async getDashboardStats');
-      expect(adminApiClientContent).toContain("return this.get<DashboardStats>(`/admin/dashboard/stats`)");
-    });
-
-    it('should have proper error handling in AdminApiClient', async () => {
-      const adminApiClientPath = path.join(apiRoot, 'apps/website/lib/api/admin/AdminApiClient.ts');
-      const adminApiClientContent = await fs.readFile(adminApiClientPath, 'utf-8');
-
-      // Verify BaseApiClient is extended (which provides error handling)
-      expect(adminApiClientContent).toContain('extends BaseApiClient');
-
-      // Verify methods use BaseApiClient methods (which handle errors)
-      expect(adminApiClientContent).toContain('this.get<');
-      expect(adminApiClientContent).toContain('this.post<');
-      expect(adminApiClientContent).toContain('this.patch<');
-      expect(adminApiClientContent).toContain('this.delete<');
-    });
-  });
-});

tests/contracts/analytics-contract.test.ts

@@ -1,897 +0,0 @@
-/**
- * Contract Validation Tests for Analytics Module
- * 
- * These tests validate that the analytics API DTOs and OpenAPI spec are consistent
- * and that the generated types will be compatible with the website analytics client.
- */
-
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { describe, expect, it } from 'vitest';
-
-interface OpenAPISchema {
-  type?: string;
-  format?: string;
-  $ref?: string;
-  items?: OpenAPISchema;
-  properties?: Record<string, OpenAPISchema>;
-  required?: string[];
-  enum?: string[];
-  nullable?: boolean;
-  description?: string;
-  default?: unknown;
-}
-
-interface OpenAPISpec {
-  openapi: string;
-  info: {
-    title: string;
-    description: string;
-    version: string;
-  };
-  paths: Record<string, any>;
-  components: {
-    schemas: Record<string, OpenAPISchema>;
-  };
-}
-
-describe('Analytics Module Contract Validation', () => {
-  const apiRoot = path.join(__dirname, '../..');
-  const openapiPath = path.join(apiRoot, 'apps/api/openapi.json');
-  const generatedTypesDir = path.join(apiRoot, 'apps/website/lib/types/generated');
-  const websiteTypesDir = path.join(apiRoot, 'apps/website/lib/types');
-
-  describe('OpenAPI Spec Integrity for Analytics Endpoints', () => {
-    it('should have analytics endpoints defined in OpenAPI spec', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      // Check for analytics endpoints
-      expect(spec.paths['/analytics/page-view']).toBeDefined();
-      expect(spec.paths['/analytics/engagement']).toBeDefined();
-      expect(spec.paths['/analytics/dashboard']).toBeDefined();
-      expect(spec.paths['/analytics/metrics']).toBeDefined();
-
-      // Verify POST methods exist for recording endpoints
-      expect(spec.paths['/analytics/page-view'].post).toBeDefined();
-      expect(spec.paths['/analytics/engagement'].post).toBeDefined();
-
-      // Verify GET methods exist for query endpoints
-      expect(spec.paths['/analytics/dashboard'].get).toBeDefined();
-      expect(spec.paths['/analytics/metrics'].get).toBeDefined();
-    });
-
-    it('should have RecordPageViewInputDTO schema defined', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['RecordPageViewInputDTO'];
-      expect(schema).toBeDefined();
-      expect(schema.type).toBe('object');
-
-      // Verify required fields
-      expect(schema.required).toContain('entityType');
-      expect(schema.required).toContain('entityId');
-      expect(schema.required).toContain('visitorType');
-      expect(schema.required).toContain('sessionId');
-
-      // Verify field types
-      expect(schema.properties?.entityType?.type).toBe('string');
-      expect(schema.properties?.entityId?.type).toBe('string');
-      expect(schema.properties?.visitorType?.type).toBe('string');
-      expect(schema.properties?.sessionId?.type).toBe('string');
-
-      // Verify optional fields
-      expect(schema.properties?.visitorId).toBeDefined();
-      expect(schema.properties?.referrer).toBeDefined();
-      expect(schema.properties?.userAgent).toBeDefined();
-      expect(schema.properties?.country).toBeDefined();
-    });
-
-    it('should have RecordPageViewOutputDTO schema defined', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['RecordPageViewOutputDTO'];
-      expect(schema).toBeDefined();
-      expect(schema.type).toBe('object');
-
-      // Verify required fields
-      expect(schema.required).toContain('pageViewId');
-
-      // Verify field types
-      expect(schema.properties?.pageViewId?.type).toBe('string');
-    });
-
-    it('should have RecordEngagementInputDTO schema defined', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['RecordEngagementInputDTO'];
-      expect(schema).toBeDefined();
-      expect(schema.type).toBe('object');
-
-      // Verify required fields
-      expect(schema.required).toContain('action');
-      expect(schema.required).toContain('entityType');
-      expect(schema.required).toContain('entityId');
-      expect(schema.required).toContain('actorType');
-      expect(schema.required).toContain('sessionId');
-
-      // Verify field types
-      expect(schema.properties?.action?.type).toBe('string');
-      expect(schema.properties?.entityType?.type).toBe('string');
-      expect(schema.properties?.entityId?.type).toBe('string');
-      expect(schema.properties?.actorType?.type).toBe('string');
-      expect(schema.properties?.sessionId?.type).toBe('string');
-
-      // Verify optional fields
-      expect(schema.properties?.actorId).toBeDefined();
-      expect(schema.properties?.metadata).toBeDefined();
-    });
-
-    it('should have RecordEngagementOutputDTO schema defined', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['RecordEngagementOutputDTO'];
-      expect(schema).toBeDefined();
-      expect(schema.type).toBe('object');
-
-      // Verify required fields
-      expect(schema.required).toContain('eventId');
-      expect(schema.required).toContain('engagementWeight');
-
-      // Verify field types
-      expect(schema.properties?.eventId?.type).toBe('string');
-      expect(schema.properties?.engagementWeight?.type).toBe('number');
-    });
-
-    it('should have GetAnalyticsMetricsOutputDTO schema defined', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['GetAnalyticsMetricsOutputDTO'];
-      expect(schema).toBeDefined();
-      expect(schema.type).toBe('object');
-
-      // Verify required fields
-      expect(schema.required).toContain('pageViews');
-      expect(schema.required).toContain('uniqueVisitors');
-      expect(schema.required).toContain('averageSessionDuration');
-      expect(schema.required).toContain('bounceRate');
-
-      // Verify field types
-      expect(schema.properties?.pageViews?.type).toBe('number');
-      expect(schema.properties?.uniqueVisitors?.type).toBe('number');
-      expect(schema.properties?.averageSessionDuration?.type).toBe('number');
-      expect(schema.properties?.bounceRate?.type).toBe('number');
-    });
-
-    it('should have GetDashboardDataOutputDTO schema defined', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['GetDashboardDataOutputDTO'];
-      expect(schema).toBeDefined();
-      expect(schema.type).toBe('object');
-
-      // Verify required fields
-      expect(schema.required).toContain('totalUsers');
-      expect(schema.required).toContain('activeUsers');
-      expect(schema.required).toContain('totalRaces');
-      expect(schema.required).toContain('totalLeagues');
-
-      // Verify field types
-      expect(schema.properties?.totalUsers?.type).toBe('number');
-      expect(schema.properties?.activeUsers?.type).toBe('number');
-      expect(schema.properties?.totalRaces?.type).toBe('number');
-      expect(schema.properties?.totalLeagues?.type).toBe('number');
-    });
-
-    it('should have proper request/response structure for page-view endpoint', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const pageViewPath = spec.paths['/analytics/page-view']?.post;
-      expect(pageViewPath).toBeDefined();
-
-      // Verify request body
-      const requestBody = pageViewPath.requestBody;
-      expect(requestBody).toBeDefined();
-      expect(requestBody.content['application/json']).toBeDefined();
-      expect(requestBody.content['application/json'].schema.$ref).toBe('#/components/schemas/RecordPageViewInputDTO');
-
-      // Verify response
-      const response201 = pageViewPath.responses['201'];
-      expect(response201).toBeDefined();
-      expect(response201.content['application/json'].schema.$ref).toBe('#/components/schemas/RecordPageViewOutputDTO');
-    });
-
-    it('should have proper request/response structure for engagement endpoint', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const engagementPath = spec.paths['/analytics/engagement']?.post;
-      expect(engagementPath).toBeDefined();
-
-      // Verify request body
-      const requestBody = engagementPath.requestBody;
-      expect(requestBody).toBeDefined();
-      expect(requestBody.content['application/json']).toBeDefined();
-      expect(requestBody.content['application/json'].schema.$ref).toBe('#/components/schemas/RecordEngagementInputDTO');
-
-      // Verify response
-      const response201 = engagementPath.responses['201'];
-      expect(response201).toBeDefined();
-      expect(response201.content['application/json'].schema.$ref).toBe('#/components/schemas/RecordEngagementOutputDTO');
-    });
-
-    it('should have proper response structure for metrics endpoint', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const metricsPath = spec.paths['/analytics/metrics']?.get;
-      expect(metricsPath).toBeDefined();
-
-      // Verify response
-      const response200 = metricsPath.responses['200'];
-      expect(response200).toBeDefined();
-      expect(response200.content['application/json'].schema.$ref).toBe('#/components/schemas/GetAnalyticsMetricsOutputDTO');
-    });
-
-    it('should have proper response structure for dashboard endpoint', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const dashboardPath = spec.paths['/analytics/dashboard']?.get;
-      expect(dashboardPath).toBeDefined();
-
-      // Verify response
-      const response200 = dashboardPath.responses['200'];
-      expect(response200).toBeDefined();
-      expect(response200.content['application/json'].schema.$ref).toBe('#/components/schemas/GetDashboardDataOutputDTO');
-    });
-  });
-
-  describe('DTO Consistency', () => {
-    it('should have generated DTO files for analytics schemas', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const generatedFiles = await fs.readdir(generatedTypesDir);
-      const generatedDTOs = generatedFiles
-        .filter(f => f.endsWith('.ts'))
-        .map(f => f.replace('.ts', ''));
-
-      // Check for analytics-related DTOs
-      const analyticsDTOs = [
-        'RecordPageViewInputDTO',
-        'RecordPageViewOutputDTO',
-        'RecordEngagementInputDTO',
-        'RecordEngagementOutputDTO',
-        'GetAnalyticsMetricsOutputDTO',
-        'GetDashboardDataOutputDTO',
-      ];
-
-      for (const dtoName of analyticsDTOs) {
-        expect(spec.components.schemas[dtoName]).toBeDefined();
-        expect(generatedDTOs).toContain(dtoName);
-      }
-    });
-
-    it('should have consistent property types between DTOs and schemas', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-      const schemas = spec.components.schemas;
-
-      // Test RecordPageViewInputDTO
-      const pageViewSchema = schemas['RecordPageViewInputDTO'];
-      const pageViewDtoPath = path.join(generatedTypesDir, 'RecordPageViewInputDTO.ts');
-      const pageViewDtoExists = await fs.access(pageViewDtoPath).then(() => true).catch(() => false);
-      
-      if (pageViewDtoExists) {
-        const pageViewDtoContent = await fs.readFile(pageViewDtoPath, 'utf-8');
-        
-        // Check that all properties are present
-        if (pageViewSchema.properties) {
-          for (const propName of Object.keys(pageViewSchema.properties)) {
-            expect(pageViewDtoContent).toContain(propName);
-          }
-        }
-      }
-
-      // Test RecordEngagementInputDTO
-      const engagementSchema = schemas['RecordEngagementInputDTO'];
-      const engagementDtoPath = path.join(generatedTypesDir, 'RecordEngagementInputDTO.ts');
-      const engagementDtoExists = await fs.access(engagementDtoPath).then(() => true).catch(() => false);
-      
-      if (engagementDtoExists) {
-        const engagementDtoContent = await fs.readFile(engagementDtoPath, 'utf-8');
-        
-        // Check that all properties are present
-        if (engagementSchema.properties) {
-          for (const propName of Object.keys(engagementSchema.properties)) {
-            expect(engagementDtoContent).toContain(propName);
-          }
-        }
-      }
-
-      // Test GetAnalyticsMetricsOutputDTO
-      const metricsSchema = schemas['GetAnalyticsMetricsOutputDTO'];
-      const metricsDtoPath = path.join(generatedTypesDir, 'GetAnalyticsMetricsOutputDTO.ts');
-      const metricsDtoExists = await fs.access(metricsDtoPath).then(() => true).catch(() => false);
-      
-      if (metricsDtoExists) {
-        const metricsDtoContent = await fs.readFile(metricsDtoPath, 'utf-8');
-        
-        // Check that all required properties are present
-        if (metricsSchema.required) {
-          for (const requiredProp of metricsSchema.required) {
-            expect(metricsDtoContent).toContain(requiredProp);
-          }
-        }
-      }
-
-      // Test GetDashboardDataOutputDTO
-      const dashboardSchema = schemas['GetDashboardDataOutputDTO'];
-      const dashboardDtoPath = path.join(generatedTypesDir, 'GetDashboardDataOutputDTO.ts');
-      const dashboardDtoExists = await fs.access(dashboardDtoPath).then(() => true).catch(() => false);
-      
-      if (dashboardDtoExists) {
-        const dashboardDtoContent = await fs.readFile(dashboardDtoPath, 'utf-8');
-        
-        // Check that all required properties are present
-        if (dashboardSchema.required) {
-          for (const requiredProp of dashboardSchema.required) {
-            expect(dashboardDtoContent).toContain(requiredProp);
-          }
-        }
-      }
-    });
-
-    it('should have analytics types defined in tbd folder', async () => {
-      // Check if analytics types exist in tbd folder (similar to admin types)
-      const tbdDir = path.join(websiteTypesDir, 'tbd');
-      const tbdFiles = await fs.readdir(tbdDir).catch(() => []);
-      
-      // Analytics types might be in a separate file or combined with existing types
-      // For now, we'll check if the generated types are properly available
-      const generatedFiles = await fs.readdir(generatedTypesDir);
-      const analyticsGenerated = generatedFiles.filter(f => 
-        f.includes('Analytics') || 
-        f.includes('Record') || 
-        f.includes('PageView') || 
-        f.includes('Engagement')
-      );
-      
-      expect(analyticsGenerated.length).toBeGreaterThanOrEqual(6);
-    });
-
-    it('should have analytics types re-exported from main types file', async () => {
-      // Check if there's an analytics.ts file or if types are exported elsewhere
-      const analyticsTypesPath = path.join(websiteTypesDir, 'analytics.ts');
-      const analyticsTypesExists = await fs.access(analyticsTypesPath).then(() => true).catch(() => false);
-      
-      if (analyticsTypesExists) {
-        const analyticsTypesContent = await fs.readFile(analyticsTypesPath, 'utf-8');
-        
-        // Verify re-exports
-        expect(analyticsTypesContent).toContain('RecordPageViewInputDTO');
-        expect(analyticsTypesContent).toContain('RecordEngagementInputDTO');
-        expect(analyticsTypesContent).toContain('GetAnalyticsMetricsOutputDTO');
-        expect(analyticsTypesContent).toContain('GetDashboardDataOutputDTO');
-      }
-    });
-  });
-
-  describe('Analytics API Client Contract', () => {
-    it('should have AnalyticsApiClient defined', async () => {
-      const analyticsApiClientPath = path.join(apiRoot, 'apps/website/lib/api/analytics/AnalyticsApiClient.ts');
-      const analyticsApiClientExists = await fs.access(analyticsApiClientPath).then(() => true).catch(() => false);
-      
-      expect(analyticsApiClientExists).toBe(true);
-
-      const analyticsApiClientContent = await fs.readFile(analyticsApiClientPath, 'utf-8');
-
-      // Verify class definition
-      expect(analyticsApiClientContent).toContain('export class AnalyticsApiClient');
-      expect(analyticsApiClientContent).toContain('extends BaseApiClient');
-
-      // Verify methods exist
-      expect(analyticsApiClientContent).toContain('recordPageView');
-      expect(analyticsApiClientContent).toContain('recordEngagement');
-      expect(analyticsApiClientContent).toContain('getDashboardData');
-      expect(analyticsApiClientContent).toContain('getAnalyticsMetrics');
-
-      // Verify method signatures
-      expect(analyticsApiClientContent).toContain('recordPageView(input: RecordPageViewInputDTO)');
-      expect(analyticsApiClientContent).toContain('recordEngagement(input: RecordEngagementInputDTO)');
-      expect(analyticsApiClientContent).toContain('getDashboardData()');
-      expect(analyticsApiClientContent).toContain('getAnalyticsMetrics()');
-    });
-
-    it('should have proper request construction in recordPageView method', async () => {
-      const analyticsApiClientPath = path.join(apiRoot, 'apps/website/lib/api/analytics/AnalyticsApiClient.ts');
-      const analyticsApiClientContent = await fs.readFile(analyticsApiClientPath, 'utf-8');
-
-      // Verify POST request with input
-      expect(analyticsApiClientContent).toContain("return this.post<RecordPageViewOutputDTO>('/analytics/page-view', input)");
-    });
-
-    it('should have proper request construction in recordEngagement method', async () => {
-      const analyticsApiClientPath = path.join(apiRoot, 'apps/website/lib/api/analytics/AnalyticsApiClient.ts');
-      const analyticsApiClientContent = await fs.readFile(analyticsApiClientPath, 'utf-8');
-
-      // Verify POST request with input
-      expect(analyticsApiClientContent).toContain("return this.post<RecordEngagementOutputDTO>('/analytics/engagement', input)");
-    });
-
-    it('should have proper request construction in getDashboardData method', async () => {
-      const analyticsApiClientPath = path.join(apiRoot, 'apps/website/lib/api/analytics/AnalyticsApiClient.ts');
-      const analyticsApiClientContent = await fs.readFile(analyticsApiClientPath, 'utf-8');
-
-      // Verify GET request
-      expect(analyticsApiClientContent).toContain("return this.get<GetDashboardDataOutputDTO>('/analytics/dashboard')");
-    });
-
-    it('should have proper request construction in getAnalyticsMetrics method', async () => {
-      const analyticsApiClientPath = path.join(apiRoot, 'apps/website/lib/api/analytics/AnalyticsApiClient.ts');
-      const analyticsApiClientContent = await fs.readFile(analyticsApiClientPath, 'utf-8');
-
-      // Verify GET request
-      expect(analyticsApiClientContent).toContain("return this.get<GetAnalyticsMetricsOutputDTO>('/analytics/metrics')");
-    });
-  });
-
-  describe('Request Correctness Tests', () => {
-    it('should validate RecordPageViewInputDTO required fields', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['RecordPageViewInputDTO'];
-
-      // Verify all required fields are present
-      expect(schema.required).toContain('entityType');
-      expect(schema.required).toContain('entityId');
-      expect(schema.required).toContain('visitorType');
-      expect(schema.required).toContain('sessionId');
-
-      // Verify no extra required fields
-      expect(schema.required.length).toBe(4);
-    });
-
-    it('should validate RecordPageViewInputDTO optional fields', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['RecordPageViewInputDTO'];
-
-      // Verify optional fields are not required
-      expect(schema.required).not.toContain('visitorId');
-      expect(schema.required).not.toContain('referrer');
-      expect(schema.required).not.toContain('userAgent');
-      expect(schema.required).not.toContain('country');
-
-      // Verify optional fields exist
-      expect(schema.properties?.visitorId).toBeDefined();
-      expect(schema.properties?.referrer).toBeDefined();
-      expect(schema.properties?.userAgent).toBeDefined();
-      expect(schema.properties?.country).toBeDefined();
-    });
-
-    it('should validate RecordEngagementInputDTO required fields', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['RecordEngagementInputDTO'];
-
-      // Verify all required fields are present
-      expect(schema.required).toContain('action');
-      expect(schema.required).toContain('entityType');
-      expect(schema.required).toContain('entityId');
-      expect(schema.required).toContain('actorType');
-      expect(schema.required).toContain('sessionId');
-
-      // Verify no extra required fields
-      expect(schema.required.length).toBe(5);
-    });
-
-    it('should validate RecordEngagementInputDTO optional fields', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['RecordEngagementInputDTO'];
-
-      // Verify optional fields are not required
-      expect(schema.required).not.toContain('actorId');
-      expect(schema.required).not.toContain('metadata');
-
-      // Verify optional fields exist
-      expect(schema.properties?.actorId).toBeDefined();
-      expect(schema.properties?.metadata).toBeDefined();
-    });
-
-    it('should validate GetAnalyticsMetricsOutputDTO structure', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['GetAnalyticsMetricsOutputDTO'];
-
-      // Verify all required fields
-      expect(schema.required).toContain('pageViews');
-      expect(schema.required).toContain('uniqueVisitors');
-      expect(schema.required).toContain('averageSessionDuration');
-      expect(schema.required).toContain('bounceRate');
-
-      // Verify field types
-      expect(schema.properties?.pageViews?.type).toBe('number');
-      expect(schema.properties?.uniqueVisitors?.type).toBe('number');
-      expect(schema.properties?.averageSessionDuration?.type).toBe('number');
-      expect(schema.properties?.bounceRate?.type).toBe('number');
-    });
-
-    it('should validate GetDashboardDataOutputDTO structure', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['GetDashboardDataOutputDTO'];
-
-      // Verify all required fields
-      expect(schema.required).toContain('totalUsers');
-      expect(schema.required).toContain('activeUsers');
-      expect(schema.required).toContain('totalRaces');
-      expect(schema.required).toContain('totalLeagues');
-
-      // Verify field types
-      expect(schema.properties?.totalUsers?.type).toBe('number');
-      expect(schema.properties?.activeUsers?.type).toBe('number');
-      expect(schema.properties?.totalRaces?.type).toBe('number');
-      expect(schema.properties?.totalLeagues?.type).toBe('number');
-    });
-  });
-
-  describe('Response Handling Tests', () => {
-    it('should handle successful page view recording response', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const pageViewSchema = spec.components.schemas['RecordPageViewOutputDTO'];
-
-      // Verify response structure
-      expect(pageViewSchema.properties?.pageViewId).toBeDefined();
-      expect(pageViewSchema.properties?.pageViewId?.type).toBe('string');
-      expect(pageViewSchema.required).toContain('pageViewId');
-    });
-
-    it('should handle successful engagement recording response', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const engagementSchema = spec.components.schemas['RecordEngagementOutputDTO'];
-
-      // Verify response structure
-      expect(engagementSchema.properties?.eventId).toBeDefined();
-      expect(engagementSchema.properties?.engagementWeight).toBeDefined();
-      expect(engagementSchema.properties?.eventId?.type).toBe('string');
-      expect(engagementSchema.properties?.engagementWeight?.type).toBe('number');
-      expect(engagementSchema.required).toContain('eventId');
-      expect(engagementSchema.required).toContain('engagementWeight');
-    });
-
-    it('should handle metrics response with all required fields', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const metricsSchema = spec.components.schemas['GetAnalyticsMetricsOutputDTO'];
-
-      // Verify all required fields are present
-      for (const field of ['pageViews', 'uniqueVisitors', 'averageSessionDuration', 'bounceRate']) {
-        expect(metricsSchema.required).toContain(field);
-        expect(metricsSchema.properties?.[field]).toBeDefined();
-        expect(metricsSchema.properties?.[field]?.type).toBe('number');
-      }
-    });
-
-    it('should handle dashboard data response with all required fields', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const dashboardSchema = spec.components.schemas['GetDashboardDataOutputDTO'];
-
-      // Verify all required fields are present
-      for (const field of ['totalUsers', 'activeUsers', 'totalRaces', 'totalLeagues']) {
-        expect(dashboardSchema.required).toContain(field);
-        expect(dashboardSchema.properties?.[field]).toBeDefined();
-        expect(dashboardSchema.properties?.[field]?.type).toBe('number');
-      }
-    });
-
-    it('should handle optional fields in page view input correctly', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['RecordPageViewInputDTO'];
-
-      // Verify optional fields are nullable or optional
-      expect(schema.properties?.visitorId?.type).toBe('string');
-      expect(schema.properties?.referrer?.type).toBe('string');
-      expect(schema.properties?.userAgent?.type).toBe('string');
-      expect(schema.properties?.country?.type).toBe('string');
-    });
-
-    it('should handle optional fields in engagement input correctly', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const schema = spec.components.schemas['RecordEngagementInputDTO'];
-
-      // Verify optional fields
-      expect(schema.properties?.actorId?.type).toBe('string');
-      expect(schema.properties?.metadata?.type).toBe('object');
-    });
-  });
-
-  describe('Error Handling Tests', () => {
-    it('should document 400 Bad Request response for invalid page view input', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const pageViewPath = spec.paths['/analytics/page-view']?.post;
-
-      // Check if 400 response is documented
-      if (pageViewPath.responses['400']) {
-        expect(pageViewPath.responses['400']).toBeDefined();
-      }
-    });
-
-    it('should document 400 Bad Request response for invalid engagement input', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const engagementPath = spec.paths['/analytics/engagement']?.post;
-
-      // Check if 400 response is documented
-      if (engagementPath.responses['400']) {
-        expect(engagementPath.responses['400']).toBeDefined();
-      }
-    });
-
-    it('should document 401 Unauthorized response for protected endpoints', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      // Dashboard and metrics endpoints should require authentication
-      const dashboardPath = spec.paths['/analytics/dashboard']?.get;
-      const metricsPath = spec.paths['/analytics/metrics']?.get;
-
-      // Check if 401 responses are documented
-      if (dashboardPath.responses['401']) {
-        expect(dashboardPath.responses['401']).toBeDefined();
-      }
-      if (metricsPath.responses['401']) {
-        expect(metricsPath.responses['401']).toBeDefined();
-      }
-    });
-
-    it('should document 500 Internal Server Error response', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const pageViewPath = spec.paths['/analytics/page-view']?.post;
-      const engagementPath = spec.paths['/analytics/engagement']?.post;
-
-      // Check if 500 response is documented for recording endpoints
-      if (pageViewPath.responses['500']) {
-        expect(pageViewPath.responses['500']).toBeDefined();
-      }
-      if (engagementPath.responses['500']) {
-        expect(engagementPath.responses['500']).toBeDefined();
-      }
-    });
-
-    it('should have proper error handling in AnalyticsApiClient', async () => {
-      const analyticsApiClientPath = path.join(apiRoot, 'apps/website/lib/api/analytics/AnalyticsApiClient.ts');
-      const analyticsApiClientContent = await fs.readFile(analyticsApiClientPath, 'utf-8');
-
-      // Verify BaseApiClient is extended (which provides error handling)
-      expect(analyticsApiClientContent).toContain('extends BaseApiClient');
-
-      // Verify methods use BaseApiClient methods (which handle errors)
-      expect(analyticsApiClientContent).toContain('this.post<');
-      expect(analyticsApiClientContent).toContain('this.get<');
-    });
-  });
-
-  describe('Semantic Guarantee Tests', () => {
-    it('should maintain consistency between request and response schemas', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      // Verify page view request/response consistency
-      const pageViewInputSchema = spec.components.schemas['RecordPageViewInputDTO'];
-      const pageViewOutputSchema = spec.components.schemas['RecordPageViewOutputDTO'];
-
-      // Output should contain a reference to the input (pageViewId relates to the recorded page view)
-      expect(pageViewOutputSchema.properties?.pageViewId).toBeDefined();
-      expect(pageViewOutputSchema.properties?.pageViewId?.type).toBe('string');
-
-      // Verify engagement request/response consistency
-      const engagementInputSchema = spec.components.schemas['RecordEngagementInputDTO'];
-      const engagementOutputSchema = spec.components.schemas['RecordEngagementOutputDTO'];
-
-      // Output should contain event reference and engagement weight
-      expect(engagementOutputSchema.properties?.eventId).toBeDefined();
-      expect(engagementOutputSchema.properties?.engagementWeight).toBeDefined();
-    });
-
-    it('should validate semantic consistency in analytics metrics', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const metricsSchema = spec.components.schemas['GetAnalyticsMetricsOutputDTO'];
-
-      // Verify metrics are non-negative numbers
-      expect(metricsSchema.properties?.pageViews?.type).toBe('number');
-      expect(metricsSchema.properties?.uniqueVisitors?.type).toBe('number');
-      expect(metricsSchema.properties?.averageSessionDuration?.type).toBe('number');
-      expect(metricsSchema.properties?.bounceRate?.type).toBe('number');
-
-      // Verify bounce rate is a percentage (0-1 range or 0-100)
-      // This is a semantic guarantee that should be documented
-      expect(metricsSchema.properties?.bounceRate).toBeDefined();
-    });
-
-    it('should validate semantic consistency in dashboard data', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const dashboardSchema = spec.components.schemas['GetDashboardDataOutputDTO'];
-
-      // Verify dashboard metrics are non-negative numbers
-      expect(dashboardSchema.properties?.totalUsers?.type).toBe('number');
-      expect(dashboardSchema.properties?.activeUsers?.type).toBe('number');
-      expect(dashboardSchema.properties?.totalRaces?.type).toBe('number');
-      expect(dashboardSchema.properties?.totalLeagues?.type).toBe('number');
-
-      // Semantic guarantee: activeUsers <= totalUsers
-      // This should be enforced by the backend
-      expect(dashboardSchema.properties?.activeUsers).toBeDefined();
-      expect(dashboardSchema.properties?.totalUsers).toBeDefined();
-    });
-
-    it('should validate idempotency for analytics recording', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      // Check if recording endpoints support idempotency
-      const pageViewPath = spec.paths['/analytics/page-view']?.post;
-      const engagementPath = spec.paths['/analytics/engagement']?.post;
-
-      // Verify session-based deduplication is possible
-      const pageViewSchema = spec.components.schemas['RecordPageViewInputDTO'];
-      const engagementSchema = spec.components.schemas['RecordEngagementInputDTO'];
-
-      // Both should have sessionId for deduplication
-      expect(pageViewSchema.properties?.sessionId).toBeDefined();
-      expect(engagementSchema.properties?.sessionId).toBeDefined();
-    });
-
-    it('should validate uniqueness constraints for analytics entities', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const pageViewSchema = spec.components.schemas['RecordPageViewInputDTO'];
-      const engagementSchema = spec.components.schemas['RecordEngagementInputDTO'];
-
-      // Verify entity identification fields are required
-      expect(pageViewSchema.required).toContain('entityType');
-      expect(pageViewSchema.required).toContain('entityId');
-      expect(pageViewSchema.required).toContain('sessionId');
-
-      expect(engagementSchema.required).toContain('entityType');
-      expect(engagementSchema.required).toContain('entityId');
-      expect(engagementSchema.required).toContain('sessionId');
-    });
-
-    it('should validate consistency between request and response types', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      // Verify all DTOs have consistent type definitions
-      const dtos = [
-        'RecordPageViewInputDTO',
-        'RecordPageViewOutputDTO',
-        'RecordEngagementInputDTO',
-        'RecordEngagementOutputDTO',
-        'GetAnalyticsMetricsOutputDTO',
-        'GetDashboardDataOutputDTO',
-      ];
-
-      for (const dtoName of dtos) {
-        const schema = spec.components.schemas[dtoName];
-        expect(schema).toBeDefined();
-        expect(schema.type).toBe('object');
-        
-        // All should have properties defined
-        expect(schema.properties).toBeDefined();
-        
-        // All should have required fields (even if empty array)
-        expect(schema.required).toBeDefined();
-      }
-    });
-  });
-
-  describe('Analytics Module Integration Tests', () => {
-    it('should have consistent types between API DTOs and website types', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      const generatedFiles = await fs.readdir(generatedTypesDir);
-      const generatedDTOs = generatedFiles
-        .filter(f => f.endsWith('.ts'))
-        .map(f => f.replace('.ts', ''));
-
-      // Check all analytics DTOs exist in generated types
-      const analyticsDTOs = [
-        'RecordPageViewInputDTO',
-        'RecordPageViewOutputDTO',
-        'RecordEngagementInputDTO',
-        'RecordEngagementOutputDTO',
-        'GetAnalyticsMetricsOutputDTO',
-        'GetDashboardDataOutputDTO',
-      ];
-
-      for (const dtoName of analyticsDTOs) {
-        expect(spec.components.schemas[dtoName]).toBeDefined();
-        expect(generatedDTOs).toContain(dtoName);
-      }
-    });
-
-    it('should have AnalyticsApiClient methods matching API endpoints', async () => {
-      const analyticsApiClientPath = path.join(apiRoot, 'apps/website/lib/api/analytics/AnalyticsApiClient.ts');
-      const analyticsApiClientContent = await fs.readFile(analyticsApiClientPath, 'utf-8');
-
-      // Verify recordPageView method exists and uses correct endpoint
-      expect(analyticsApiClientContent).toContain('async recordPageView');
-      expect(analyticsApiClientContent).toContain("return this.post<RecordPageViewOutputDTO>('/analytics/page-view', input)");
-
-      // Verify recordEngagement method exists and uses correct endpoint
-      expect(analyticsApiClientContent).toContain('async recordEngagement');
-      expect(analyticsApiClientContent).toContain("return this.post<RecordEngagementOutputDTO>('/analytics/engagement', input)");
-
-      // Verify getDashboardData method exists and uses correct endpoint
-      expect(analyticsApiClientContent).toContain('async getDashboardData');
-      expect(analyticsApiClientContent).toContain("return this.get<GetDashboardDataOutputDTO>('/analytics/dashboard')");
-
-      // Verify getAnalyticsMetrics method exists and uses correct endpoint
-      expect(analyticsApiClientContent).toContain('async getAnalyticsMetrics');
-      expect(analyticsApiClientContent).toContain("return this.get<GetAnalyticsMetricsOutputDTO>('/analytics/metrics')");
-    });
-
-    it('should have proper error handling in AnalyticsApiClient', async () => {
-      const analyticsApiClientPath = path.join(apiRoot, 'apps/website/lib/api/analytics/AnalyticsApiClient.ts');
-      const analyticsApiClientContent = await fs.readFile(analyticsApiClientPath, 'utf-8');
-
-      // Verify BaseApiClient is extended (which provides error handling)
-      expect(analyticsApiClientContent).toContain('extends BaseApiClient');
-
-      // Verify methods use BaseApiClient methods (which handle errors)
-      expect(analyticsApiClientContent).toContain('this.post<');
-      expect(analyticsApiClientContent).toContain('this.get<');
-    });
-
-    it('should have consistent type imports in AnalyticsApiClient', async () => {
-      const analyticsApiClientPath = path.join(apiRoot, 'apps/website/lib/api/analytics/AnalyticsApiClient.ts');
-      const analyticsApiClientContent = await fs.readFile(analyticsApiClientPath, 'utf-8');
-
-      // Verify all required types are imported
-      expect(analyticsApiClientContent).toContain('RecordPageViewOutputDTO');
-      expect(analyticsApiClientContent).toContain('RecordEngagementOutputDTO');
-      expect(analyticsApiClientContent).toContain('GetDashboardDataOutputDTO');
-      expect(analyticsApiClientContent).toContain('GetAnalyticsMetricsOutputDTO');
-      expect(analyticsApiClientContent).toContain('RecordPageViewInputDTO');
-      expect(analyticsApiClientContent).toContain('RecordEngagementInputDTO');
-    });
-  });
-});

tests/contracts/bootstrap-contract.test.ts

@@ -1,313 +0,0 @@
-/**
- * Contract Validation Tests for Bootstrap Module
- * 
- * These tests validate that the bootstrap module is properly configured and that
- * the initialization process follows expected patterns. The bootstrap module is
- * an internal initialization module that runs during application startup and
- * does not expose HTTP endpoints.
- * 
- * Key Findings:
- * - Bootstrap module is an internal initialization module (not an API endpoint)
- * - It runs during application startup via OnModuleInit lifecycle hook
- * - It seeds the database with initial data (admin users, achievements, racing data)
- * - It does not expose any HTTP controllers or endpoints
- * - No API client exists in the website app for bootstrap operations
- * - No bootstrap-related endpoints are defined in the OpenAPI spec
- */
-
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { describe, expect, it } from 'vitest';
-
-interface OpenAPISpec {
-  openapi: string;
-  info: {
-    title: string;
-    description: string;
-    version: string;
-  };
-  paths: Record<string, any>;
-  components: {
-    schemas: Record<string, any>;
-  };
-}
-
-describe('Bootstrap Module Contract Validation', () => {
-  const apiRoot = path.join(__dirname, '../..');
-  const openapiPath = path.join(apiRoot, 'apps/api/openapi.json');
-  const bootstrapModulePath = path.join(apiRoot, 'apps/api/src/domain/bootstrap/BootstrapModule.ts');
-  const bootstrapAdaptersPath = path.join(apiRoot, 'adapters/bootstrap');
-
-  describe('OpenAPI Spec Integrity for Bootstrap', () => {
-    it('should NOT have bootstrap endpoints defined in OpenAPI spec', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      // Bootstrap is an internal module, not an API endpoint
-      // Verify no bootstrap-related paths exist
-      const bootstrapPaths = Object.keys(spec.paths).filter(p => p.includes('bootstrap'));
-      expect(bootstrapPaths.length).toBe(0);
-    });
-
-    it('should NOT have bootstrap-related DTOs in OpenAPI spec', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-
-      // Bootstrap module doesn't expose DTOs for API consumption
-      // It uses internal DTOs for seeding data
-      const bootstrapSchemas = Object.keys(spec.components.schemas).filter(s => 
-        s.toLowerCase().includes('bootstrap') || 
-        s.toLowerCase().includes('seed')
-      );
-      expect(bootstrapSchemas.length).toBe(0);
-    });
-  });
-
-  describe('Bootstrap Module Structure', () => {
-    it('should have BootstrapModule defined', async () => {
-      const bootstrapModuleExists = await fs.access(bootstrapModulePath).then(() => true).catch(() => false);
-      expect(bootstrapModuleExists).toBe(true);
-    });
-
-    it('should have BootstrapModule implement OnModuleInit', async () => {
-      const bootstrapModuleContent = await fs.readFile(bootstrapModulePath, 'utf-8');
-      
-      // Verify it implements OnModuleInit lifecycle hook
-      expect(bootstrapModuleContent).toContain('implements OnModuleInit');
-      expect(bootstrapModuleContent).toContain('async onModuleInit()');
-    });
-
-    it('should have BootstrapModule with proper dependencies', async () => {
-      const bootstrapModuleContent = await fs.readFile(bootstrapModulePath, 'utf-8');
-      
-      // Verify required dependencies are injected
-      expect(bootstrapModuleContent).toContain('@Inject(ENSURE_INITIAL_DATA_TOKEN)');
-      expect(bootstrapModuleContent).toContain('@Inject(SEED_DEMO_USERS_TOKEN)');
-      expect(bootstrapModuleContent).toContain('@Inject(\'Logger\')');
-      expect(bootstrapModuleContent).toContain('@Inject(\'RacingSeedDependencies\')');
-    });
-
-    it('should have BootstrapModule with proper imports', async () => {
-      const bootstrapModuleContent = await fs.readFile(bootstrapModulePath, 'utf-8');
-      
-      // Verify persistence modules are imported
-      expect(bootstrapModuleContent).toContain('RacingPersistenceModule');
-      expect(bootstrapModuleContent).toContain('SocialPersistenceModule');
-      expect(bootstrapModuleContent).toContain('AchievementPersistenceModule');
-      expect(bootstrapModuleContent).toContain('IdentityPersistenceModule');
-      expect(bootstrapModuleContent).toContain('AdminPersistenceModule');
-    });
-  });
-
-  describe('Bootstrap Adapters Structure', () => {
-    it('should have EnsureInitialData adapter', async () => {
-      const ensureInitialDataPath = path.join(bootstrapAdaptersPath, 'EnsureInitialData.ts');
-      const ensureInitialDataExists = await fs.access(ensureInitialDataPath).then(() => true).catch(() => false);
-      expect(ensureInitialDataExists).toBe(true);
-    });
-
-    it('should have SeedDemoUsers adapter', async () => {
-      const seedDemoUsersPath = path.join(bootstrapAdaptersPath, 'SeedDemoUsers.ts');
-      const seedDemoUsersExists = await fs.access(seedDemoUsersPath).then(() => true).catch(() => false);
-      expect(seedDemoUsersExists).toBe(true);
-    });
-
-    it('should have SeedRacingData adapter', async () => {
-      const seedRacingDataPath = path.join(bootstrapAdaptersPath, 'SeedRacingData.ts');
-      const seedRacingDataExists = await fs.access(seedRacingDataPath).then(() => true).catch(() => false);
-      expect(seedRacingDataExists).toBe(true);
-    });
-
-    it('should have racing seed factories', async () => {
-      const racingDir = path.join(bootstrapAdaptersPath, 'racing');
-      const racingDirExists = await fs.access(racingDir).then(() => true).catch(() => false);
-      expect(racingDirExists).toBe(true);
-
-      // Verify key factory files exist
-      const racingFiles = await fs.readdir(racingDir);
-      expect(racingFiles).toContain('RacingDriverFactory.ts');
-      expect(racingFiles).toContain('RacingTeamFactory.ts');
-      expect(racingFiles).toContain('RacingLeagueFactory.ts');
-      expect(racingFiles).toContain('RacingRaceFactory.ts');
-    });
-  });
-
-  describe('Bootstrap Configuration', () => {
-    it('should have bootstrap configuration in environment', async () => {
-      const envPath = path.join(apiRoot, 'apps/api/src/env.ts');
-      const envContent = await fs.readFile(envPath, 'utf-8');
-      
-      // Verify bootstrap configuration functions exist
-      expect(envContent).toContain('getEnableBootstrap');
-      expect(envContent).toContain('getForceReseed');
-    });
-
-    it('should have bootstrap enabled by default', async () => {
-      const envPath = path.join(apiRoot, 'apps/api/src/env.ts');
-      const envContent = await fs.readFile(envPath, 'utf-8');
-      
-      // Verify bootstrap is enabled by default (for dev/test)
-      expect(envContent).toContain('GRIDPILOT_API_BOOTSTRAP');
-      expect(envContent).toContain('true'); // Default value
-    });
-  });
-
-  describe('Bootstrap Initialization Logic', () => {
-    it('should have proper initialization sequence', async () => {
-      const bootstrapModuleContent = await fs.readFile(bootstrapModulePath, 'utf-8');
-      
-      // Verify initialization sequence
-      expect(bootstrapModuleContent).toContain('await this.ensureInitialData.execute()');
-      expect(bootstrapModuleContent).toContain('await this.shouldSeedRacingData()');
-      expect(bootstrapModuleContent).toContain('await this.shouldSeedDemoUsers()');
-    });
-
-    it('should have environment-aware seeding logic', async () => {
-      const bootstrapModuleContent = await fs.readFile(bootstrapModulePath, 'utf-8');
-      
-      // Verify environment checks
-      expect(bootstrapModuleContent).toContain('process.env.NODE_ENV');
-      expect(bootstrapModuleContent).toContain('production');
-      expect(bootstrapModuleContent).toContain('inmemory');
-      expect(bootstrapModuleContent).toContain('postgres');
-    });
-
-    it('should have force reseed capability', async () => {
-      const bootstrapModuleContent = await fs.readFile(bootstrapModulePath, 'utf-8');
-      
-      // Verify force reseed logic
-      expect(bootstrapModuleContent).toContain('getForceReseed()');
-      expect(bootstrapModuleContent).toContain('Force reseed enabled');
-    });
-  });
-
-  describe('Bootstrap Data Seeding', () => {
-    it('should seed initial admin user', async () => {
-      const ensureInitialDataPath = path.join(bootstrapAdaptersPath, 'EnsureInitialData.ts');
-      const ensureInitialDataContent = await fs.readFile(ensureInitialDataPath, 'utf-8');
-      
-      // Verify admin user seeding
-      expect(ensureInitialDataContent).toContain('admin@gridpilot.local');
-      expect(ensureInitialDataContent).toContain('Admin');
-      expect(ensureInitialDataContent).toContain('signupUseCase');
-    });
-
-    it('should seed achievements', async () => {
-      const ensureInitialDataPath = path.join(bootstrapAdaptersPath, 'EnsureInitialData.ts');
-      const ensureInitialDataContent = await fs.readFile(ensureInitialDataPath, 'utf-8');
-      
-      // Verify achievement seeding
-      expect(ensureInitialDataContent).toContain('DRIVER_ACHIEVEMENTS');
-      expect(ensureInitialDataContent).toContain('STEWARD_ACHIEVEMENTS');
-      expect(ensureInitialDataContent).toContain('ADMIN_ACHIEVEMENTS');
-      expect(ensureInitialDataContent).toContain('COMMUNITY_ACHIEVEMENTS');
-      expect(ensureInitialDataContent).toContain('createAchievementUseCase');
-    });
-
-    it('should seed demo users', async () => {
-      const seedDemoUsersPath = path.join(bootstrapAdaptersPath, 'SeedDemoUsers.ts');
-      const seedDemoUsersContent = await fs.readFile(seedDemoUsersPath, 'utf-8');
-      
-      // Verify demo user seeding
-      expect(seedDemoUsersContent).toContain('SeedDemoUsers');
-      expect(seedDemoUsersContent).toContain('execute');
-    });
-
-    it('should seed racing data', async () => {
-      const seedRacingDataPath = path.join(bootstrapAdaptersPath, 'SeedRacingData.ts');
-      const seedRacingDataContent = await fs.readFile(seedRacingDataPath, 'utf-8');
-      
-      // Verify racing data seeding
-      expect(seedRacingDataContent).toContain('SeedRacingData');
-      expect(seedRacingDataContent).toContain('execute');
-      expect(seedRacingDataContent).toContain('RacingSeedDependencies');
-    });
-  });
-
-  describe('Bootstrap Providers', () => {
-    it('should have BootstrapProviders defined', async () => {
-      const bootstrapProvidersPath = path.join(apiRoot, 'apps/api/src/domain/bootstrap/BootstrapProviders.ts');
-      const bootstrapProvidersExists = await fs.access(bootstrapProvidersPath).then(() => true).catch(() => false);
-      expect(bootstrapProvidersExists).toBe(true);
-    });
-
-    it('should have proper provider tokens', async () => {
-      const bootstrapProvidersContent = await fs.readFile(
-        path.join(apiRoot, 'apps/api/src/domain/bootstrap/BootstrapProviders.ts'),
-        'utf-8'
-      );
-      
-      // Verify provider tokens are defined
-      expect(bootstrapProvidersContent).toContain('ENSURE_INITIAL_DATA_TOKEN');
-      expect(bootstrapProvidersContent).toContain('SEED_DEMO_USERS_TOKEN');
-    });
-  });
-
-  describe('Bootstrap Module Integration', () => {
-    it('should be imported in main app module', async () => {
-      const appModulePath = path.join(apiRoot, 'apps/api/src/app.module.ts');
-      const appModuleContent = await fs.readFile(appModulePath, 'utf-8');
-      
-      // Verify BootstrapModule is imported
-      expect(appModuleContent).toContain('BootstrapModule');
-      expect(appModuleContent).toContain('./domain/bootstrap/BootstrapModule');
-    });
-
-    it('should be included in app module imports', async () => {
-      const appModulePath = path.join(apiRoot, 'apps/api/src/app.module.ts');
-      const appModuleContent = await fs.readFile(appModulePath, 'utf-8');
-      
-      // Verify BootstrapModule is in imports array
-      expect(appModuleContent).toMatch(/imports:\s*\[[^\]]*BootstrapModule[^\]]*\]/s);
-    });
-  });
-
-  describe('Bootstrap Module Tests', () => {
-    it('should have unit tests for BootstrapModule', async () => {
-      const bootstrapModuleTestPath = path.join(apiRoot, 'apps/api/src/domain/bootstrap/BootstrapModule.test.ts');
-      const bootstrapModuleTestExists = await fs.access(bootstrapModuleTestPath).then(() => true).catch(() => false);
-      expect(bootstrapModuleTestExists).toBe(true);
-    });
-
-    it('should have postgres seed tests', async () => {
-      const postgresSeedTestPath = path.join(apiRoot, 'apps/api/src/domain/bootstrap/BootstrapModule.postgres-seed.test.ts');
-      const postgresSeedTestExists = await fs.access(postgresSeedTestPath).then(() => true).catch(() => false);
-      expect(postgresSeedTestExists).toBe(true);
-    });
-
-    it('should have racing seed tests', async () => {
-      const racingSeedTestPath = path.join(apiRoot, 'apps/api/src/domain/bootstrap/RacingSeed.test.ts');
-      const racingSeedTestExists = await fs.access(racingSeedTestPath).then(() => true).catch(() => false);
-      expect(racingSeedTestExists).toBe(true);
-    });
-  });
-
-  describe('Bootstrap Module Contract Summary', () => {
-    it('should document that bootstrap is an internal module', async () => {
-      const bootstrapModuleContent = await fs.readFile(bootstrapModulePath, 'utf-8');
-      
-      // Verify bootstrap is documented as internal initialization
-      expect(bootstrapModuleContent).toContain('Initializing application data');
-      expect(bootstrapModuleContent).toContain('Bootstrap disabled');
-    });
-
-    it('should have no API client in website app', async () => {
-      const websiteApiDir = path.join(apiRoot, 'apps/website/lib/api');
-      const apiFiles = await fs.readdir(websiteApiDir);
-      
-      // Verify no bootstrap API client exists
-      const bootstrapFiles = apiFiles.filter(f => f.toLowerCase().includes('bootstrap'));
-      expect(bootstrapFiles.length).toBe(0);
-    });
-
-    it('should have no bootstrap endpoints in OpenAPI', async () => {
-      const content = await fs.readFile(openapiPath, 'utf-8');
-      const spec: OpenAPISpec = JSON.parse(content);
-      
-      // Verify no bootstrap paths exist
-      const allPaths = Object.keys(spec.paths);
-      const bootstrapPaths = allPaths.filter(p => p.toLowerCase().includes('bootstrap'));
-      expect(bootstrapPaths.length).toBe(0);
-    });
-  });
-});