integration tests

tests/e2e/rating/README.md

@@ -0,0 +1,127 @@
+# Rating BDD E2E Tests
+
+This directory contains BDD (Behavior-Driven Development) E2E tests for the GridPilot Rating system.
+
+## Overview
+
+The GridPilot Rating system is a competition rating designed specifically for league racing. Unlike iRating (which is for matchmaking), GridPilot Rating measures:
+- **Results Strength**: How well you finish relative to field strength
+- **Consistency**: Stability of finishing positions over a season
+- **Clean Driving**: Incidents per race, weighted by severity
+- **Racecraft**: Positions gained/lost vs. incident involvement
+- **Reliability**: Attendance, DNS/DNF record
+- **Team Contribution**: Points earned for your team; lineup efficiency
+
+## Test Files
+
+### [`rating-profile.spec.ts`](rating-profile.spec.ts)
+Tests the driver profile rating display, including:
+- Current GridPilot Rating value
+- Rating breakdown by component (results, consistency, clean driving, etc.)
+- Rating trend over time (seasons)
+- Rating comparison with peers
+- Rating impact on team contribution
+
+**Key Scenarios:**
+- Driver sees their current GridPilot Rating on profile
+- Driver sees rating breakdown by component
+- Driver sees rating trend over multiple seasons
+- Driver sees how rating compares to league peers
+- Driver sees rating impact on team contribution
+- Driver sees rating explanation/tooltip
+- Driver sees rating update after race completion
+
+### [`rating-calculation.spec.ts`](rating-calculation.spec.ts)
+Tests the rating calculation logic and updates:
+- Rating calculation after race completion
+- Rating update based on finishing position
+- Rating update based on field strength
+- Rating update based on incidents
+- Rating update based on consistency
+- Rating update based on team contribution
+- Rating update based on season performance
+
+**Key Scenarios:**
+- Rating increases after strong finish against strong field
+- Rating decreases after poor finish or incidents
+- Rating reflects consistency over multiple races
+- Rating accounts for team contribution
+- Rating updates immediately after results are processed
+- Rating calculation is transparent and understandable
+
+### [`rating-leaderboard.spec.ts`](rating-leaderboard.spec.ts)
+Tests the rating-based leaderboards:
+- Global driver rankings by GridPilot Rating
+- League-specific driver rankings
+- Team rankings based on driver ratings
+- Rating-based filtering and sorting
+- Rating-based search functionality
+
+**Key Scenarios:**
+- User sees drivers ranked by GridPilot Rating
+- User can filter drivers by rating range
+- User can search for drivers by rating
+- User can sort drivers by different rating components
+- User sees team rankings based on driver ratings
+- User sees rating-based leaderboards with accurate data
+
+## Test Structure
+
+Each test file follows this pattern:
+
+```typescript
+import { test, expect } from '@playwright/test';
+
+test.describe('GridPilot Rating System', () => {
+  test.beforeEach(async ({ page }) => {
+    // TODO: Implement authentication setup
+  });
+
+  test('Driver sees their GridPilot Rating on profile', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver views their rating
+    // Given I am a registered driver "John Doe"
+    // And I have completed several races
+    // And I am on my profile page
+    // Then I should see my GridPilot Rating
+    // And I should see the rating breakdown
+  });
+});
+```
+
+## Test Philosophy
+
+These tests follow the BDD E2E testing concept:
+
+- **Focus on outcomes, not visual implementation**: Tests validate what the user sees and can verify, not how it's rendered
+- **Use Gherkin syntax**: Tests are written in Given/When/Then format
+- **Validate final user outcomes**: Tests serve as acceptance criteria for the rating functionality
+- **Use Playwright**: Tests are implemented using Playwright for browser automation
+
+## TODO Implementation
+
+All tests are currently placeholders with TODO comments. The actual test implementation should:
+
+1. Set up authentication (login as a test driver)
+2. Navigate to the appropriate page
+3. Verify the expected outcomes using Playwright assertions
+4. Handle loading states, error states, and edge cases
+5. Use test data that matches the expected behavior
+
+## Test Data
+
+Tests should use realistic test data that matches the expected behavior:
+- Driver: "John Doe" or similar test driver with varying performance
+- Races: Completed races with different results (wins, podiums, DNFs)
+- Fields: Races with varying field strength (strong vs. weak fields)
+- Incidents: Races with different incident counts
+- Teams: Teams with multiple drivers contributing to team score
+
+## Future Enhancements
+
+- Add test data factories/fixtures for consistent test data
+- Add helper functions for common actions (login, navigation, etc.)
+- Add visual regression tests for rating display
+- Add performance tests for rating calculation
+- Add accessibility tests for rating pages
+- Add cross-browser compatibility testing

tests/e2e/rating/rating-calculation.spec.ts

