1043 lines
30 KiB
TypeScript
1043 lines
30 KiB
TypeScript
import { describe, it, expect } from 'vitest';
|
|
import { TeamDetailViewDataBuilder } from './TeamDetailViewDataBuilder';
|
|
import type { TeamDetailPageDto } from '@/lib/page-queries/TeamDetailPageQuery';
|
|
|
|
describe('TeamDetailViewDataBuilder', () => {
|
|
describe('happy paths', () => {
|
|
it('should transform TeamDetailPageDto to TeamDetailViewData correctly', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-123',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: ['league-1', 'league-2'],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English', 'German'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: true,
|
|
},
|
|
memberships: [
|
|
{
|
|
driverId: 'driver-1',
|
|
driverName: 'Driver 1',
|
|
role: 'owner',
|
|
joinedAt: '2024-01-01',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result).toEqual({
|
|
team: {
|
|
id: 'team-123',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: ['league-1', 'league-2'],
|
|
createdAt: '2024-01-01',
|
|
foundedDateLabel: 'January 2024',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English', 'German'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: true,
|
|
},
|
|
memberships: [
|
|
{
|
|
driverId: 'driver-1',
|
|
driverName: 'Driver 1',
|
|
role: 'owner',
|
|
joinedAt: '2024-01-01',
|
|
joinedAtLabel: 'Jan 1, 2024',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
],
|
|
currentDriverId: 'driver-1',
|
|
isAdmin: true,
|
|
teamMetrics: [
|
|
{
|
|
icon: 'users',
|
|
label: 'Members',
|
|
value: '1',
|
|
color: 'text-primary-blue',
|
|
},
|
|
{
|
|
icon: 'zap',
|
|
label: 'Est. Reach',
|
|
value: '15',
|
|
color: 'text-purple-400',
|
|
},
|
|
{
|
|
icon: 'calendar',
|
|
label: 'Races',
|
|
value: '2',
|
|
color: 'text-neon-aqua',
|
|
},
|
|
{
|
|
icon: 'users',
|
|
label: 'Engagement',
|
|
value: '82%',
|
|
color: 'text-performance-green',
|
|
},
|
|
],
|
|
tabs: [
|
|
{ id: 'overview', label: 'Overview', visible: true },
|
|
{ id: 'roster', label: 'Roster', visible: true },
|
|
{ id: 'standings', label: 'Standings', visible: true },
|
|
{ id: 'admin', label: 'Admin', visible: true },
|
|
],
|
|
memberCountLabel: '1',
|
|
leagueCountLabel: '2',
|
|
});
|
|
});
|
|
|
|
it('should handle team without leagues', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-456',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [
|
|
{
|
|
driverId: 'driver-1',
|
|
driverName: 'Driver 1',
|
|
role: 'member',
|
|
joinedAt: '2024-01-01',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.leagues).toHaveLength(0);
|
|
expect(result.teamMetrics[2].value).toBe('0');
|
|
expect(result.leagueCountLabel).toBe('0');
|
|
});
|
|
|
|
it('should handle team without members', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-789',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: ['league-1'],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.memberships).toHaveLength(0);
|
|
expect(result.teamMetrics[0].value).toBe('0');
|
|
expect(result.teamMetrics[1].value).toBe('0');
|
|
expect(result.memberCountLabel).toBe('0');
|
|
});
|
|
|
|
it('should handle multiple members', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-101',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: ['league-1'],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [
|
|
{
|
|
driverId: 'driver-1',
|
|
driverName: 'Driver 1',
|
|
role: 'owner',
|
|
joinedAt: '2024-01-01',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
{
|
|
driverId: 'driver-2',
|
|
driverName: 'Driver 2',
|
|
role: 'manager',
|
|
joinedAt: '2024-01-02',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
{
|
|
driverId: 'driver-3',
|
|
driverName: 'Driver 3',
|
|
role: 'member',
|
|
joinedAt: '2024-01-03',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.memberships).toHaveLength(3);
|
|
expect(result.teamMetrics[0].value).toBe('3');
|
|
expect(result.teamMetrics[1].value).toBe('45');
|
|
expect(result.memberCountLabel).toBe('3');
|
|
});
|
|
});
|
|
|
|
describe('data transformation', () => {
|
|
it('should preserve all DTO fields in the output', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-102',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: ['league-1'],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: true,
|
|
},
|
|
memberships: [
|
|
{
|
|
driverId: 'driver-1',
|
|
driverName: 'Driver 1',
|
|
role: 'owner',
|
|
joinedAt: '2024-01-01',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.id).toBe(teamDetailPageDto.team.id);
|
|
expect(result.team.name).toBe(teamDetailPageDto.team.name);
|
|
expect(result.team.tag).toBe(teamDetailPageDto.team.tag);
|
|
expect(result.team.description).toBe(teamDetailPageDto.team.description);
|
|
expect(result.team.ownerId).toBe(teamDetailPageDto.team.ownerId);
|
|
expect(result.team.leagues).toEqual(teamDetailPageDto.team.leagues);
|
|
expect(result.team.createdAt).toBe(teamDetailPageDto.team.createdAt);
|
|
expect(result.team.specialization).toBe(teamDetailPageDto.team.specialization);
|
|
expect(result.team.region).toBe(teamDetailPageDto.team.region);
|
|
expect(result.team.languages).toEqual(teamDetailPageDto.team.languages);
|
|
expect(result.team.category).toBe(teamDetailPageDto.team.category);
|
|
expect(result.team.membership).toBe(teamDetailPageDto.team.membership);
|
|
expect(result.team.canManage).toBe(teamDetailPageDto.team.canManage);
|
|
expect(result.currentDriverId).toBe(teamDetailPageDto.currentDriverId);
|
|
});
|
|
|
|
it('should not modify the input DTO', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-103',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const originalDto = { ...teamDetailPageDto };
|
|
TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(teamDetailPageDto).toEqual(originalDto);
|
|
});
|
|
});
|
|
|
|
describe('edge cases', () => {
|
|
it('should handle team without createdAt', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-104',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: null,
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.foundedDateLabel).toBe('Unknown');
|
|
});
|
|
|
|
it('should handle team without description', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-105',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: null,
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.description).toBeNull();
|
|
});
|
|
|
|
it('should handle team without tag', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-106',
|
|
name: 'Test Team',
|
|
tag: null,
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.tag).toBeNull();
|
|
});
|
|
|
|
it('should handle team without specialization', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-107',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: null,
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.specialization).toBeNull();
|
|
});
|
|
|
|
it('should handle team without region', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-108',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: null,
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.region).toBeNull();
|
|
});
|
|
|
|
it('should handle team without languages', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-109',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: null,
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.languages).toBeNull();
|
|
});
|
|
|
|
it('should handle team without category', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-110',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: null,
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.category).toBeNull();
|
|
});
|
|
|
|
it('should handle team without membership', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-111',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: null,
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.membership).toBeNull();
|
|
});
|
|
|
|
it('should handle member without avatar', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-112',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [
|
|
{
|
|
driverId: 'driver-1',
|
|
driverName: 'Driver 1',
|
|
role: 'owner',
|
|
joinedAt: '2024-01-01',
|
|
isActive: true,
|
|
avatarUrl: null,
|
|
},
|
|
],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.memberships[0].avatarUrl).toBeNull();
|
|
});
|
|
|
|
it('should handle member without role', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-113',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [
|
|
{
|
|
driverId: 'driver-1',
|
|
driverName: 'Driver 1',
|
|
role: null,
|
|
joinedAt: '2024-01-01',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.memberships[0].role).toBeNull();
|
|
});
|
|
|
|
it('should handle member without isActive', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-114',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [
|
|
{
|
|
driverId: 'driver-1',
|
|
driverName: 'Driver 1',
|
|
role: 'owner',
|
|
joinedAt: '2024-01-01',
|
|
isActive: null,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.memberships[0].isActive).toBeNull();
|
|
});
|
|
|
|
it('should handle current driver not in members', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-115',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [
|
|
{
|
|
driverId: 'driver-1',
|
|
driverName: 'Driver 1',
|
|
role: 'owner',
|
|
joinedAt: '2024-01-01',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
],
|
|
currentDriverId: 'driver-2',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.isAdmin).toBe(false);
|
|
expect(result.tabs.find(t => t.id === 'admin')?.visible).toBe(false);
|
|
});
|
|
|
|
it('should handle current driver as manager', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-116',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [
|
|
{
|
|
driverId: 'driver-1',
|
|
driverName: 'Driver 1',
|
|
role: 'manager',
|
|
joinedAt: '2024-01-01',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.isAdmin).toBe(true);
|
|
expect(result.tabs.find(t => t.id === 'admin')?.visible).toBe(true);
|
|
});
|
|
|
|
it('should handle current driver as member', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-117',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [
|
|
{
|
|
driverId: 'driver-1',
|
|
driverName: 'Driver 1',
|
|
role: 'member',
|
|
joinedAt: '2024-01-01',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.isAdmin).toBe(false);
|
|
expect(result.tabs.find(t => t.id === 'admin')?.visible).toBe(false);
|
|
});
|
|
|
|
it('should handle current driver as steward', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-118',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [
|
|
{
|
|
driverId: 'driver-1',
|
|
driverName: 'Driver 1',
|
|
role: 'steward',
|
|
joinedAt: '2024-01-01',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.isAdmin).toBe(false);
|
|
expect(result.tabs.find(t => t.id === 'admin')?.visible).toBe(false);
|
|
});
|
|
|
|
it('should handle different membership types', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-119',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'closed',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.membership).toBe('closed');
|
|
});
|
|
|
|
it('should handle different categories', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-120',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Amateur',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.category).toBe('Amateur');
|
|
});
|
|
|
|
it('should handle different specializations', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-121',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Endurance',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.specialization).toBe('Endurance');
|
|
});
|
|
|
|
it('should handle different regions', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-122',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'NA',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.region).toBe('NA');
|
|
});
|
|
|
|
it('should handle multiple languages', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-123',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English', 'German', 'French'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.languages).toEqual(['English', 'German', 'French']);
|
|
});
|
|
|
|
it('should handle empty languages array', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-124',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: [],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.languages).toEqual([]);
|
|
});
|
|
|
|
it('should handle empty leagues array', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-125',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.leagues).toEqual([]);
|
|
});
|
|
|
|
it('should handle large number of leagues', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-126',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: ['league-1', 'league-2', 'league-3', 'league-4', 'league-5'],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.team.leagues).toHaveLength(5);
|
|
expect(result.teamMetrics[2].value).toBe('5');
|
|
expect(result.leagueCountLabel).toBe('5');
|
|
});
|
|
|
|
it('should handle large number of members', () => {
|
|
const teamDetailPageDto: TeamDetailPageDto = {
|
|
team: {
|
|
id: 'team-127',
|
|
name: 'Test Team',
|
|
tag: 'TT',
|
|
description: 'Test Description',
|
|
ownerId: 'owner-1',
|
|
leagues: [],
|
|
createdAt: '2024-01-01',
|
|
specialization: 'Racing',
|
|
region: 'EU',
|
|
languages: ['English'],
|
|
category: 'Professional',
|
|
membership: 'open',
|
|
canManage: false,
|
|
},
|
|
memberships: [
|
|
{
|
|
driverId: 'driver-1',
|
|
driverName: 'Driver 1',
|
|
role: 'owner',
|
|
joinedAt: '2024-01-01',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
{
|
|
driverId: 'driver-2',
|
|
driverName: 'Driver 2',
|
|
role: 'member',
|
|
joinedAt: '2024-01-02',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
{
|
|
driverId: 'driver-3',
|
|
driverName: 'Driver 3',
|
|
role: 'member',
|
|
joinedAt: '2024-01-03',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
{
|
|
driverId: 'driver-4',
|
|
driverName: 'Driver 4',
|
|
role: 'member',
|
|
joinedAt: '2024-01-04',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
{
|
|
driverId: 'driver-5',
|
|
driverName: 'Driver 5',
|
|
role: 'member',
|
|
joinedAt: '2024-01-05',
|
|
isActive: true,
|
|
avatarUrl: 'avatar-url',
|
|
},
|
|
],
|
|
currentDriverId: 'driver-1',
|
|
};
|
|
|
|
const result = TeamDetailViewDataBuilder.build(teamDetailPageDto);
|
|
|
|
expect(result.memberships).toHaveLength(5);
|
|
expect(result.teamMetrics[0].value).toBe('5');
|
|
expect(result.teamMetrics[1].value).toBe('75');
|
|
expect(result.memberCountLabel).toBe('5');
|
|
});
|
|
});
|
|
});
|