fix adapters

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

@@ -0,0 +1,52 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { Logger } from '@core/shared/application';
+import { InMemoryLeagueMembershipRepository } from './InMemoryLeagueMembershipRepository';
+
+describe('InMemoryLeagueMembershipRepository', () => {
+  let repository: InMemoryLeagueMembershipRepository;
+  let logger: Logger;
+
+  beforeEach(() => {
+    logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    } as unknown as Logger;
+
+    repository = new InMemoryLeagueMembershipRepository(logger);
+  });
+
+  it('saves and queries memberships and join requests', async () => {
+    const membership: { id: string; leagueId: string; driverId: string; status: string } = {
+      id: 'm1',
+      leagueId: 'league-1',
+      driverId: 'driver-1',
+      status: 'active',
+    };
+
+    await repository.saveMembership(
+      membership as unknown as Parameters<InMemoryLeagueMembershipRepository['saveMembership']>[0],
+    );
+
+    expect((await repository.getMembership('league-1', 'driver-1'))?.id).toBe('m1');
+    expect((await repository.findActiveByLeagueIdAndDriverId('league-1', 'driver-1'))?.id).toBe('m1');
+
+    expect((await repository.findAllByLeagueId('league-1')).length).toBe(1);
+    expect((await repository.findAllByDriverId('driver-1')).length).toBe(1);
+    expect((await repository.getLeagueMembers('league-1')).length).toBe(1);
+
+    const joinRequest: { id: string; leagueId: string } = { id: 'jr1', leagueId: 'league-1' };
+    await repository.saveJoinRequest(
+      joinRequest as unknown as Parameters<InMemoryLeagueMembershipRepository['saveJoinRequest']>[0],
+    );
+
+    expect((await repository.getJoinRequests('league-1')).map(r => r.id)).toEqual(['jr1']);
+
+    await repository.removeJoinRequest('jr1');
+    expect((await repository.getJoinRequests('league-1')).length).toBe(0);
+
+    await repository.removeMembership('league-1', 'driver-1');
+    expect(await repository.getMembership('league-1', 'driver-1')).toBeNull();
+  });
+});

adapters/racing/persistence/inmemory/InMemoryStandingRepository.ts

@@ -213,10 +213,19 @@ export class InMemoryStandingRepository implements IStandingRepository {
 
       const standingsMap = new Map<string, Standing>();
 
-      results.forEach(result => {
+      const normalizePosition = (position: unknown): number => {
+        if (typeof position === 'number') return position;
+        if (typeof position === 'string') return Number(position);
+        if (position && typeof (position as { toNumber?: unknown }).toNumber === 'function') {
+          return (position as { toNumber: () => number }).toNumber();
+        }
+        return Number(position);
+      };
+
+      results.forEach((result) => {
         const driverIdStr = result.driverId.toString();
         let standing = standingsMap.get(driverIdStr);
-        
+
         if (!standing) {
           standing = Standing.create({
             leagueId,
@@ -225,7 +234,8 @@ export class InMemoryStandingRepository implements IStandingRepository {
           this.logger.debug(`Created new standing for driver ${driverIdStr} in league ${leagueId}.`);
         }
 
-        standing = standing.addRaceResult(result.position.toNumber(), resolvedPointsSystem);
+        const position = normalizePosition((result as { position: unknown }).position);
+        standing = standing.addRaceResult(position, resolvedPointsSystem);
         standingsMap.set(driverIdStr, standing);
         this.logger.debug(`Driver ${driverIdStr} in league ${leagueId} accumulated ${standing.points} points.`);
       });

adapters/racing/ports/InMemoryDriverExtendedProfileProvider.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { Logger } from '@core/shared/application';
+import { InMemoryDriverExtendedProfileProvider } from './InMemoryDriverExtendedProfileProvider';
+
+describe('InMemoryDriverExtendedProfileProvider', () => {
+  it('returns an extended profile shape', () => {
+    const logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    } as unknown as Logger;
+
+    const provider = new InMemoryDriverExtendedProfileProvider(logger);
+
+    const profile = provider.getExtendedProfile('driver-1');
+    expect(profile).not.toBeNull();
+    expect(profile?.socialHandles).toBeInstanceOf(Array);
+    expect(profile?.achievements).toBeInstanceOf(Array);
+    expect(typeof profile?.favoriteTrack).toBe('string');
+  });
+});

adapters/racing/ports/InMemoryDriverRatingProvider.test.ts

@@ -0,0 +1,25 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { Logger } from '@core/shared/application';
+import { InMemoryDriverRatingProvider } from './InMemoryDriverRatingProvider';
+
+describe('InMemoryDriverRatingProvider', () => {
+  it('returns ratings for known drivers and null for unknown', () => {
+    const logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    } as unknown as Logger;
+
+    const provider = new InMemoryDriverRatingProvider(logger);
+
+    expect(provider.getRating('driver-1')).toBe(2500);
+    expect(provider.getRating('driver-2')).toBe(2400);
+    expect(provider.getRating('driver-x')).toBeNull();
+
+    const map = provider.getRatings(['driver-1', 'driver-x', 'driver-2']);
+    expect(map.get('driver-1')).toBe(2500);
+    expect(map.get('driver-2')).toBe(2400);
+    expect(map.has('driver-x')).toBe(false);
+  });
+});

adapters/racing/services/InMemoryDriverStatsService.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { Logger } from '@core/shared/application';
+import { InMemoryDriverStatsService } from './InMemoryDriverStatsService';
+
+describe('InMemoryDriverStatsService', () => {
+  it('returns stats for known drivers', () => {
+    const logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    } as unknown as Logger;
+
+    const service = new InMemoryDriverStatsService(logger);
+
+    const stats = service.getDriverStats('driver-1');
+    expect(stats?.rating).toBe(2500);
+
+    expect(service.getDriverStats('unknown')).toBeNull();
+  });
+});

adapters/racing/services/InMemoryRankingService.test.ts

@@ -0,0 +1,21 @@
+import { describe, expect, it, vi } from 'vitest';
+import type { Logger } from '@core/shared/application';
+import { InMemoryRankingService } from './InMemoryRankingService';
+
+describe('InMemoryRankingService', () => {
+  it('returns mock rankings', () => {
+    const logger = {
+      debug: vi.fn(),
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+    } as unknown as Logger;
+
+    const service = new InMemoryRankingService(logger);
+    const rankings = service.getAllDriverRankings();
+
+    expect(rankings.length).toBeGreaterThanOrEqual(3);
+    expect(rankings[0]).toHaveProperty('driverId');
+    expect(rankings[0]).toHaveProperty('rating');
+  });
+});