mmintel/gridpilot.gg
1
0
Fork 0
Code Issues Pull Requests 1 Actions Packages Projects Releases Wiki Activity

wip

Browse Source
This commit is contained in:
Marc Mintel
2025-11-30 14:00:46 +01:00
parent f8a1fbeb50
commit 9a1feb2912
37 changed files with 3079 additions and 7301 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
tests/e2e/steps/step-01-hosted-racing.e2e.test.ts Normal file
View File

@@ -0,0 +1,30 @@
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import type { StepHarness } from '../support/StepHarness';
import { createStepHarness } from '../support/StepHarness';
describe('Step 1 – hosted racing', () => {
let harness: StepHarness;
beforeEach(async () => {
harness = await createStepHarness();
});
afterEach(async () => {
await harness.dispose();
});
it('executes on Hosted Racing page in mock wizard', async () => {
await harness.navigateToFixtureStep(1);
const page = harness.adapter.getPage();
expect(page).not.toBeNull();
const bodyText = await page!.textContent('body');
expect(bodyText).toContain('Create a Race');
const result = await harness.executeStep(1, {});
expect(result.success).toBe(true);
expect(result.error).toBeUndefined();
});
});

32
tests/e2e/steps/step-02-create-race.e2e.test.ts Normal file
View File

@@ -0,0 +1,32 @@
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import type { StepHarness } from '../support/StepHarness';
import { createStepHarness } from '../support/StepHarness';
describe('Step 2 – create race', () => {
let harness: StepHarness;
beforeEach(async () => {
harness = await createStepHarness();
});
afterEach(async () => {
await harness.dispose();
});
it('clicks Create a Race on Hosted Racing page', async () => {
await harness.navigateToFixtureStep(1);
const page = harness.adapter.getPage();
expect(page).not.toBeNull();
const bodyTextBefore = await page!.textContent('body');
expect(bodyTextBefore).toContain('Create a Race');
const result = await harness.executeStep(2, {});
expect(result.success).toBe(true);
expect(result.error).toBeUndefined();
const bodyTextAfter = await page!.textContent('body');
expect(bodyTextAfter).toMatch(/Last Settings/i);
});
});

39
tests/e2e/steps/step-03-race-information.e2e.test.ts Normal file
View File

@@ -0,0 +1,39 @@
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import type { StepHarness } from '../support/StepHarness';
import { createStepHarness } from '../support/StepHarness';
describe('Step 3 – race information', () => {
let harness: StepHarness;
beforeEach(async () => {
harness = await createStepHarness();
});
afterEach(async () => {
await harness.dispose();
});
it('fills race information on Race Information page', async () => {
await harness.navigateToFixtureStep(3);
const page = harness.adapter.getPage();
expect(page).not.toBeNull();
const sidebarRaceInfo = await page!.textContent(
'#wizard-sidebar-link-set-session-information',
);
expect(sidebarRaceInfo).toContain('Race Information');
const result = await harness.executeStep(3, {
sessionName: 'GridPilot E2E Session',
password: 'secret',
description: 'Step 3 race information E2E',
});
expect(result.success).toBe(true);
expect(result.error).toBeUndefined();
const footerText = await page!.textContent('.wizard-footer');
expect(footerText).toMatch(/Server Details|Admins/i);
});
});

35
tests/e2e/steps/step-04-server-details.e2e.test.ts Normal file
View File

@@ -0,0 +1,35 @@
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import type { StepHarness } from '../support/StepHarness';
import { createStepHarness } from '../support/StepHarness';
describe('Step 4 – server details', () => {
let harness: StepHarness;
beforeEach(async () => {
harness = await createStepHarness();
});
afterEach(async () => {
await harness.dispose();
});
it('executes on Server Details page and progresses toward Admins', async () => {
await harness.navigateToFixtureStep(4);
const page = harness.adapter.getPage();
expect(page).not.toBeNull();
const sidebarServerDetails = await page!.textContent(
'#wizard-sidebar-link-set-server-details',
);
expect(sidebarServerDetails).toContain('Server Details');
const result = await harness.executeStep(4, {});
expect(result.success).toBe(true);
expect(result.error).toBeUndefined();
const footerText = await page!.textContent('.wizard-footer');
expect(footerText).toMatch(/Admins/i);
});
});