@@ -0,0 +1,129 @@
+import { test, expect } from '@playwright/test';
+
+test.describe('GridPilot Rating - Calculation Logic', () => {
+  test.beforeEach(async ({ page }) => {
+    // TODO: Implement authentication setup
+    // - Login as test driver
+    // - Ensure test data exists
+  });
+
+  test('Rating increases after strong finish against strong field', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver finishes well against strong competition
+    // Given I am a driver with baseline rating
+    // And I complete a race against strong field
+    // And I finish in top positions
+    // When I view my rating after race
+    // Then my rating should increase
+    // And I should see the increase amount
+  });
+
+  test('Rating decreases after poor finish or incidents', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver has poor race with incidents
+    // Given I am a driver with baseline rating
+    // And I complete a race with poor finish
+    // And I have multiple incidents
+    // When I view my rating after race
+    // Then my rating should decrease
+    // And I should see the decrease amount
+  });
+
+  test('Rating reflects consistency over multiple races', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver shows consistent performance
+    // Given I complete multiple races
+    // And I finish in similar positions each race
+    // When I view my rating
+    // Then my consistency score should be high
+    // And my rating should be stable
+  });
+
+  test('Rating accounts for team contribution', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver contributes to team success
+    // Given I am on a team
+    // And I score points for my team
+    // When I view my rating
+    // Then my team contribution score should reflect this
+    // And my overall rating should include team impact
+  });
+
+  test('Rating updates immediately after results are processed', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Race results are processed
+    // Given I just completed a race
+    // And results are being processed
+    // When results are available
+    // Then my rating should update immediately
+    // And I should see the update in real-time
+  });
+
+  test('Rating calculation is transparent and understandable', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver wants to understand rating changes
+    // Given I view my rating details
+    // When I see a rating change
+    // Then I should see explanation of what caused it
+    // And I should see breakdown of calculation
+    // And I should see tips for improvement
+  });
+
+  test('Rating handles DNFs appropriately', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver has DNF
+    // Given I complete a race
+    // And I have a DNF (Did Not Finish)
+    // When I view my rating
+    // Then my rating should be affected
+    // And my reliability score should decrease
+    // And I should see explanation of DNF impact
+  });
+
+  test('Rating handles DNS appropriately', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver has DNS
+    // Given I have a DNS (Did Not Start)
+    // When I view my rating
+    // Then my rating should be affected
+    // And my reliability score should decrease
+    // And I should see explanation of DNS impact
+  });
+
+  test('Rating handles small field sizes appropriately', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver races in small field
+    // Given I complete a race with small field
+    // When I view my rating
+    // Then my rating should be normalized for field size
+    // And I should see explanation of field size impact
+  });
+
+  test('Rating handles large field sizes appropriately', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver races in large field
+    // Given I complete a race with large field
+    // When I view my rating
+    // Then my rating should be normalized for field size
+    // And I should see explanation of field size impact
+  });
+
+  test('Rating handles clean races appropriately', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver has clean race
+    // Given I complete a race with zero incidents
+    // When I view my rating
+    // Then my clean driving score should increase
+    // And my rating should benefit from clean driving
+  });
+
+  test('Rating handles penalty scenarios appropriately', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver receives penalty
+    // Given I complete a race
+    // And I receive a penalty
+    // When I view my rating
+    // Then my rating should be affected by penalty
+    // And I should see explanation of penalty impact
+  });
+});

tests/e2e/rating/rating-leaderboard.spec.ts

@@ -0,0 +1,123 @@
+import { test, expect } from '@playwright/test';
+
+test.describe('GridPilot Rating - Leaderboards', () => {
+  test.beforeEach(async ({ page }) => {
+    // TODO: Implement authentication setup
+    // - Login as test user
+    // - Ensure test data exists
+  });
+
+  test('User sees drivers ranked by GridPilot Rating', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: User views rating-based leaderboard
+    // Given I am on the leaderboards page
+    // When I view the driver rankings
+    // Then I should see drivers sorted by GridPilot Rating
+    // And I should see rating values for each driver
+    // And I should see ranking numbers
+  });
+
+  test('User can filter drivers by rating range', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: User filters leaderboard by rating
+    // Given I am on the driver leaderboards page
+    // When I set a rating range filter
+    // Then I should see only drivers within that range
+    // And I should see filter summary
+  });
+
+  test('User can search for drivers by rating', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: User searches for specific rating
+    // Given I am on the driver leaderboards page
+    // When I search for drivers with specific rating
+    // Then I should see matching drivers
+    // And I should see search results count
+  });
+
+  test('User can sort drivers by different rating components', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: User sorts leaderboard by rating component
+    // Given I am on the driver leaderboards page
+    // When I sort by "Results Strength"
+    // Then drivers should be sorted by results strength
+    // When I sort by "Clean Driving"
+    // Then drivers should be sorted by clean driving score
+    // And I should see the sort indicator
+  });
+
+  test('User sees team rankings based on driver ratings', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: User views team leaderboards
+    // Given I am on the team leaderboards page
+    // When I view team rankings
+    // Then I should see teams ranked by combined driver ratings
+    // And I should see team rating breakdown
+    // And I should see driver contributions
+  });
+
+  test('User sees rating-based leaderboards with accurate data', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: User verifies leaderboard accuracy
+    // Given I am viewing a rating-based leaderboard
+    // When I check the data
+    // Then ratings should match driver profiles
+    // And rankings should be correct
+    // And calculations should be accurate
+  });
+
+  test('User sees empty state when no rating data exists', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Leaderboard with no data
+    // Given there are no drivers with ratings
+    // When I view the leaderboards
+    // Then I should see empty state
+    // And I should see message about no data
+  });
+
+  test('User sees loading state while leaderboards load', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Leaderboards load slowly
+    // Given I navigate to leaderboards
+    // When data is loading
+    // Then I should see loading skeleton
+    // And I should see loading indicators
+  });
+
+  test('User sees error state when leaderboards fail to load', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Leaderboards fail to load
+    // Given I navigate to leaderboards
+    // When data fails to load
+    // Then I should see error message
+    // And I should see retry button
+  });
+
+  test('User can navigate from leaderboard to driver profile', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: User clicks on driver in leaderboard
+    // Given I am viewing a rating-based leaderboard
+    // When I click on a driver entry
+    // Then I should navigate to that driver's profile
+    // And I should see their detailed rating
+  });
+
+  test('User sees pagination for large leaderboards', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Leaderboard has many drivers
+    // Given there are many drivers with ratings
+    // When I view the leaderboards
+    // Then I should see pagination controls
+    // And I can navigate through pages
+    // And I should see page count
+  });
+
+  test('User sees rating percentile information', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: User wants to know relative standing
+    // Given I am viewing a driver in leaderboard
+    // When I look at their rating
+    // Then I should see percentile (e.g., "Top 10%")
+    // And I should see how many drivers are above/below
+  });
+});

