Refactor infra tests, clean E2E step suites, and fix TS in tests

tests/e2e/steps/step-06-admins.e2e.test.ts

@@ -0,0 +1,70 @@
+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';
+
+describe('Step 6 – admins', () => {
+  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('completes successfully from Set Admins page', async () => {
+    await adapter.navigateToPage(server.getFixtureUrl(5));
+    const page = 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), {
+      adminSearch: 'Marc',
+    });
+
+    expect(result.success).toBe(true);
+
+    const footerText = await page!.textContent('.wizard-footer');
+    expect(footerText).toContain('Time Limit');
+  });
+
+  it('handles Add Admin drawer state without regression', async () => {
+    await adapter.navigateToPage(server.getFixtureUrl(6));
+    const page = 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), {
+      adminSearch: 'Mintel',
+    });
+
+    expect(result.success).toBe(true);
+
+    const footerText = await page!.textContent('.wizard-footer');
+    expect(footerText).toContain('Time Limit');
+  });
+});

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

@@ -0,0 +1,44 @@
+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';
+
+describe('Step 7 – time limits', () => {
+  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 Time Limits page and navigates to Cars', async () => {
+    await adapter.navigateToPage(`${fixtureBaseUrl}/step-07-time-limits.html`);
+    const page = 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), {
+      practice: 10,
+      qualify: 10,
+      race: 20,
+    });
+
+    expect(result.success).toBe(true);
+    expect(result.error).toBeUndefined();
+
+    const stepIndicatorAfter = await page!.textContent('[data-indicator]');
+    expect(stepIndicatorAfter).toContain('Set Cars');
+  });
+});

tests/e2e/steps/step-08-cars.e2e.test.ts

@@ -0,0 +1,98 @@
+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';
+
+describe('Step 8 – cars', () => {
+  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`);
+
+      const page = 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), {});
+
+      expect(result.success).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+  });
+
+  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 expect(async () => {
+        await adapter.executeStep(StepId.create(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 expect(async () => {
+        await adapter.executeStep(StepId.create(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');
+
+      const result = await adapter.executeStep(StepId.create(8), {});
+
+      expect(result.success).toBe(true);
+    });
+  });
+});

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

@@ -0,0 +1,173 @@
+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';
+
+describe('Step 9 – add car', () => {
+  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`);
+
+      const page = 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' },
+      );
+
+      expect(result.success).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+  });
+
+  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 expect(async () => {
+        await adapter.executeStep(StepId.create(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 expect(async () => {
+        await adapter.executeStep(StepId.create(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 expect(async () => {
+        await adapter.executeStep(StepId.create(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');
+
+      const result = await adapter.executeStep(StepId.create(9), {
+        carSearch: 'Mazda MX-5',
+      });
+
+      expect(result.success).toBe(true);
+    });
+
+    it('provides detailed error context in validation failure', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(11));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      let errorMessage = '';
+      try {
+        await adapter.executeStep(StepId.create(9), {
+          carSearch: 'BMW M4',
+        });
+      } catch (error) {
+        errorMessage = error instanceof Error ? error.message : String(error);
+      }
+
+      expect(errorMessage).toContain('Step 9');
+      expect(errorMessage).toMatch(/validation|mismatch|wrong page/i);
+    });
+
+    it('validates page state before attempting any Step 9 actions', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(11));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      const page = adapter.getPage();
+      if (!page) {
+        throw new Error('Page not available');
+      }
+
+      let carModalOpened = false;
+      page.on('framenavigated', () => {
+        carModalOpened = true;
+      });
+
+      let validationError = false;
+      try {
+        await adapter.executeStep(StepId.create(9), {
+          carSearch: 'Audi R8',
+        });
+      } catch {
+        validationError = true;
+      }
+
+      expect(validationError).toBe(true);
+      expect(carModalOpened).toBe(false);
+    });
+
+    it('checks wizard footer state in Step 9', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(11));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      await expect(async () => {
+        await adapter.executeStep(StepId.create(9), {
+          carSearch: 'McLaren 720S',
+        });
+      }).rejects.toThrow();
+    });
+  });
+});

tests/e2e/steps/step-11-track.e2e.test.ts

@@ -0,0 +1,54 @@
+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';
+
+describe('Step 11 – track', () => {
+  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 Cars page instead of Track page', async () => {
+      await adapter.navigateToPage(server.getFixtureUrl(8));
+      await adapter.getPage()?.waitForLoadState('domcontentloaded');
+
+      await expect(async () => {
+        await adapter.executeStep(StepId.create(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');
+
+      const result = await adapter.executeStep(StepId.create(11), {});
+
+      expect(result.success).toBe(true);
+    });
+  });
+});