code quality

core/leaderboards/application/use-cases/GetDriverRankingsUseCase.test.ts

@@ -1,14 +1,16 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { GetDriverRankingsUseCase, GetDriverRankingsUseCasePorts } from './GetDriverRankingsUseCase';
 import { ValidationError } from '../../../shared/errors/ValidationError';
+import { LeaderboardsRepository, LeaderboardDriverData } from '../ports/LeaderboardsRepository';
+import { LeaderboardsEventPublisher } from '../ports/LeaderboardsEventPublisher';
 
 describe('GetDriverRankingsUseCase', () => {
-  let mockLeaderboardsRepository: any;
-  let mockEventPublisher: any;
+  let mockLeaderboardsRepository: LeaderboardsRepository;
+  let mockEventPublisher: LeaderboardsEventPublisher;
   let ports: GetDriverRankingsUseCasePorts;
   let useCase: GetDriverRankingsUseCase;
 
-  const mockDrivers = [
+  const mockDrivers: LeaderboardDriverData[] = [
     { id: '1', name: 'Alice', rating: 2000, raceCount: 10, teamId: 't1', teamName: 'Team A' },
     { id: '2', name: 'Bob', rating: 1500, raceCount: 5, teamId: 't2', teamName: 'Team B' },
     { id: '3', name: 'Charlie', rating: 1800, raceCount: 8 },
@@ -17,10 +19,14 @@ describe('GetDriverRankingsUseCase', () => {
   beforeEach(() => {
     mockLeaderboardsRepository = {
       findAllDrivers: vi.fn().mockResolvedValue([...mockDrivers]),
+      findAllTeams: vi.fn(),
+      findDriversByTeamId: vi.fn(),
     };
     mockEventPublisher = {
       publishDriverRankingsAccessed: vi.fn().mockResolvedValue(undefined),
       publishLeaderboardsError: vi.fn().mockResolvedValue(undefined),
+      publishGlobalLeaderboardsAccessed: vi.fn(),
+      publishTeamRankingsAccessed: vi.fn(),
     };
     ports = {
       leaderboardsRepository: mockLeaderboardsRepository,
@@ -92,6 +98,6 @@ describe('GetDriverRankingsUseCase', () => {
   });
 
   it('should throw ValidationError for invalid sortBy', async () => {
-    await expect(useCase.execute({ sortBy: 'invalid' as any })).rejects.toThrow(ValidationError);
+    await expect(useCase.execute({ sortBy: 'invalid' as unknown as 'name' })).rejects.toThrow(ValidationError);
   });
 });

core/leaderboards/application/use-cases/GetGlobalLeaderboardsUseCase.test.ts

@@ -1,30 +1,35 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, Mock } from 'vitest';
 import { GetGlobalLeaderboardsUseCase, GetGlobalLeaderboardsUseCasePorts } from './GetGlobalLeaderboardsUseCase';
+import { LeaderboardsRepository, LeaderboardDriverData, LeaderboardTeamData } from '../ports/LeaderboardsRepository';
+import { LeaderboardsEventPublisher } from '../ports/LeaderboardsEventPublisher';
 
 describe('GetGlobalLeaderboardsUseCase', () => {
-  let mockLeaderboardsRepository: any;
-  let mockEventPublisher: any;
+  let mockLeaderboardsRepository: LeaderboardsRepository;
+  let mockEventPublisher: LeaderboardsEventPublisher;
   let ports: GetGlobalLeaderboardsUseCasePorts;
   let useCase: GetGlobalLeaderboardsUseCase;
 
-  const mockDrivers = [
+  const mockDrivers: LeaderboardDriverData[] = [
     { id: 'd1', name: 'Alice', rating: 2000, raceCount: 10 },
     { id: 'd2', name: 'Bob', rating: 1500, raceCount: 5 },
   ];
 
-  const mockTeams = [
+  const mockTeams: LeaderboardTeamData[] = [
     { id: 't1', name: 'Team A', rating: 2500, memberCount: 5, raceCount: 20 },
     { id: 't2', name: 'Team B', rating: 2200, memberCount: 3, raceCount: 15 },
   ];
 
   beforeEach(() => {
     mockLeaderboardsRepository = {
-      findAllDrivers: vi.fn().mockResolvedValue([...mockDrivers]),
-      findAllTeams: vi.fn().mockResolvedValue([...mockTeams]),
+      findAllDrivers: vi.fn().mockResolvedValue([...mockDrivers]) as unknown as Mock,
+      findAllTeams: vi.fn().mockResolvedValue([...mockTeams]) as unknown as Mock,
+      findDriversByTeamId: vi.fn() as unknown as Mock,
     };
     mockEventPublisher = {
-      publishGlobalLeaderboardsAccessed: vi.fn().mockResolvedValue(undefined),
-      publishLeaderboardsError: vi.fn().mockResolvedValue(undefined),
+      publishGlobalLeaderboardsAccessed: vi.fn().mockResolvedValue(undefined) as unknown as Mock,
+      publishLeaderboardsError: vi.fn().mockResolvedValue(undefined) as unknown as Mock,
+      publishDriverRankingsAccessed: vi.fn() as unknown as Mock,
+      publishTeamRankingsAccessed: vi.fn() as unknown as Mock,
     };
     ports = {
       leaderboardsRepository: mockLeaderboardsRepository,
@@ -57,7 +62,7 @@ describe('GetGlobalLeaderboardsUseCase', () => {
   });
 
   it('should handle errors and publish error event', async () => {
-    mockLeaderboardsRepository.findAllDrivers.mockRejectedValue(new Error('Repo error'));
+    (mockLeaderboardsRepository.findAllDrivers as Mock).mockRejectedValue(new Error('Repo error'));
 
     await expect(useCase.execute()).rejects.toThrow('Repo error');
     expect(mockEventPublisher.publishLeaderboardsError).toHaveBeenCalled();

core/leaderboards/application/use-cases/GetTeamRankingsUseCase.test.ts

@@ -1,19 +1,21 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, Mock } from 'vitest';
 import { GetTeamRankingsUseCase, GetTeamRankingsUseCasePorts } from './GetTeamRankingsUseCase';
 import { ValidationError } from '../../../shared/errors/ValidationError';
+import { LeaderboardsRepository, LeaderboardTeamData, LeaderboardDriverData } from '../ports/LeaderboardsRepository';
+import { LeaderboardsEventPublisher } from '../ports/LeaderboardsEventPublisher';
 
 describe('GetTeamRankingsUseCase', () => {
-  let mockLeaderboardsRepository: any;
-  let mockEventPublisher: any;
+  let mockLeaderboardsRepository: LeaderboardsRepository;
+  let mockEventPublisher: LeaderboardsEventPublisher;
   let ports: GetTeamRankingsUseCasePorts;
   let useCase: GetTeamRankingsUseCase;
 
-  const mockTeams = [
+  const mockTeams: LeaderboardTeamData[] = [
     { id: 't1', name: 'Team A', rating: 2500, memberCount: 0, raceCount: 20 },
     { id: 't2', name: 'Team B', rating: 2200, memberCount: 0, raceCount: 15 },
   ];
 
-  const mockDrivers = [
+  const mockDrivers: LeaderboardDriverData[] = [
     { id: 'd1', name: 'Alice', rating: 2000, raceCount: 10, teamId: 't1', teamName: 'Team A' },
     { id: 'd2', name: 'Bob', rating: 1500, raceCount: 5, teamId: 't1', teamName: 'Team A' },
     { id: 'd3', name: 'Charlie', rating: 1800, raceCount: 8, teamId: 't2', teamName: 'Team B' },
@@ -22,12 +24,15 @@ describe('GetTeamRankingsUseCase', () => {
 
   beforeEach(() => {
     mockLeaderboardsRepository = {
-      findAllTeams: vi.fn().mockResolvedValue([...mockTeams]),
-      findAllDrivers: vi.fn().mockResolvedValue([...mockDrivers]),
+      findAllTeams: vi.fn().mockResolvedValue([...mockTeams]) as unknown as Mock,
+      findAllDrivers: vi.fn().mockResolvedValue([...mockDrivers]) as unknown as Mock,
+      findDriversByTeamId: vi.fn() as unknown as Mock,
     };
     mockEventPublisher = {
-      publishTeamRankingsAccessed: vi.fn().mockResolvedValue(undefined),
-      publishLeaderboardsError: vi.fn().mockResolvedValue(undefined),
+      publishTeamRankingsAccessed: vi.fn().mockResolvedValue(undefined) as unknown as Mock,
+      publishLeaderboardsError: vi.fn().mockResolvedValue(undefined) as unknown as Mock,
+      publishGlobalLeaderboardsAccessed: vi.fn() as unknown as Mock,
+      publishDriverRankingsAccessed: vi.fn() as unknown as Mock,
     };
     ports = {
       leaderboardsRepository: mockLeaderboardsRepository,

core/leaderboards/application/use-cases/GetTeamRankingsUseCase.ts

@@ -19,6 +19,14 @@ export interface GetTeamRankingsUseCasePorts {
   eventPublisher: LeaderboardsEventPublisher;
 }
 
+interface DiscoveredTeam {
+  id: string;
+  name: string;
+  rating: number;
+  memberCount: number;
+  raceCount: number;
+}
+
 export class GetTeamRankingsUseCase {
   constructor(private readonly ports: GetTeamRankingsUseCasePorts) {}
 
@@ -56,7 +64,7 @@ export class GetTeamRankingsUseCase {
       });
 
       // Discover teams that only exist in the drivers repository
-      const discoveredTeams: any[] = [];
+      const discoveredTeams: DiscoveredTeam[] = [];
       driverCounts.forEach((count, teamId) => {
         if (!allTeams.some(t => t.id === teamId)) {
           const driverWithTeam = allDrivers.find(d => d.teamId === teamId);