tests/e2e/rating/rating-profile.spec.ts

@@ -0,0 +1,115 @@
+import { test, expect } from '@playwright/test';
+
+test.describe('GridPilot Rating - Profile Display', () => {
+  test.beforeEach(async ({ page }) => {
+    // TODO: Implement authentication setup
+    // - Login as test driver
+    // - Ensure driver has rating data
+  });
+
+  test('Driver sees their GridPilot Rating on profile', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver views their rating on profile
+    // Given I am a registered driver "John Doe"
+    // And I have completed several races with varying results
+    // And I am on my profile page
+    // Then I should see my GridPilot Rating displayed
+    // And I should see the rating value (e.g., "1500")
+    // And I should see the rating label (e.g., "GridPilot Rating")
+  });
+
+  test('Driver sees rating breakdown by component', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver views detailed rating breakdown
+    // Given I am on my profile page
+    // When I view the rating details
+    // Then I should see breakdown by:
+    // - Results Strength
+    // - Consistency
+    // - Clean Driving
+    // - Racecraft
+    // - Reliability
+    // - Team Contribution
+    // And each component should have a score/value
+  });
+
+  test('Driver sees rating trend over multiple seasons', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver views rating history
+    // Given I have raced in multiple seasons
+    // When I view my rating history
+    // Then I should see rating trend over time
+    // And I should see rating changes per season
+    // And I should see rating peaks and valleys
+  });
+
+  test('Driver sees rating comparison with league peers', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver compares rating with peers
+    // Given I am in a league with other drivers
+    // When I view my rating
+    // Then I should see how my rating compares to league average
+    // And I should see my percentile in the league
+    // And I should see my rank in the league
+  });
+
+  test('Driver sees rating impact on team contribution', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver sees how rating affects team
+    // Given I am on a team
+    // When I view my rating
+    // Then I should see my contribution to team score
+    // And I should see my percentage of team total
+    // And I should see how my rating affects team ranking
+  });
+
+  test('Driver sees rating explanation/tooltip', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver seeks explanation of rating
+    // Given I am viewing my rating
+    // When I hover over rating components
+    // Then I should see explanation of what each component means
+    // And I should see how each component is calculated
+    // And I should see tips for improving each component
+  });
+
+  test('Driver sees rating update after race completion', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver sees rating update after race
+    // Given I just completed a race
+    // When I view my profile
+    // Then I should see my rating has updated
+    // And I should see the change (e.g., "+15")
+    // And I should see what caused the change
+  });
+
+  test('Driver sees empty state when no rating data exists', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: New driver views profile
+    // Given I am a new driver with no races
+    // When I view my profile
+    // Then I should see empty state for rating
+    // And I should see message about rating calculation
+    // And I should see call to action to complete races
+  });
+
+  test('Driver sees loading state while rating loads', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Driver views profile with slow connection
+    // Given I am on my profile page
+    // When rating data is loading
+    // Then I should see loading skeleton
+    // And I should see loading indicator
+    // And I should see placeholder values
+  });
+
+  test('Driver sees error state when rating fails to load', async ({ page }) => {
+    // TODO: Implement test
+    // Scenario: Rating data fails to load
+    // Given I am on my profile page
+    // When rating data fails to load
+    // Then I should see error message
+    // And I should see retry button
+    // And I should see fallback UI
+  });
+});