module cleanup

apps/api/src/domain/team/TeamService.test.ts

@@ -5,8 +5,7 @@ import { GetDriverTeamUseCase } from '@core/racing/application/use-cases/GetDriv
 import type { Logger } from '@core/shared/application/Logger';
 import { AllTeamsPresenter } from './presenters/AllTeamsPresenter';
 import { DriverTeamPresenter } from './presenters/DriverTeamPresenter';
-import { AllTeamsViewModel, DriverTeamViewModel, GetDriverTeamQuery } from './dto/TeamDto';
-import { TEAM_GET_ALL_USE_CASE_TOKEN, TEAM_GET_DRIVER_TEAM_USE_CASE_TOKEN, TEAM_LOGGER_TOKEN } from './TeamProviders';
+import { AllTeamsViewModel, DriverTeamViewModel } from './dtos/TeamDto';
 
 describe('TeamService', () => {
   let service: TeamService;
@@ -31,138 +30,72 @@ describe('TeamService', () => {
       providers: [
         TeamService,
         {
-          provide: TEAM_GET_ALL_USE_CASE_TOKEN,
+          provide: GetAllTeamsUseCase,
           useValue: mockGetAllTeamsUseCase,
         },
         {
-          provide: TEAM_GET_DRIVER_TEAM_USE_CASE_TOKEN,
+          provide: GetDriverTeamUseCase,
           useValue: mockGetDriverTeamUseCase,
         },
         {
-          provide: TEAM_LOGGER_TOKEN,
+          provide: 'Logger',
           useValue: mockLogger,
         },
       ],
     }).compile();
 
     service = module.get<TeamService>(TeamService);
-    getAllTeamsUseCase = module.get(TEAM_GET_ALL_USE_CASE_TOKEN);
-    getDriverTeamUseCase = module.get(TEAM_GET_DRIVER_TEAM_USE_CASE_TOKEN);
-    logger = module.get(TEAM_LOGGER_TOKEN);
+    getAllTeamsUseCase = module.get(GetAllTeamsUseCase);
+    getDriverTeamUseCase = module.get(GetDriverTeamUseCase);
+    logger = module.get('Logger');
   });
 
   it('should be defined', () => {
     expect(service).toBeDefined();
   });
 
-  describe('getAllTeams', () => {
-    it('should create presenter, call use case, and return view model', async () => {
-      const mockViewModel: AllTeamsViewModel = {
-        teams: [],
-        totalCount: 0,
-      };
+  describe('getAll', () => {
+    it('should call use case and return result', async () => {
+      const mockResult = { isOk: () => true, value: { teams: [], totalCount: 0 } };
+      getAllTeamsUseCase.execute.mockResolvedValue(mockResult as any);
 
       const mockPresenter = {
-        reset: jest.fn(),
         present: jest.fn(),
-        get viewModel(): AllTeamsViewModel {
-          return mockViewModel;
-        },
+        getViewModel: jest.fn().mockReturnValue({ teams: [], totalCount: 0 }),
       };
-
-      // Mock the presenter constructor
-      const originalConstructor = AllTeamsPresenter;
       (AllTeamsPresenter as any) = jest.fn().mockImplementation(() => mockPresenter);
 
-      // Mock the use case to call the presenter
-      getAllTeamsUseCase.execute.mockImplementation(async (input, presenter) => {
-        presenter.present({ teams: [] });
-      });
+      const result = await service.getAll();
 
-      const result = await service.getAllTeams();
-
-      expect(AllTeamsPresenter).toHaveBeenCalled();
-      expect(getAllTeamsUseCase.execute).toHaveBeenCalledWith(undefined, mockPresenter);
-      expect(result).toBe(mockViewModel);
-
-      // Restore
-      AllTeamsPresenter = originalConstructor;
+      expect(getAllTeamsUseCase.execute).toHaveBeenCalled();
+      expect(result).toEqual({ teams: [], totalCount: 0 });
     });
   });
 
   describe('getDriverTeam', () => {
-    it('should create presenter, call use case, and return view model', async () => {
-      const query: GetDriverTeamQuery = { teamId: 'team1', driverId: 'driver1' };
-      const mockViewModel: DriverTeamViewModel = {
-        team: {
-          id: 'team1',
-          name: 'Team 1',
-          tag: 'T1',
-          description: 'Description',
-          ownerId: 'driver1',
-          leagues: [],
-        },
-        membership: {
-          role: 'owner' as any,
-          joinedAt: new Date(),
-          isActive: true,
-        },
-        isOwner: true,
-        canManage: true,
-      };
+    it('should call use case and return result', async () => {
+      const mockResult = { isOk: () => true, value: {} };
+      getDriverTeamUseCase.execute.mockResolvedValue(mockResult as any);
 
       const mockPresenter = {
-        reset: jest.fn(),
         present: jest.fn(),
-        get viewModel(): DriverTeamViewModel {
-          return mockViewModel;
-        },
+        getViewModel: jest.fn().mockReturnValue({} as DriverTeamViewModel),
       };
-
-      // Mock the presenter constructor
-      const originalConstructor = DriverTeamPresenter;
       (DriverTeamPresenter as any) = jest.fn().mockImplementation(() => mockPresenter);
 
-      // Mock the use case to call the presenter
-      getDriverTeamUseCase.execute.mockImplementation(async (input, presenter) => {
-        presenter.present({
-          team: {
-            id: 'team1',
-            name: 'Team 1',
-            tag: 'T1',
-            description: 'Description',
-            ownerId: 'driver1',
-            leagues: [],
-          },
-          membership: {
-            role: 'owner',
-            status: 'active',
-            joinedAt: new Date(),
-          },
-          driverId: 'driver1',
-        });
-      });
+      const result = await service.getDriverTeam('driver1');
 
-      const result = await service.getDriverTeam(query);
-
-      expect(DriverTeamPresenter).toHaveBeenCalled();
-      expect(getDriverTeamUseCase.execute).toHaveBeenCalledWith({ driverId: 'driver1' }, mockPresenter);
-      expect(result).toBe(mockViewModel);
-
-      // Restore
-      DriverTeamPresenter = originalConstructor;
+      expect(getDriverTeamUseCase.execute).toHaveBeenCalledWith({ driverId: 'driver1' });
+      expect(result).toEqual({});
     });
 
     it('should return null on error', async () => {
-      const query: GetDriverTeamQuery = { teamId: 'team1', driverId: 'driver1' };
+      const mockResult = { isErr: () => true, error: {} };
+      getDriverTeamUseCase.execute.mockResolvedValue(mockResult as any);
 
-      // Mock the use case to throw an error
-      getDriverTeamUseCase.execute.mockRejectedValue(new Error('Team not found'));
-
-      const result = await service.getDriverTeam(query);
+      const result = await service.getDriverTeam('driver1');
 
       expect(result).toBeNull();
-      expect(logger.error).toHaveBeenCalled();
     });
   });
 });