670 lines
28 KiB
TypeScript
670 lines
28 KiB
TypeScript
/**
|
|
* BDD E2E Test: League Schedule
|
|
*
|
|
* Tests the league schedule page that displays:
|
|
* - List of races in the league
|
|
* - Race details (track, car, date, time)
|
|
* - Race registration status
|
|
* - Race results
|
|
* - Race management (for admins)
|
|
*
|
|
* Focus: Final user outcomes - what the driver sees and can verify
|
|
*/
|
|
|
|
import { test, expect } from '@playwright/test';
|
|
|
|
test.describe('League Schedule', () => {
|
|
test.beforeEach(async ({ page }) => {
|
|
// TODO: Implement authentication setup for a registered driver
|
|
// - Navigate to login page
|
|
// - Enter credentials for "John Doe" or similar test driver
|
|
// - Verify successful login
|
|
// - Navigate to a league schedule page
|
|
});
|
|
|
|
test('Driver sees list of races in the league', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views league races
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see a list of races in the league
|
|
// And each race should display its track name
|
|
// And each race should display its date and time
|
|
});
|
|
|
|
test('Driver sees race track name', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race track name
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see the track name for each race
|
|
// And the track name should be readable
|
|
});
|
|
|
|
test('Driver sees race car type', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race car type
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see the car type for each race
|
|
// And the car type should be readable
|
|
});
|
|
|
|
test('Driver sees race date and time', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race date and time
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see the date and time for each race
|
|
// And the date and time should be formatted correctly
|
|
});
|
|
|
|
test('Driver sees race duration', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race duration
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see the duration for each race
|
|
// And the duration should be formatted correctly
|
|
});
|
|
|
|
test('Driver sees race registration status', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race registration status
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see registration status for each race
|
|
// And open registration races should be marked as "Open"
|
|
// And closed registration races should be marked as "Closed"
|
|
});
|
|
|
|
test('Driver can register for an open race', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver registers for a race
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// And there is an open registration race
|
|
// When I click "Register" on the race
|
|
// Then I should be registered for the race
|
|
// And I should see a confirmation message
|
|
});
|
|
|
|
test('Driver can unregister from a race', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver unregisters from a race
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// And I am registered for a race
|
|
// When I click "Unregister" on the race
|
|
// Then I should be unregistered from the race
|
|
// And I should see a confirmation message
|
|
});
|
|
|
|
test('Driver cannot register for a closed race', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver tries to register for closed race
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// And there is a closed registration race
|
|
// Then I should not see the "Register" button
|
|
// And I should see that registration is closed
|
|
});
|
|
|
|
test('Driver sees race registration deadline', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race registration deadline
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see the registration deadline for each race
|
|
// And the deadline should be formatted correctly
|
|
});
|
|
|
|
test('Driver sees race registration count', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race registration count
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see the number of registered drivers for each race
|
|
// And the count should be accurate
|
|
});
|
|
|
|
test('Driver sees race max drivers', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race max drivers
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see the maximum number of drivers for each race
|
|
// And the max drivers should be displayed
|
|
});
|
|
|
|
test('Driver sees race available slots', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race available slots
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see the available slots for each race
|
|
// And the available slots should be calculated correctly
|
|
});
|
|
|
|
test('Driver sees race status', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race status
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see the status for each race
|
|
// And upcoming races should be marked as "Upcoming"
|
|
// And in-progress races should be marked as "In Progress"
|
|
// And completed races should be marked as "Completed"
|
|
});
|
|
|
|
test('Driver sees race results when available', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race results
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// And there are completed races with results
|
|
// Then I should see results for completed races
|
|
// And I should see the top finishers
|
|
});
|
|
|
|
test('Driver can navigate to race details', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver navigates to race details
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// When I click on a race
|
|
// Then I should be navigated to the race detail page
|
|
// And I should see the race details
|
|
});
|
|
|
|
test('Driver can navigate to race results', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver navigates to race results
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// And there is a completed race
|
|
// When I click "View Results" on the race
|
|
// Then I should be navigated to the race results page
|
|
// And I should see the race results
|
|
});
|
|
|
|
test('Driver sees upcoming races section', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views upcoming races
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see a section for upcoming races
|
|
// And upcoming races should be listed
|
|
});
|
|
|
|
test('Driver sees completed races section', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views completed races
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see a section for completed races
|
|
// And completed races should be listed
|
|
});
|
|
|
|
test('Driver sees in-progress races section', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views in-progress races
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see a section for in-progress races
|
|
// And in-progress races should be listed
|
|
});
|
|
|
|
test('Driver can filter races by status', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver filters races by status
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// When I select "Upcoming" status filter
|
|
// Then I should only see upcoming races
|
|
// And I should not see completed or in-progress races
|
|
});
|
|
|
|
test('Driver can filter races by track', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver filters races by track
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// When I select a track filter
|
|
// Then I should only see races on that track
|
|
// And I should not see races on other tracks
|
|
});
|
|
|
|
test('Driver can filter races by car type', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver filters races by car type
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// When I select a car type filter
|
|
// Then I should only see races with that car type
|
|
// And I should not see races with other car types
|
|
});
|
|
|
|
test('Driver can search for races', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver searches for races
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// When I enter a search query
|
|
// Then I should see races matching the search
|
|
// And I should not see races that don't match
|
|
});
|
|
|
|
test('Driver can clear race filters', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver clears race filters
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// And I have selected filters
|
|
// When I click "Clear Filters"
|
|
// Then I should see all races again
|
|
// And the filters should be reset
|
|
});
|
|
|
|
test('Driver sees race count', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver sees race count
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see the total number of races
|
|
// And the count should be accurate
|
|
});
|
|
|
|
test('Driver sees upcoming race count', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver sees upcoming race count
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see the number of upcoming races
|
|
// And the count should be accurate
|
|
});
|
|
|
|
test('Driver sees completed race count', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver sees completed race count
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see the number of completed races
|
|
// And the count should be accurate
|
|
});
|
|
|
|
test('Driver sees in-progress race count', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver sees in-progress race count
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see the number of in-progress races
|
|
// And the count should be accurate
|
|
});
|
|
|
|
test('Admin can add a new race', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Admin adds a new race
|
|
// Given I am a league admin for "European GT League"
|
|
// And I am on the "European GT League" schedule page
|
|
// When I click "Add Race"
|
|
// And I fill in the race details
|
|
// Then the race should be added to the schedule
|
|
// And I should see a confirmation message
|
|
});
|
|
|
|
test('Admin can edit an existing race', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Admin edits a race
|
|
// Given I am a league admin for "European GT League"
|
|
// And I am on the "European GT League" schedule page
|
|
// When I click "Edit" on a race
|
|
// And I update the race details
|
|
// Then the race should be updated
|
|
// And I should see a confirmation message
|
|
});
|
|
|
|
test('Admin can delete a race', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Admin deletes a race
|
|
// Given I am a league admin for "European GT League"
|
|
// And I am on the "European GT League" schedule page
|
|
// When I click "Delete" on a race
|
|
// Then the race should be removed from the schedule
|
|
// And I should see a confirmation message
|
|
});
|
|
|
|
test('Admin can open registration for a race', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Admin opens race registration
|
|
// Given I am a league admin for "European GT League"
|
|
// And I am on the "European GT League" schedule page
|
|
// And there is a closed registration race
|
|
// When I click "Open Registration" on the race
|
|
// Then the race registration should be open
|
|
// And I should see a confirmation message
|
|
});
|
|
|
|
test('Admin can close registration for a race', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Admin closes race registration
|
|
// Given I am a league admin for "European GT League"
|
|
// And I am on the "European GT League" schedule page
|
|
// And there is an open registration race
|
|
// When I click "Close Registration" on the race
|
|
// Then the race registration should be closed
|
|
// And I should see a confirmation message
|
|
});
|
|
|
|
test('Admin can import race results', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Admin imports race results
|
|
// Given I am a league admin for "European GT League"
|
|
// And I am on the "European GT League" schedule page
|
|
// And there is a completed race
|
|
// When I click "Import Results" on the race
|
|
// And I upload the results file
|
|
// Then the race results should be imported
|
|
// And I should see a confirmation message
|
|
});
|
|
|
|
test('Admin can export race results', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Admin exports race results
|
|
// Given I am a league admin for "European GT League"
|
|
// And I am on the "European GT League" schedule page
|
|
// And there is a completed race with results
|
|
// When I click "Export Results" on the race
|
|
// Then the race results should be exported
|
|
// And I should see a confirmation message
|
|
});
|
|
|
|
test('Driver sees race weather information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race weather
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see weather information for each race
|
|
// And weather should include temperature, conditions, etc.
|
|
});
|
|
|
|
test('Driver sees race track layout', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race track layout
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see track layout information for each race
|
|
// And track layout should include length, turns, etc.
|
|
});
|
|
|
|
test('Driver sees race qualifying information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race qualifying information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see qualifying information for each race
|
|
// And qualifying should include duration, format, etc.
|
|
});
|
|
|
|
test('Driver sees race practice information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race practice information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see practice information for each race
|
|
// And practice should include duration, format, etc.
|
|
});
|
|
|
|
test('Driver sees race warmup information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race warmup information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see warmup information for each race
|
|
// And warmup should include duration, format, etc.
|
|
});
|
|
|
|
test('Driver sees race grid size', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race grid size
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see grid size for each race
|
|
// And grid size should be displayed as number of positions
|
|
});
|
|
|
|
test('Driver sees race pit lane information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race pit lane information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see pit lane information for each race
|
|
// And pit lane should include duration, etc.
|
|
});
|
|
|
|
test('Driver sees race safety car information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race safety car information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see safety car information for each race
|
|
// And safety car should include deployment rules, etc.
|
|
});
|
|
|
|
test('Driver sees race virtual safety car information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race virtual safety car information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see virtual safety car information for each race
|
|
// And virtual safety car should include deployment rules, etc.
|
|
});
|
|
|
|
test('Driver sees race FCY information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race FCY information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see FCY information for each race
|
|
// And FCY should include deployment rules, etc.
|
|
});
|
|
|
|
test('Driver sees race caution periods information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race caution periods information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see caution periods information for each race
|
|
// And caution periods should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race restart procedures information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race restart procedures information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see restart procedures information for each race
|
|
// And restart procedures should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race penalty information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race penalty information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see penalty information for each race
|
|
// And penalties should include types, etc.
|
|
});
|
|
|
|
test('Driver sees race protest information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race protest information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see protest information for each race
|
|
// And protests should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race appeal information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race appeal information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see appeal information for each race
|
|
// And appeals should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race stewarding information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race stewarding information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see stewarding information for each race
|
|
// And stewarding should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race incident review information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race incident review information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see incident review information for each race
|
|
// And incident review should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race penalty appeal information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race penalty appeal information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see penalty appeal information for each race
|
|
// And penalty appeal should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race protest appeal information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race protest appeal information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see protest appeal information for each race
|
|
// And protest appeal should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race stewarding action appeal information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race stewarding action appeal information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see stewarding action appeal information for each race
|
|
// And stewarding action appeal should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race penalty protest information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race penalty protest information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see penalty protest information for each race
|
|
// And penalty protest should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race stewarding action protest information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race stewarding action protest information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see stewarding action protest information for each race
|
|
// And stewarding action protest should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race penalty appeal protest information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race penalty appeal protest information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see penalty appeal protest information for each race
|
|
// And penalty appeal protest should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race stewarding action appeal protest information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race stewarding action appeal protest information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see stewarding action appeal protest information for each race
|
|
// And stewarding action appeal protest should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race penalty appeal protest stewarding action information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race penalty appeal protest stewarding action information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see penalty appeal protest stewarding action information for each race
|
|
// And penalty appeal protest stewarding action should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race stewarding action appeal protest penalty information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race stewarding action appeal protest penalty information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see stewarding action appeal protest penalty information for each race
|
|
// And stewarding action appeal protest penalty should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race penalty appeal protest stewarding action appeal information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race penalty appeal protest stewarding action appeal information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see penalty appeal protest stewarding action appeal information for each race
|
|
// And penalty appeal protest stewarding action appeal should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race stewarding action appeal protest penalty appeal information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race stewarding action appeal protest penalty appeal information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see stewarding action appeal protest penalty appeal information for each race
|
|
// And stewarding action appeal protest penalty appeal should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race penalty appeal protest stewarding action appeal protest information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race penalty appeal protest stewarding action appeal protest information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see penalty appeal protest stewarding action appeal protest information for each race
|
|
// And penalty appeal protest stewarding action appeal protest should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race stewarding action appeal protest penalty appeal protest information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race stewarding action appeal protest penalty appeal protest information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see stewarding action appeal protest penalty appeal protest information for each race
|
|
// And stewarding action appeal protest penalty appeal protest should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race penalty appeal protest stewarding action appeal protest penalty information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race penalty appeal protest stewarding action appeal protest penalty information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see penalty appeal protest stewarding action appeal protest penalty information for each race
|
|
// And penalty appeal protest stewarding action appeal protest penalty should include rules, etc.
|
|
});
|
|
|
|
test('Driver sees race stewarding action appeal protest penalty appeal protest penalty information', async ({ page }) => {
|
|
// TODO: Implement test
|
|
// Scenario: Driver views race stewarding action appeal protest penalty appeal protest penalty information
|
|
// Given I am a registered driver "John Doe"
|
|
// And I am on the "European GT League" schedule page
|
|
// Then I should see stewarding action appeal protest penalty appeal protest penalty information for each race
|
|
// And stewarding action appeal protest penalty appeal protest penalty should include rules, etc.
|
|
});
|
|
});
|