38
tests/e2e/steps/step-05-set-admins.e2e.test.ts Normal file
View File

@@ -0,0 +1,38 @@
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import type { StepHarness } from '../support/StepHarness';
import { createStepHarness } from '../support/StepHarness';
describe('Step 5 – set admins', () => {
let harness: StepHarness;
beforeEach(async () => {
harness = await createStepHarness();
});
afterEach(async () => {
await harness.dispose();
});
it('executes on Set Admins page and progresses to Time Limit', async () => {
await harness.navigateToFixtureStep(5);
const page = harness.adapter.getPage();
expect(page).not.toBeNull();
const sidebarAdmins = await page!.textContent(
'#wizard-sidebar-link-set-admins',
);
expect(sidebarAdmins).toContain('Admins');
const bodyText = await page!.textContent('body');
expect(bodyText).toContain('Add an Admin');
const result = await harness.executeStep(5, {});
expect(result.success).toBe(true);
expect(result.error).toBeUndefined();
const footerText = await page!.textContent('.wizard-footer');
expect(footerText).toContain('Time Limit');
});
});

41
tests/e2e/steps/step-06-admins.e2e.test.ts
View File

@@ -1,46 +1,27 @@
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { PlaywrightAutomationAdapter, FixtureServer } from 'packages/infrastructure/adapters/automation';
import { StepId } from 'packages/domain/value-objects/StepId';
import { PinoLogAdapter } from 'packages/infrastructure/adapters/logging/PinoLogAdapter';
import type { StepHarness } from '../support/StepHarness';
import { createStepHarness } from '../support/StepHarness';
describe('Step 6 – admins', () => {
let server: FixtureServer;
let adapter: PlaywrightAutomationAdapter;
let logger: PinoLogAdapter;
let harness: StepHarness;
beforeEach(async () => {
server = new FixtureServer();
const serverInfo = await server.start();
logger = new PinoLogAdapter();
adapter = new PlaywrightAutomationAdapter(
{
headless: true,
timeout: 5000,
mode: 'mock',
baseUrl: serverInfo.url,
},
logger,
);
await adapter.connect();
harness = await createStepHarness();
});
afterEach(async () => {
await adapter.disconnect();
await server.stop();
await harness.dispose();
});
it('completes successfully from Set Admins page', async () => {
await adapter.navigateToPage(server.getFixtureUrl(5));
const page = adapter.getPage();
await harness.navigateToFixtureStep(5);
const page = harness.adapter.getPage();
expect(page).not.toBeNull();
const sidebarAdmins = await page!.textContent('#wizard-sidebar-link-set-admins');
expect(sidebarAdmins).toContain('Admins');
const result = await adapter.executeStep(StepId.create(6), {
const result = await harness.executeStep(6, {
adminSearch: 'Marc',
});
@@ -51,14 +32,14 @@ describe('Step 6 – admins', () => {
});
it('handles Add Admin drawer state without regression', async () => {
await adapter.navigateToPage(server.getFixtureUrl(6));
const page = adapter.getPage();
await harness.navigateToFixtureStep(6);
const page = harness.adapter.getPage();
expect(page).not.toBeNull();
const header = await page!.textContent('#set-admins .card-header');
expect(header).toContain('Set Admins');
const result = await adapter.executeStep(StepId.create(6), {
const result = await harness.executeStep(6, {
adminSearch: 'Mintel',
});

30
tests/e2e/steps/step-07-time-limits.e2e.test.ts
View File

@@ -1,35 +1,27 @@
import { describe, it, expect, beforeAll, afterAll } from 'vitest';
import path from 'path';
import { PlaywrightAutomationAdapter } from 'packages/infrastructure/adapters/automation';
import { StepId } from 'packages/domain/value-objects/StepId';
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import type { StepHarness } from '../support/StepHarness';
import { createStepHarness } from '../support/StepHarness';
describe('Step 7 – time limits', () => {
let adapter: PlaywrightAutomationAdapter;
const fixtureBaseUrl = `file://${path.resolve(process.cwd(), 'html-dumps')}`;
let harness: StepHarness;
beforeAll(async () => {
adapter = new PlaywrightAutomationAdapter({
headless: true,
timeout: 5000,
baseUrl: fixtureBaseUrl,
mode: 'mock',
});
await adapter.connect();
beforeEach(async () => {
harness = await createStepHarness();
});
afterAll(async () => {
await adapter.disconnect();
afterEach(async () => {
await harness.dispose();
});
it('executes on Time Limits page and navigates to Cars', async () => {
await adapter.navigateToPage(`${fixtureBaseUrl}/step-07-time-limits.html`);
const page = adapter.getPage();
await harness.navigateToFixtureStep(7);
const page = harness.adapter.getPage();
expect(page).not.toBeNull();
const stepIndicatorBefore = await page!.textContent('[data-indicator]');
expect(stepIndicatorBefore).toContain('Time Limits');
const result = await adapter.executeStep(StepId.create(7), {
const result = await harness.executeStep(7, {
practice: 10,
qualify: 10,
race: 20,

87
tests/e2e/steps/step-08-cars.e2e.test.ts
View File

@@ -1,38 +1,29 @@
import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
import path from 'path';
import { PlaywrightAutomationAdapter, FixtureServer } from 'packages/infrastructure/adapters/automation';
import { StepId } from 'packages/domain/value-objects/StepId';
import { PinoLogAdapter } from 'packages/infrastructure/adapters/logging/PinoLogAdapter';
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import type { StepHarness } from '../support/StepHarness';
import { createStepHarness } from '../support/StepHarness';
describe('Step 8 – cars', () => {
let harness: StepHarness;
beforeEach(async () => {
harness = await createStepHarness();
});
afterEach(async () => {
await harness.dispose();
});
describe('alignment', () => {
let adapter: PlaywrightAutomationAdapter;
const fixtureBaseUrl = `file://${path.resolve(process.cwd(), 'html-dumps')}`;
beforeAll(async () => {
adapter = new PlaywrightAutomationAdapter({
headless: true,
timeout: 5000,
baseUrl: fixtureBaseUrl,
mode: 'mock',
});
await adapter.connect();
});
afterAll(async () => {
await adapter.disconnect();
});
it('executes on Cars page in mock wizard', async () => {
await adapter.navigateToPage(`${fixtureBaseUrl}/step-08-set-cars.html`);
await harness.navigateToFixtureStep(8);
const page = adapter.getPage();
const page = harness.adapter.getPage();
expect(page).not.toBeNull();
const stepIndicatorBefore = await page!.textContent('[data-indicator]');
expect(stepIndicatorBefore).toContain('Set Cars');
const result = await adapter.executeStep(StepId.create(8), {});
const result = await harness.executeStep(8, {});
expect(result.success).toBe(true);
expect(result.error).toBeUndefined();
@@ -40,57 +31,29 @@ describe('Step 8 – cars', () => {
});
describe('state validation', () => {
let server: FixtureServer;
let adapter: PlaywrightAutomationAdapter;
let logger: PinoLogAdapter;
beforeEach(async () => {
server = new FixtureServer();
const serverInfo = await server.start();
logger = new PinoLogAdapter();
adapter = new PlaywrightAutomationAdapter(
{
headless: true,
timeout: 5000,
mode: 'mock',
baseUrl: serverInfo.url,
},
logger,
);
await adapter.connect();
});
afterEach(async () => {
await adapter.disconnect();
await server.stop();
});
it('fails validation when executed on Track page instead of Cars page', async () => {
await adapter.navigateToPage(server.getFixtureUrl(11));
await adapter.getPage()?.waitForLoadState('domcontentloaded');
await harness.navigateToFixtureStep(11);
await harness.adapter.getPage()?.waitForLoadState('domcontentloaded');
await expect(async () => {
await adapter.executeStep(StepId.create(8), {});
await harness.executeStep(8, {});
}).rejects.toThrow(/Step 8 FAILED validation/i);
});
it('fails fast on Step 8 if already past Cars page', async () => {
await adapter.navigateToPage(server.getFixtureUrl(11));
await adapter.getPage()?.waitForLoadState('domcontentloaded');
await harness.navigateToFixtureStep(11);
await harness.adapter.getPage()?.waitForLoadState('domcontentloaded');
await expect(async () => {
await adapter.executeStep(StepId.create(8), {});
await harness.executeStep(8, {});
}).rejects.toThrow(/Step 8 FAILED validation/i);
});
it('passes validation when on Cars page', async () => {
await adapter.navigateToPage(server.getFixtureUrl(8));
await adapter.getPage()?.waitForLoadState('domcontentloaded');
await harness.navigateToFixtureStep(8);
await harness.adapter.getPage()?.waitForLoadState('domcontentloaded');
const result = await adapter.executeStep(StepId.create(8), {});
const result = await harness.executeStep(8, {});
expect(result.success).toBe(true);
});

118
tests/e2e/steps/step-09-add-car.e2e.test.ts
View File

@@ -1,41 +1,31 @@
import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
import path from 'path';
import { PlaywrightAutomationAdapter, FixtureServer } from 'packages/infrastructure/adapters/automation';
import { StepId } from 'packages/domain/value-objects/StepId';
import { PinoLogAdapter } from 'packages/infrastructure/adapters/logging/PinoLogAdapter';
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import type { StepHarness } from '../support/StepHarness';
import { createStepHarness } from '../support/StepHarness';
describe('Step 9 – add car', () => {
let harness: StepHarness;
beforeEach(async () => {
harness = await createStepHarness();
});
afterEach(async () => {
await harness.dispose();
});
describe('happy path', () => {
let adapter: PlaywrightAutomationAdapter;
const fixtureBaseUrl = `file://${path.resolve(process.cwd(), 'html-dumps')}`;
beforeAll(async () => {
adapter = new PlaywrightAutomationAdapter({
headless: true,
timeout: 5000,
baseUrl: fixtureBaseUrl,
mode: 'mock',
});
await adapter.connect();
});
afterAll(async () => {
await adapter.disconnect();
});
it('executes on Add Car modal from Cars step', async () => {
await adapter.navigateToPage(`${fixtureBaseUrl}/step-09-add-car.html`);
await harness.navigateToFixtureStep(9);
const page = adapter.getPage();
const page = harness.adapter.getPage();
expect(page).not.toBeNull();
const modalTitleBefore = await page!.textContent('[data-indicator="add-car"]');
expect(modalTitleBefore).toContain('Add a Car');
const result = await adapter.executeStep(
StepId.create(9),
{ carSearch: 'Porsche 911 GT3 R' },
);
const result = await harness.executeStep(9, {
carSearch: 'Porsche 911 GT3 R',
});
expect(result.success).toBe(true);
expect(result.error).toBeUndefined();
@@ -43,72 +33,44 @@ describe('Step 9 – add car', () => {
});
describe('state validation', () => {
let server: FixtureServer;
let adapter: PlaywrightAutomationAdapter;
let logger: PinoLogAdapter;
beforeEach(async () => {
server = new FixtureServer();
const serverInfo = await server.start();
logger = new PinoLogAdapter();
adapter = new PlaywrightAutomationAdapter(
{
headless: true,
timeout: 5000,
mode: 'mock',
baseUrl: serverInfo.url,
},
logger,
);
await adapter.connect();
});
afterEach(async () => {
await adapter.disconnect();
await server.stop();
});
it('throws when executed on Track page instead of Cars page', async () => {
await adapter.navigateToPage(server.getFixtureUrl(11));
await adapter.getPage()?.waitForLoadState('domcontentloaded');
await harness.navigateToFixtureStep(11);
await harness.adapter.getPage()?.waitForLoadState('domcontentloaded');
await expect(async () => {
await adapter.executeStep(StepId.create(9), {
await harness.executeStep(9, {
carSearch: 'Mazda MX-5',
});
}).rejects.toThrow(/Step 9 FAILED validation/i);
});
it('detects state mismatch when Cars button is missing', async () => {
await adapter.navigateToPage(server.getFixtureUrl(11));
await adapter.getPage()?.waitForLoadState('domcontentloaded');
await harness.navigateToFixtureStep(11);
await harness.adapter.getPage()?.waitForLoadState('domcontentloaded');
await expect(async () => {
await adapter.executeStep(StepId.create(9), {
await harness.executeStep(9, {
carSearch: 'Porsche 911',
});
}).rejects.toThrow(/Expected cars step/i);
});
it('detects when Track container is present instead of Cars page', async () => {
await adapter.navigateToPage(server.getFixtureUrl(11));
await adapter.getPage()?.waitForLoadState('domcontentloaded');
await harness.navigateToFixtureStep(11);
await harness.adapter.getPage()?.waitForLoadState('domcontentloaded');
await expect(async () => {
await adapter.executeStep(StepId.create(9), {
await harness.executeStep(9, {
carSearch: 'Ferrari 488',
});
}).rejects.toThrow(/3 steps ahead|Track page/i);
});
it('passes validation when on Cars page', async () => {
await adapter.navigateToPage(server.getFixtureUrl(8));
await adapter.getPage()?.waitForLoadState('domcontentloaded');
await harness.navigateToFixtureStep(8);
await harness.adapter.getPage()?.waitForLoadState('domcontentloaded');
const result = await adapter.executeStep(StepId.create(9), {
const result = await harness.executeStep(9, {
carSearch: 'Mazda MX-5',
});
@@ -116,12 +78,12 @@ describe('Step 9 – add car', () => {
});
it('provides detailed error context in validation failure', async () => {
await adapter.navigateToPage(server.getFixtureUrl(11));
await adapter.getPage()?.waitForLoadState('domcontentloaded');
await harness.navigateToFixtureStep(11);
await harness.adapter.getPage()?.waitForLoadState('domcontentloaded');
let errorMessage = '';
try {
await adapter.executeStep(StepId.create(9), {
await harness.executeStep(9, {
carSearch: 'BMW M4',
});
} catch (error) {
@@ -133,10 +95,10 @@ describe('Step 9 – add car', () => {
});
it('validates page state before attempting any Step 9 actions', async () => {
await adapter.navigateToPage(server.getFixtureUrl(11));
await adapter.getPage()?.waitForLoadState('domcontentloaded');
await harness.navigateToFixtureStep(11);
await harness.adapter.getPage()?.waitForLoadState('domcontentloaded');
const page = adapter.getPage();
const page = harness.adapter.getPage();
if (!page) {
throw new Error('Page not available');
}
@@ -148,7 +110,7 @@ describe('Step 9 – add car', () => {
let validationError = false;
try {
await adapter.executeStep(StepId.create(9), {
await harness.executeStep(9, {
carSearch: 'Audi R8',
});
} catch {
@@ -160,11 +122,11 @@ describe('Step 9 – add car', () => {
});
it('checks wizard footer state in Step 9', async () => {
await adapter.navigateToPage(server.getFixtureUrl(11));
await adapter.getPage()?.waitForLoadState('domcontentloaded');
await harness.navigateToFixtureStep(11);
await harness.adapter.getPage()?.waitForLoadState('domcontentloaded');
await expect(async () => {
await adapter.executeStep(StepId.create(9), {
await harness.executeStep(9, {
carSearch: 'McLaren 720S',
});
}).rejects.toThrow();

33
tests/e2e/steps/step-10-car-classes.e2e.test.ts Normal file
View File

@@ -0,0 +1,33 @@
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import type { StepHarness } from '../support/StepHarness';
import { createStepHarness } from '../support/StepHarness';
describe('Step 10 – car classes', () => {
let harness: StepHarness;
beforeEach(async () => {
harness = await createStepHarness();
});
afterEach(async () => {
await harness.dispose();
});
it('executes on Car Classes page and keeps wizard on Track path', async () => {
await harness.navigateToFixtureStep(10);
const page = harness.adapter.getPage();
expect(page).not.toBeNull();
const bodyText = await page!.textContent('body');
expect(bodyText).toContain('Add a Car Class');
const result = await harness.executeStep(10, {});
expect(result.success).toBe(true);
expect(result.error).toBeUndefined();
const footerText = await page!.textContent('.wizard-footer');
expect(footerText).toMatch(/Track/i);
});
});

41
tests/e2e/steps/step-11-track.e2e.test.ts
View File

@@ -1,52 +1,33 @@
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import { PlaywrightAutomationAdapter, FixtureServer } from 'packages/infrastructure/adapters/automation';
import { StepId } from 'packages/domain/value-objects/StepId';
import { PinoLogAdapter } from 'packages/infrastructure/adapters/logging/PinoLogAdapter';
import type { StepHarness } from '../support/StepHarness';
import { createStepHarness } from '../support/StepHarness';
describe('Step 11 – track', () => {
describe('state validation', () => {
let server: FixtureServer;
let adapter: PlaywrightAutomationAdapter;
let logger: PinoLogAdapter;
let harness: StepHarness;
beforeEach(async () => {
server = new FixtureServer();
const serverInfo = await server.start();
logger = new PinoLogAdapter();
adapter = new PlaywrightAutomationAdapter(
{
headless: true,
timeout: 5000,
mode: 'mock',
baseUrl: serverInfo.url,
},
logger,
);
await adapter.connect();
harness = await createStepHarness();
});
afterEach(async () => {
await adapter.disconnect();
await server.stop();
await harness.dispose();
});
it('fails validation when executed on Cars page instead of Track page', async () => {
await adapter.navigateToPage(server.getFixtureUrl(8));
await adapter.getPage()?.waitForLoadState('domcontentloaded');
await harness.navigateToFixtureStep(8);
await harness.adapter.getPage()?.waitForLoadState('domcontentloaded');
await expect(async () => {
await adapter.executeStep(StepId.create(11), {});
await harness.executeStep(11, {});
}).rejects.toThrow(/Step 11 FAILED validation/i);
});
it('passes validation when on Track page', async () => {
await adapter.navigateToPage(server.getFixtureUrl(11));
await adapter.getPage()?.waitForLoadState('domcontentloaded');
await harness.navigateToFixtureStep(11);
await harness.adapter.getPage()?.waitForLoadState('domcontentloaded');
const result = await adapter.executeStep(StepId.create(11), {});
const result = await harness.executeStep(11, {});
expect(result.success).toBe(true);
});

38
tests/e2e/steps/step-12-add-track.e2e.test.ts Normal file
View File

@@ -0,0 +1,38 @@
import { describe, it, expect, beforeEach, afterEach } from 'vitest';
import type { StepHarness } from '../support/StepHarness';
import { createStepHarness } from '../support/StepHarness';
describe('Step 12 – add track', () => {
let harness: StepHarness;
beforeEach(async () => {
harness = await createStepHarness();
});
afterEach(async () => {
await harness.dispose();
});
it('executes on Add Track modal from Track step', async () => {
await harness.navigateToFixtureStep(12);
const page = harness.adapter.getPage();
expect(page).not.toBeNull();
const sidebarTrack = await page!.textContent(
'#wizard-sidebar-link-set-track',
);
expect(sidebarTrack).toContain('Track');
const bodyText = await page!.textContent('body');
expect(bodyText).toMatch(/Add a Track/i);
const result = await harness.executeStep(12, {});
expect(result.success).toBe(true);
expect(result.error).toBeUndefined();
const footerText = await page!.textContent('.wizard-footer');
expect(footerText).toMatch(/Track Options/i);
});
});