wip

tests/unit/racing-application/DashboardOverviewUseCase.test.ts

@@ -1,6 +1,13 @@
 import { describe, it, expect } from 'vitest';
 
 import { GetDashboardOverviewUseCase } from '@gridpilot/racing/application/use-cases/GetDashboardOverviewUseCase';
+import { Driver } from '@gridpilot/racing/domain/entities/Driver';
+import { Race } from '@gridpilot/racing/domain/entities/Race';
+import { Result } from '@gridpilot/racing/domain/entities/Result';
+import { League } from '@gridpilot/racing/domain/entities/League';
+import { Standing } from '@gridpilot/racing/domain/entities/Standing';
+import { LeagueMembership } from '@gridpilot/racing/domain/entities/LeagueMembership';
+import type { FeedItem } from '@gridpilot/social/domain/types/FeedItem';
 import type {
   IDashboardOverviewPresenter,
   DashboardOverviewViewModel,
@@ -25,11 +32,17 @@ class FakeDashboardOverviewPresenter implements IDashboardOverviewPresenter {
 
 interface TestImageService {
   getDriverAvatar(driverId: string): string;
+  getTeamLogo(teamId: string): string;
+  getLeagueCover(leagueId: string): string;
+  getLeagueLogo(leagueId: string): string;
 }
 
 function createTestImageService(): TestImageService {
   return {
     getDriverAvatar: (driverId: string) => `avatar-${driverId}`,
+    getTeamLogo: (teamId: string) => `team-logo-${teamId}`,
+    getLeagueCover: (leagueId: string) => `league-cover-${leagueId}`,
+    getLeagueLogo: (leagueId: string) => `league-logo-${leagueId}`,
   };
 }
 
@@ -38,143 +51,173 @@ describe('GetDashboardOverviewUseCase', () => {
     // Given a driver with memberships in two leagues and future races with mixed registration
     const driverId = 'driver-1';
 
-    const driver = { id: driverId, name: 'Alice Racer', country: 'US' };
+    const driver = Driver.create({ id: driverId, iracingId: '12345', name: 'Alice Racer', country: 'US' });
 
     const leagues = [
-      { id: 'league-1', name: 'Alpha League' },
-      { id: 'league-2', name: 'Beta League' },
+      League.create({ id: 'league-1', name: 'Alpha League', description: 'First league', ownerId: 'owner-1' }),
+      League.create({ id: 'league-2', name: 'Beta League', description: 'Second league', ownerId: 'owner-2' }),
     ];
 
     const now = Date.now();
 
     const races = [
-      {
+      Race.create({
         id: 'race-1',
         leagueId: 'league-1',
         track: 'Monza',
         car: 'GT3',
         scheduledAt: new Date(now + 60 * 60 * 1000),
-        status: 'scheduled' as const,
-      },
-      {
+        status: 'scheduled',
+      }),
+      Race.create({
         id: 'race-2',
         leagueId: 'league-1',
         track: 'Spa',
         car: 'GT3',
         scheduledAt: new Date(now + 2 * 60 * 60 * 1000),
-        status: 'scheduled' as const,
-      },
-      {
+        status: 'scheduled',
+      }),
+      Race.create({
         id: 'race-3',
         leagueId: 'league-2',
         track: 'Silverstone',
         car: 'GT4',
         scheduledAt: new Date(now + 3 * 60 * 60 * 1000),
-        status: 'scheduled' as const,
-      },
-      {
+        status: 'scheduled',
+      }),
+      Race.create({
         id: 'race-4',
         leagueId: 'league-2',
         track: 'Imola',
         car: 'GT4',
         scheduledAt: new Date(now + 4 * 60 * 60 * 1000),
-        status: 'scheduled' as const,
-      },
+        status: 'scheduled',
+      }),
     ];
 
-    const results: unknown[] = [];
+    const results: Result[] = [];
 
     const memberships = [
-      {
+      LeagueMembership.create({
         leagueId: 'league-1',
         driverId,
+        role: 'member',
         status: 'active',
-      },
-      {
+      }),
+      LeagueMembership.create({
         leagueId: 'league-2',
         driverId,
+        role: 'member',
         status: 'active',
-      },
+      }),
     ];
 
     const registeredRaceIds = new Set<string>(['race-1', 'race-3']);
 
-    const feedItems: DashboardFeedItemSummaryViewModel[] = [];
-    const friends: Array<{ id: string }> = [];
+    const feedItems: FeedItem[] = [];
+    const friends: Driver[] = [];
  
-    const driverRepository: {
-      findById: (id: string) => Promise<{ id: string; name: string; country: string } | null>;
-    } = {
-      findById: async (id: string) => (id === driver.id ? driver : null),
+    const driverRepository = {
+      findById: async (id: string): Promise<Driver | null> => (id === driver.id ? driver : null),
+      findByIRacingId: async (): Promise<Driver | null> => null,
+      findAll: async (): Promise<Driver[]> => [],
+      create: async (): Promise<Driver> => { throw new Error('Not implemented'); },
+      update: async (): Promise<Driver> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
+      existsByIRacingId: async (): Promise<boolean> => false,
     };
  
-    const raceRepository: {
-      findAll: () => Promise<
-        Array<{
-          id: string;
-          leagueId: string;
-          track: string;
-          car: string;
-          scheduledAt: Date;
-          status: 'scheduled';
-        }>
-      >;
-    } = {
-      findAll: async () => races,
+    const raceRepository = {
+      findById: async (): Promise<Race | null> => null,
+      findAll: async (): Promise<Race[]> => races,
+      findByLeagueId: async (): Promise<Race[]> => [],
+      findUpcomingByLeagueId: async (): Promise<Race[]> => [],
+      findCompletedByLeagueId: async (): Promise<Race[]> => [],
+      findByStatus: async (): Promise<Race[]> => [],
+      findByDateRange: async (): Promise<Race[]> => [],
+      create: async (): Promise<Race> => { throw new Error('Not implemented'); },
+      update: async (): Promise<Race> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
     };
  
-    const resultRepository: {
-      findAll: () => Promise<unknown[]>;
-    } = {
-      findAll: async () => results,
+    const resultRepository = {
+      findById: async (): Promise<Result | null> => null,
+      findAll: async (): Promise<Result[]> => results,
+      findByRaceId: async (): Promise<Result[]> => [],
+      findByDriverId: async (): Promise<Result[]> => [],
+      findByDriverIdAndLeagueId: async (): Promise<Result[]> => [],
+      create: async (): Promise<Result> => { throw new Error('Not implemented'); },
+      createMany: async (): Promise<Result[]> => { throw new Error('Not implemented'); },
+      update: async (): Promise<Result> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      deleteByRaceId: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
+      existsByRaceId: async (): Promise<boolean> => false,
     };
  
-    const leagueRepository: {
-      findAll: () => Promise<Array<{ id: string; name: string }>>;
-    } = {
-      findAll: async () => leagues,
+    const leagueRepository = {
+      findById: async (): Promise<League | null> => null,
+      findAll: async (): Promise<League[]> => leagues,
+      findByOwnerId: async (): Promise<League[]> => [],
+      create: async (): Promise<League> => { throw new Error('Not implemented'); },
+      update: async (): Promise<League> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
+      searchByName: async (): Promise<League[]> => [],
     };
  
-    const standingRepository: {
-      findByLeagueId: (leagueId: string) => Promise<unknown[]>;
-    } = {
-      findByLeagueId: async () => [],
+    const standingRepository = {
+      findByLeagueId: async (): Promise<Standing[]> => [],
+      findByDriverIdAndLeagueId: async (): Promise<Standing | null> => null,
+      findAll: async (): Promise<Standing[]> => [],
+      save: async (): Promise<Standing> => { throw new Error('Not implemented'); },
+      saveMany: async (): Promise<Standing[]> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      deleteByLeagueId: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
+      recalculate: async (): Promise<Standing[]> => [],
     };
  
-    const leagueMembershipRepository: {
-      getMembership: (
-        leagueId: string,
-        driverIdParam: string,
-      ) => Promise<{ leagueId: string; driverId: string; status: string } | null>;
-    } = {
-      getMembership: async (leagueId: string, driverIdParam: string) => {
+    const leagueMembershipRepository = {
+      getMembership: async (leagueId: string, driverIdParam: string): Promise<LeagueMembership | null> => {
         return (
           memberships.find(
             (m) => m.leagueId === leagueId && m.driverId === driverIdParam,
           ) ?? null
         );
       },
+      getLeagueMembers: async (): Promise<LeagueMembership[]> => [],
+      getJoinRequests: async (): Promise<any[]> => [],
+      saveMembership: async (): Promise<LeagueMembership> => { throw new Error('Not implemented'); },
+      removeMembership: async (): Promise<void> => { throw new Error('Not implemented'); },
+      saveJoinRequest: async (): Promise<any> => { throw new Error('Not implemented'); },
+      removeJoinRequest: async (): Promise<void> => { throw new Error('Not implemented'); },
     };
  
-    const raceRegistrationRepository: {
-      isRegistered: (raceId: string, driverIdParam: string) => Promise<boolean>;
-    } = {
-      isRegistered: async (raceId: string, driverIdParam: string) => {
+    const raceRegistrationRepository = {
+      isRegistered: async (raceId: string, driverIdParam: string): Promise<boolean> => {
         if (driverIdParam !== driverId) return false;
         return registeredRaceIds.has(raceId);
       },
+      getRegisteredDrivers: async (): Promise<string[]> => [],
+      getRegistrationCount: async (): Promise<number> => 0,
+      register: async (): Promise<void> => { throw new Error('Not implemented'); },
+      withdraw: async (): Promise<void> => { throw new Error('Not implemented'); },
+      getDriverRegistrations: async (): Promise<string[]> => [],
+      clearRaceRegistrations: async (): Promise<void> => { throw new Error('Not implemented'); },
     };
  
-    const feedRepository: {
-      getFeedForDriver: (driverIdParam: string) => Promise<DashboardFeedItemSummaryViewModel[]>;
-    } = {
-      getFeedForDriver: async () => feedItems,
+    const feedRepository = {
+      getFeedForDriver: async (): Promise<FeedItem[]> => feedItems,
+      getGlobalFeed: async (): Promise<FeedItem[]> => [],
     };
  
-    const socialRepository: {
-      getFriends: (driverIdParam: string) => Promise<Array<{ id: string }>>;
-    } = {
-      getFriends: async () => friends,
+    const socialRepository = {
+      getFriends: async (): Promise<Driver[]> => friends,
+      getFriendIds: async (): Promise<string[]> => [],
+      getSuggestedFriends: async (): Promise<Driver[]> => [],
     };
 
     const imageService = createTestImageService();
@@ -230,138 +273,181 @@ describe('GetDashboardOverviewUseCase', () => {
     // Given completed races with results and standings
     const driverId = 'driver-2';
 
-    const driver = { id: driverId, name: 'Result Driver', country: 'DE' };
+    const driver = Driver.create({ id: driverId, iracingId: '67890', name: 'Result Driver', country: 'DE' });
 
     const leagues = [
-      { id: 'league-A', name: 'Results League A' },
-      { id: 'league-B', name: 'Results League B' },
+      League.create({ id: 'league-A', name: 'Results League A', description: 'League A', ownerId: 'owner-A' }),
+      League.create({ id: 'league-B', name: 'Results League B', description: 'League B', ownerId: 'owner-B' }),
     ];
 
-    const raceOld = {
+    const raceOld = Race.create({
       id: 'race-old',
       leagueId: 'league-A',
       track: 'Old Circuit',
       car: 'GT3',
       scheduledAt: new Date('2024-01-01T10:00:00Z'),
-      status: 'completed' as const,
-    };
+      status: 'completed',
+    });
 
-    const raceNew = {
+    const raceNew = Race.create({
       id: 'race-new',
       leagueId: 'league-B',
       track: 'New Circuit',
       car: 'GT4',
       scheduledAt: new Date('2024-02-01T10:00:00Z'),
-      status: 'completed' as const,
-    };
+      status: 'completed',
+    });
 
     const races = [raceOld, raceNew];
 
     const results = [
-      {
+      Result.create({
         id: 'result-old',
         raceId: raceOld.id,
         driverId,
         position: 5,
+        fastestLap: 120,
         incidents: 3,
-      },
-      {
+        startPosition: 5,
+      }),
+      Result.create({
         id: 'result-new',
         raceId: raceNew.id,
         driverId,
         position: 2,
+        fastestLap: 115,
         incidents: 1,
-      },
+        startPosition: 2,
+      }),
     ];
 
     const memberships = [
-      {
+      LeagueMembership.create({
         leagueId: 'league-A',
         driverId,
+        role: 'member',
         status: 'active',
-      },
-      {
+      }),
+      LeagueMembership.create({
         leagueId: 'league-B',
         driverId,
+        role: 'member',
         status: 'active',
-      },
+      }),
     ];
 
     const standingsByLeague = new Map<
       string,
-      Array<{ leagueId: string; driverId: string; position: number; points: number }>
+      Standing[]
     >();
     standingsByLeague.set('league-A', [
-      { leagueId: 'league-A', driverId, position: 3, points: 50 },
-      { leagueId: 'league-A', driverId: 'other-1', position: 1, points: 80 },
+      Standing.create({ leagueId: 'league-A', driverId, position: 3, points: 50 }),
+      Standing.create({ leagueId: 'league-A', driverId: 'other-1', position: 1, points: 80 }),
     ]);
     standingsByLeague.set('league-B', [
-      { leagueId: 'league-B', driverId, position: 1, points: 100 },
-      { leagueId: 'league-B', driverId: 'other-2', position: 2, points: 90 },
+      Standing.create({ leagueId: 'league-B', driverId, position: 1, points: 100 }),
+      Standing.create({ leagueId: 'league-B', driverId: 'other-2', position: 2, points: 90 }),
     ]);
 
-    const driverRepository: {
-      findById: (id: string) => Promise<{ id: string; name: string; country: string } | null>;
-    } = {
-      findById: async (id: string) => (id === driver.id ? driver : null),
+    const driverRepository = {
+      findById: async (id: string): Promise<Driver | null> => (id === driver.id ? driver : null),
+      findByIRacingId: async (): Promise<Driver | null> => null,
+      findAll: async (): Promise<Driver[]> => [],
+      create: async (): Promise<Driver> => { throw new Error('Not implemented'); },
+      update: async (): Promise<Driver> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
+      existsByIRacingId: async (): Promise<boolean> => false,
     };
  
-    const raceRepository: {
-      findAll: () => Promise<typeof races>;
-    } = {
-      findAll: async () => races,
+    const raceRepository = {
+      findById: async (): Promise<Race | null> => null,
+      findAll: async (): Promise<Race[]> => races,
+      findByLeagueId: async (): Promise<Race[]> => [],
+      findUpcomingByLeagueId: async (): Promise<Race[]> => [],
+      findCompletedByLeagueId: async (): Promise<Race[]> => [],
+      findByStatus: async (): Promise<Race[]> => [],
+      findByDateRange: async (): Promise<Race[]> => [],
+      create: async (): Promise<Race> => { throw new Error('Not implemented'); },
+      update: async (): Promise<Race> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
     };
  
-    const resultRepository: {
-      findAll: () => Promise<typeof results>;
-    } = {
-      findAll: async () => results,
+    const resultRepository = {
+      findById: async (): Promise<Result | null> => null,
+      findAll: async (): Promise<Result[]> => results,
+      findByRaceId: async (): Promise<Result[]> => [],
+      findByDriverId: async (): Promise<Result[]> => [],
+      findByDriverIdAndLeagueId: async (): Promise<Result[]> => [],
+      create: async (): Promise<Result> => { throw new Error('Not implemented'); },
+      createMany: async (): Promise<Result[]> => { throw new Error('Not implemented'); },
+      update: async (): Promise<Result> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      deleteByRaceId: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
+      existsByRaceId: async (): Promise<boolean> => false,
     };
  
-    const leagueRepository: {
-      findAll: () => Promise<typeof leagues>;
-    } = {
-      findAll: async () => leagues,
+    const leagueRepository = {
+      findById: async (): Promise<League | null> => null,
+      findAll: async (): Promise<League[]> => leagues,
+      findByOwnerId: async (): Promise<League[]> => [],
+      create: async (): Promise<League> => { throw new Error('Not implemented'); },
+      update: async (): Promise<League> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
+      searchByName: async (): Promise<League[]> => [],
     };
  
-    const standingRepository: {
-      findByLeagueId: (leagueId: string) => Promise<Array<{ leagueId: string; driverId: string; position: number; points: number }>>;
-    } = {
-      findByLeagueId: async (leagueId: string) =>
+    const standingRepository = {
+      findByLeagueId: async (leagueId: string): Promise<Standing[]> =>
         standingsByLeague.get(leagueId) ?? [],
+      findByDriverIdAndLeagueId: async (): Promise<Standing | null> => null,
+      findAll: async (): Promise<Standing[]> => [],
+      save: async (): Promise<Standing> => { throw new Error('Not implemented'); },
+      saveMany: async (): Promise<Standing[]> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      deleteByLeagueId: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
+      recalculate: async (): Promise<Standing[]> => [],
     };
  
-    const leagueMembershipRepository: {
-      getMembership: (
-        leagueId: string,
-        driverIdParam: string,
-      ) => Promise<{ leagueId: string; driverId: string; status: string } | null>;
-    } = {
-      getMembership: async (leagueId: string, driverIdParam: string) => {
+    const leagueMembershipRepository = {
+      getMembership: async (leagueId: string, driverIdParam: string): Promise<LeagueMembership | null> => {
         return (
           memberships.find(
             (m) => m.leagueId === leagueId && m.driverId === driverIdParam,
           ) ?? null
         );
       },
+      getLeagueMembers: async (): Promise<LeagueMembership[]> => [],
+      getJoinRequests: async (): Promise<any[]> => [],
+      saveMembership: async (): Promise<LeagueMembership> => { throw new Error('Not implemented'); },
+      removeMembership: async (): Promise<void> => { throw new Error('Not implemented'); },
+      saveJoinRequest: async (): Promise<any> => { throw new Error('Not implemented'); },
+      removeJoinRequest: async (): Promise<void> => { throw new Error('Not implemented'); },
     };
  
-    const raceRegistrationRepository: {
-      isRegistered: (raceId: string, driverIdParam: string) => Promise<boolean>;
-    } = {
-      isRegistered: async () => false,
+    const raceRegistrationRepository = {
+      isRegistered: async (): Promise<boolean> => false,
+      getRegisteredDrivers: async (): Promise<string[]> => [],
+      getRegistrationCount: async (): Promise<number> => 0,
+      register: async (): Promise<void> => { throw new Error('Not implemented'); },
+      withdraw: async (): Promise<void> => { throw new Error('Not implemented'); },
+      getDriverRegistrations: async (): Promise<string[]> => [],
+      clearRaceRegistrations: async (): Promise<void> => { throw new Error('Not implemented'); },
     };
  
-    const feedRepository: {
-      getFeedForDriver: (driverIdParam: string) => Promise<DashboardFeedItemSummaryViewModel[]>;
-    } = {
-      getFeedForDriver: async () => [],
+    const feedRepository = {
+      getFeedForDriver: async (): Promise<FeedItem[]> => [],
+      getGlobalFeed: async (): Promise<FeedItem[]> => [],
     };
  
-    const socialRepository: {
-      getFriends: (driverIdParam: string) => Promise<Array<{ id: string }>>;
-    } = {
-      getFriends: async () => [],
+    const socialRepository = {
+      getFriends: async (): Promise<Driver[]> => [],
+      getFriendIds: async (): Promise<string[]> => [],
+      getSuggestedFriends: async (): Promise<Driver[]> => [],
     };
 
     const imageService = createTestImageService();
@@ -430,54 +516,100 @@ describe('GetDashboardOverviewUseCase', () => {
     // Given a driver with no related data
     const driverId = 'driver-empty';
 
-    const driver = { id: driverId, name: 'New Racer', country: 'FR' };
+    const driver = Driver.create({ id: driverId, iracingId: '11111', name: 'New Racer', country: 'FR' });
 
-    const driverRepository: {
-      findById: (id: string) => Promise<{ id: string; name: string; country: string } | null>;
-    } = {
-      findById: async (id: string) => (id === driver.id ? driver : null),
+    const driverRepository = {
+      findById: async (id: string): Promise<Driver | null> => (id === driver.id ? driver : null),
+      findByIRacingId: async (): Promise<Driver | null> => null,
+      findAll: async (): Promise<Driver[]> => [],
+      create: async (): Promise<Driver> => { throw new Error('Not implemented'); },
+      update: async (): Promise<Driver> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
+      existsByIRacingId: async (): Promise<boolean> => false,
     };
  
-    const raceRepository: { findAll: () => Promise<never[]> } = {
-      findAll: async () => [],
+    const raceRepository = {
+      findById: async (): Promise<Race | null> => null,
+      findAll: async (): Promise<Race[]> => [],
+      findByLeagueId: async (): Promise<Race[]> => [],
+      findUpcomingByLeagueId: async (): Promise<Race[]> => [],
+      findCompletedByLeagueId: async (): Promise<Race[]> => [],
+      findByStatus: async (): Promise<Race[]> => [],
+      findByDateRange: async (): Promise<Race[]> => [],
+      create: async (): Promise<Race> => { throw new Error('Not implemented'); },
+      update: async (): Promise<Race> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
     };
  
-    const resultRepository: { findAll: () => Promise<never[]> } = {
-      findAll: async () => [],
+    const resultRepository = {
+      findById: async (): Promise<Result | null> => null,
+      findAll: async (): Promise<Result[]> => [],
+      findByRaceId: async (): Promise<Result[]> => [],
+      findByDriverId: async (): Promise<Result[]> => [],
+      findByDriverIdAndLeagueId: async (): Promise<Result[]> => [],
+      create: async (): Promise<Result> => { throw new Error('Not implemented'); },
+      createMany: async (): Promise<Result[]> => { throw new Error('Not implemented'); },
+      update: async (): Promise<Result> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      deleteByRaceId: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
+      existsByRaceId: async (): Promise<boolean> => false,
     };
  
-    const leagueRepository: { findAll: () => Promise<never[]> } = {
-      findAll: async () => [],
+    const leagueRepository = {
+      findById: async (): Promise<League | null> => null,
+      findAll: async (): Promise<League[]> => [],
+      findByOwnerId: async (): Promise<League[]> => [],
+      create: async (): Promise<League> => { throw new Error('Not implemented'); },
+      update: async (): Promise<League> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
+      searchByName: async (): Promise<League[]> => [],
     };
  
-    const standingRepository: {
-      findByLeagueId: (leagueId: string) => Promise<never[]>;
-    } = {
-      findByLeagueId: async () => [],
+    const standingRepository = {
+      findByLeagueId: async (): Promise<Standing[]> => [],
+      findByDriverIdAndLeagueId: async (): Promise<Standing | null> => null,
+      findAll: async (): Promise<Standing[]> => [],
+      save: async (): Promise<Standing> => { throw new Error('Not implemented'); },
+      saveMany: async (): Promise<Standing[]> => { throw new Error('Not implemented'); },
+      delete: async (): Promise<void> => { throw new Error('Not implemented'); },
+      deleteByLeagueId: async (): Promise<void> => { throw new Error('Not implemented'); },
+      exists: async (): Promise<boolean> => false,
+      recalculate: async (): Promise<Standing[]> => [],
     };
  
-    const leagueMembershipRepository: {
-      getMembership: (leagueId: string, driverIdParam: string) => Promise<null>;
-    } = {
-      getMembership: async () => null,
+    const leagueMembershipRepository = {
+      getMembership: async (): Promise<LeagueMembership | null> => null,
+      getLeagueMembers: async (): Promise<LeagueMembership[]> => [],
+      getJoinRequests: async (): Promise<any[]> => [],
+      saveMembership: async (): Promise<LeagueMembership> => { throw new Error('Not implemented'); },
+      removeMembership: async (): Promise<void> => { throw new Error('Not implemented'); },
+      saveJoinRequest: async (): Promise<any> => { throw new Error('Not implemented'); },
+      removeJoinRequest: async (): Promise<void> => { throw new Error('Not implemented'); },
     };
  
-    const raceRegistrationRepository: {
-      isRegistered: (raceId: string, driverIdParam: string) => Promise<boolean>;
-    } = {
-      isRegistered: async () => false,
+    const raceRegistrationRepository = {
+      isRegistered: async (): Promise<boolean> => false,
+      getRegisteredDrivers: async (): Promise<string[]> => [],
+      getRegistrationCount: async (): Promise<number> => 0,
+      register: async (): Promise<void> => { throw new Error('Not implemented'); },
+      withdraw: async (): Promise<void> => { throw new Error('Not implemented'); },
+      getDriverRegistrations: async (): Promise<string[]> => [],
+      clearRaceRegistrations: async (): Promise<void> => { throw new Error('Not implemented'); },
     };
  
-    const feedRepository: {
-      getFeedForDriver: (driverIdParam: string) => Promise<DashboardFeedItemSummaryViewModel[]>;
-    } = {
-      getFeedForDriver: async () => [],
+    const feedRepository = {
+      getFeedForDriver: async (): Promise<FeedItem[]> => [],
+      getGlobalFeed: async (): Promise<FeedItem[]> => [],
     };
  
-    const socialRepository: {
-      getFriends: (driverIdParam: string) => Promise<Array<{ id: string }>>;
-    } = {
-      getFriends: async () => [],
+    const socialRepository = {
+      getFriends: async (): Promise<Driver[]> => [],
+      getFriendIds: async (): Promise<string[]> => [],
+      getSuggestedFriends: async (): Promise<Driver[]> => [],
     };
 
     const imageService = createTestImageService();