view models

apps/website/lib/services/teams/TeamService.test.ts

@@ -0,0 +1,205 @@
+import { describe, it, expect, vi, Mocked } from 'vitest';
+import { TeamService } from './TeamService';
+import { TeamsApiClient } from '../../api/teams/TeamsApiClient';
+import { TeamSummaryViewModel } from '../../view-models/TeamSummaryViewModel';
+import { TeamDetailsViewModel } from '../../view-models/TeamDetailsViewModel';
+import { TeamMemberViewModel } from '../../view-models/TeamMemberViewModel';
+
+describe('TeamService', () => {
+  let mockApiClient: Mocked<TeamsApiClient>;
+  let service: TeamService;
+
+  beforeEach(() => {
+    mockApiClient = {
+      getAll: vi.fn(),
+      getDetails: vi.fn(),
+      getMembers: vi.fn(),
+      create: vi.fn(),
+      update: vi.fn(),
+      getDriverTeam: vi.fn(),
+    } as Mocked<TeamsApiClient>;
+
+    service = new TeamService(mockApiClient);
+  });
+
+  describe('getAllTeams', () => {
+    it('should call apiClient.getAll and return array of TeamSummaryViewModel', async () => {
+      const mockDto = {
+        teams: [
+          {
+            id: 'team-1',
+            name: 'Test Team',
+            logoUrl: 'https://example.com/logo.png',
+            memberCount: 5,
+            rating: 1500,
+          },
+        ],
+      };
+
+      mockApiClient.getAll.mockResolvedValue(mockDto);
+
+      const result = await service.getAllTeams();
+
+      expect(mockApiClient.getAll).toHaveBeenCalled();
+      expect(result).toHaveLength(1);
+      expect(result[0]).toBeInstanceOf(TeamSummaryViewModel);
+      expect(result[0].id).toBe('team-1');
+      expect(result[0].name).toBe('Test Team');
+    });
+
+    it('should throw error when apiClient.getAll fails', async () => {
+      const error = new Error('API call failed');
+      mockApiClient.getAll.mockRejectedValue(error);
+
+      await expect(service.getAllTeams()).rejects.toThrow('API call failed');
+    });
+  });
+
+  describe('getTeamDetails', () => {
+    it('should call apiClient.getDetails and return TeamDetailsViewModel when data exists', async () => {
+      const mockDto = {
+        id: 'team-1',
+        name: 'Test Team',
+        description: 'A test team',
+        logoUrl: 'https://example.com/logo.png',
+        memberCount: 5,
+        ownerId: 'owner-1',
+        members: [],
+      };
+
+      mockApiClient.getDetails.mockResolvedValue(mockDto);
+
+      const result = await service.getTeamDetails('team-1', 'user-1');
+
+      expect(mockApiClient.getDetails).toHaveBeenCalledWith('team-1');
+      expect(result).toBeInstanceOf(TeamDetailsViewModel);
+      expect(result?.id).toBe('team-1');
+      expect(result?.name).toBe('Test Team');
+    });
+
+    it('should return null when apiClient.getDetails returns null', async () => {
+      mockApiClient.getDetails.mockResolvedValue(null);
+
+      const result = await service.getTeamDetails('team-1', 'user-1');
+
+      expect(mockApiClient.getDetails).toHaveBeenCalledWith('team-1');
+      expect(result).toBeNull();
+    });
+
+    it('should throw error when apiClient.getDetails fails', async () => {
+      const error = new Error('API call failed');
+      mockApiClient.getDetails.mockRejectedValue(error);
+
+      await expect(service.getTeamDetails('team-1', 'user-1')).rejects.toThrow('API call failed');
+    });
+  });
+
+  describe('getTeamMembers', () => {
+    it('should call apiClient.getMembers and return array of TeamMemberViewModel', async () => {
+      const mockDto = {
+        members: [
+          {
+            driverId: 'driver-1',
+            driver: { id: 'driver-1', name: 'Driver One', avatarUrl: 'avatar.png', iracingId: '123', rating: 1400 },
+            role: 'member',
+            joinedAt: '2023-01-01T00:00:00Z',
+          },
+        ],
+      };
+
+      mockApiClient.getMembers.mockResolvedValue(mockDto);
+
+      const result = await service.getTeamMembers('team-1', 'user-1', 'owner-1');
+
+      expect(mockApiClient.getMembers).toHaveBeenCalledWith('team-1');
+      expect(result).toHaveLength(1);
+      expect(result[0]).toBeInstanceOf(TeamMemberViewModel);
+      expect(result[0].driverId).toBe('driver-1');
+      expect(result[0].role).toBe('member');
+    });
+
+    it('should throw error when apiClient.getMembers fails', async () => {
+      const error = new Error('API call failed');
+      mockApiClient.getMembers.mockRejectedValue(error);
+
+      await expect(service.getTeamMembers('team-1', 'user-1', 'owner-1')).rejects.toThrow('API call failed');
+    });
+  });
+
+  describe('createTeam', () => {
+    it('should call apiClient.create and return the result', async () => {
+      const input = { name: 'New Team', tag: 'NT', description: 'A new team' };
+
+      const mockOutput = { id: 'team-123', success: true };
+
+      mockApiClient.create.mockResolvedValue(mockOutput);
+
+      const result = await service.createTeam(input);
+
+      expect(mockApiClient.create).toHaveBeenCalledWith(input);
+      expect(result).toEqual(mockOutput);
+    });
+
+    it('should throw error when apiClient.create fails', async () => {
+      const input = { name: 'New Team', tag: 'NT' };
+
+      const error = new Error('API call failed');
+      mockApiClient.create.mockRejectedValue(error);
+
+      await expect(service.createTeam(input)).rejects.toThrow('API call failed');
+    });
+  });
+
+  describe('updateTeam', () => {
+    it('should call apiClient.update and return the result', async () => {
+      const input = { name: 'Updated Team', description: 'Updated description' };
+
+      const mockOutput = { success: true };
+
+      mockApiClient.update.mockResolvedValue(mockOutput);
+
+      const result = await service.updateTeam('team-1', input);
+
+      expect(mockApiClient.update).toHaveBeenCalledWith('team-1', input);
+      expect(result).toEqual(mockOutput);
+    });
+
+    it('should throw error when apiClient.update fails', async () => {
+      const input = { name: 'Updated Team' };
+
+      const error = new Error('API call failed');
+      mockApiClient.update.mockRejectedValue(error);
+
+      await expect(service.updateTeam('team-1', input)).rejects.toThrow('API call failed');
+    });
+  });
+
+  describe('getDriverTeam', () => {
+    it('should call apiClient.getDriverTeam and return the result', async () => {
+      const mockOutput = { teamId: 'team-1', teamName: 'Test Team', role: 'member' };
+
+      mockApiClient.getDriverTeam.mockResolvedValue(mockOutput);
+
+      const result = await service.getDriverTeam('driver-1');
+
+      expect(mockApiClient.getDriverTeam).toHaveBeenCalledWith('driver-1');
+      expect(result).toEqual(mockOutput);
+    });
+
+    it('should return null when apiClient.getDriverTeam returns null', async () => {
+      mockApiClient.getDriverTeam.mockResolvedValue(null);
+
+      const result = await service.getDriverTeam('driver-1');
+
+      expect(mockApiClient.getDriverTeam).toHaveBeenCalledWith('driver-1');
+      expect(result).toBeNull();
+    });
+
+    it('should throw error when apiClient.getDriverTeam fails', async () => {
+      const error = new Error('API call failed');
+      mockApiClient.getDriverTeam.mockRejectedValue(error);
+
+      await expect(service.getDriverTeam('driver-1')).rejects.toThrow('API call failed');
+    });
+  });
+});