cabloy 5.1.202 → 5.1.203

package/repo-e2e/scripts/runE2eArgs.test.ts

@@ -20,15 +20,11 @@ function withSpecs(callback: (specsDir: string) => void): void {
   }
 }
 
-test('parses mode, multiple specs, and repeatable tags', () => {
+test('parses multiple specs and repeatable tags', () => {
   withSpecs(specsDir => {
     assert.deepEqual(
-      parseE2eArgs(
-        ['--clean', 'cabloy-basic', 'account', '--tag', '@web', '--tag=@smoke'],
-        specsDir,
-      ),
+      parseE2eArgs(['cabloy-basic', 'account', '--tag', '@web', '--tag=@smoke'], specsDir),
       {
-        mode: 'clean',
         specNames: ['cabloy-basic', 'account'],
         playwrightArgs: [],
         tags: ['@web', '@smoke'],
@@ -39,8 +35,7 @@ test('parses mode, multiple specs, and repeatable tags', () => {
 
 test('allows no spec names and forwards Playwright filters', () => {
   withSpecs(specsDir => {
-    assert.deepEqual(parseE2eArgs(['--fast', '--grep', '@flow'], specsDir), {
-      mode: 'fast',
+    assert.deepEqual(parseE2eArgs(['--grep', '@flow'], specsDir), {
       specNames: [],
       playwrightArgs: ['--grep', '@flow'],
       tags: [],
@@ -50,19 +45,28 @@ test('allows no spec names and forwards Playwright filters', () => {
 
 test('rejects invalid or unknown specs and managed config overrides', () => {
   withSpecs(specsDir => {
-    assert.throws(() => parseE2eArgs(['--fast', '../account'], specsDir), /Invalid E2E spec name/);
-    assert.throws(() => parseE2eArgs(['--fast', 'missing'], specsDir), /Unknown E2E spec/);
-    assert.throws(
-      () => parseE2eArgs(['--fast', '--config', 'other.ts'], specsDir),
-      /manages --config/,
-    );
+    assert.throws(() => parseE2eArgs(['../account'], specsDir), /Invalid E2E spec name/);
+    assert.throws(() => parseE2eArgs(['missing'], specsDir), /Unknown E2E spec/);
+    for (const args of [
+      ['--config', 'other.ts'],
+      ['--config=other.ts'],
+      ['-c', 'other.ts'],
+      ['-c=other.ts'],
+      ['-cother.ts'],
+    ]) {
+      assert.throws(() => parseE2eArgs(args, specsDir), /manages --config/);
+    }
+    for (const args of [['--workers', '2'], ['--workers=2'], ['-j', '2'], ['-j=2'], ['-j2']]) {
+      assert.throws(() => parseE2eArgs(args, specsDir), /manages --workers/);
+    }
   });
 });
 
-test('requires exactly one run mode', () => {
+test('rejects removed clean and fast options', () => {
   withSpecs(specsDir => {
-    assert.throws(() => parseE2eArgs(['account'], specsDir), /Missing E2E mode/);
-    assert.throws(() => parseE2eArgs(['--clean', '--fast'], specsDir), /exactly one/);
+    for (const option of ['--clean', '--fast', '--clean=true', '--fast=false']) {
+      assert.throws(() => parseE2eArgs(['account', option], specsDir), /Unsupported E2E option/);
+    }
   });
 });
 

package/repo-e2e/scripts/runE2eArgs.ts

@@ -1,10 +1,7 @@
 import { existsSync } from 'node:fs';
 import { resolve } from 'node:path';
 
-export type E2eRunMode = 'clean' | 'fast';
-
 export type ParsedE2eArgs = {
-  mode: E2eRunMode;
   specNames: string[];
   playwrightArgs: string[];
   tags: string[];
@@ -28,7 +25,6 @@ const VALUE_OPTIONS = new Set([
   '--shard',
   '--timeout',
   '--trace',
-  '--workers',
 ]);
 
 function optionName(arg: string): string {
@@ -46,35 +42,23 @@ export function buildTagGrep(tags: string[]): string | undefined {
 }
 
 export function parseE2eArgs(args: string[], specsDir: string): ParsedE2eArgs {
-  let mode: E2eRunMode | undefined;
-  const remainingArgs: string[] = [];
-
-  for (const arg of args) {
-    if (arg === '--clean' || arg === '--fast') {
-      if (mode && mode !== arg.slice(2)) {
-        throw new Error('Choose exactly one E2E mode: --clean or --fast.');
-      }
-      if (mode === arg.slice(2)) {
-        throw new Error(`E2E mode ${arg} was provided more than once.`);
-      }
-      mode = arg.slice(2) as E2eRunMode;
-    } else {
-      remainingArgs.push(arg);
-    }
-  }
-
-  if (!mode) {
-    throw new Error('Missing E2E mode. Use --clean or --fast.');
-  }
-
   const specNames: string[] = [];
   const playwrightArgs: string[] = [];
   const tags: string[] = [];
   let optionStarted = false;
   let pendingValueFor: string | undefined;
 
-  for (let index = 0; index < remainingArgs.length; index++) {
-    const arg = remainingArgs[index];
+  for (let index = 0; index < args.length; index++) {
+    const arg = args[index];
+
+    if (
+      arg === '--clean' ||
+      arg.startsWith('--clean=') ||
+      arg === '--fast' ||
+      arg.startsWith('--fast=')
+    ) {
+      throw new Error(`Unsupported E2E option: ${arg}. Use the single managed test:e2e command.`);
+    }
 
     if (pendingValueFor) {
       if (!arg || arg.startsWith('--')) {
@@ -100,9 +84,12 @@ export function parseE2eArgs(args: string[], specsDir: string): ParsedE2eArgs {
       continue;
     }
 
-    if (arg === '--config' || arg.startsWith('--config=')) {
+    if (arg === '--config' || arg.startsWith('--config=') || arg.startsWith('-c')) {
       throw new Error('The E2E runner manages --config; do not provide it.');
     }
+    if (arg === '--workers' || arg.startsWith('--workers=') || arg.startsWith('-j')) {
+      throw new Error('The E2E runner manages --workers; do not provide it.');
+    }
 
     if (!optionStarted && !arg.startsWith('-')) {
       if (!SPEC_NAME_PATTERN.test(arg)) {
@@ -133,7 +120,7 @@ export function parseE2eArgs(args: string[], specsDir: string): ParsedE2eArgs {
     throw new Error(`Missing value for ${pendingValueFor}.`);
   }
 
-  return { mode, specNames, playwrightArgs, tags };
+  return { specNames, playwrightArgs, tags };
 }
 
 export function combineGreps(args: string[], tags: string[]): string[] {

package/repo-e2e/scripts/startE2eVona.ts

@@ -1,19 +1,30 @@
 import type { ChildProcess } from 'node:child_process';
 
 import { spawn } from 'node:child_process';
+import { resolve } from 'node:path';
 
 import { E2E_LOCAL_BASE_URL, E2E_ROOT_DIR } from './e2e.ts';
 
-const child: ChildProcess = spawn('npm', ['run', 'dev:one'], {
-  cwd: E2E_ROOT_DIR,
-  detached: process.platform !== 'win32',
-  stdio: 'inherit',
-  env: {
-    ...process.env,
-    SERVER_SERVE_PROTOCOL: 'http',
-    SERVER_SERVE_HOST: E2E_LOCAL_BASE_URL.replace(/^https?:\/\//, ''),
+const child: ChildProcess = spawn(
+  process.execPath,
+  [
+    './packages-cli/cli/src/bin/vona.ts',
+    ':bin:dev',
+    '--workers=1',
+    '--flavor=normal',
+    '--mode=test',
+  ],
+  {
+    cwd: resolve(E2E_ROOT_DIR, 'vona'),
+    detached: process.platform !== 'win32',
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      SERVER_SERVE_PROTOCOL: 'http',
+      SERVER_SERVE_HOST: E2E_LOCAL_BASE_URL.replace(/^https?:\/\//, ''),
+    },
   },
-});
+);
 
 const gracefulShutdownTimeout = 7000;
 

package/repo-e2e/specs/a-commerce.spec.ts

@@ -8,6 +8,155 @@ const addressResourceUrl =
 const addressMinePath = '/api/commerce/member/address/mine';
 const addressActionPath = '/api/commerce/member/address';
 const passportTestActivateCurrentPath = '/api/home/user/passportTest/activateCurrent';
+const commerceFixturePath = '/api/commerce/trade/e2eFixture';
+
+interface IOwnedCommerceFixture {
+  customerToken?: string;
+  customerName?: string;
+  adminToken?: string;
+  categoryId?: number | string;
+  orderIds: Array<number | string>;
+}
+
+const ownedFixtures = new Map<string, IOwnedCommerceFixture>();
+
+function ownedFixture(testInfo: TestInfo): IOwnedCommerceFixture {
+  let fixture = ownedFixtures.get(testInfo.testId);
+  if (!fixture) {
+    fixture = { orderIds: [] };
+    ownedFixtures.set(testInfo.testId, fixture);
+  }
+  return fixture;
+}
+
+async function fixtureRequest(
+  request: APIRequestContext,
+  method: 'post' | 'delete',
+  path: string,
+  token: string,
+  data?: object,
+) {
+  const response = await request[method](path, {
+    headers: { Authorization: `Bearer ${token}`, Accept: 'application/json' },
+    ...(data ? { data } : {}),
+  });
+  if (!response.ok())
+    throw new Error(`Commerce fixture ${method} ${path} failed (${response.status()})`);
+  if (method === 'delete') return;
+  return (await response.json()).data;
+}
+
+async function createOwnedCatalogue(browser: Browser, testInfo: TestInfo) {
+  const fixture = ownedFixture(testInfo);
+  const context = await browser.newContext();
+  try {
+    const page = await context.newPage();
+    await login(page, '/commerce-admin/', 'admin', '123456', 'commerceAdmin');
+    const token = (await context.cookies()).find(cookie => cookie.name === 'token')?.value;
+    if (!token) throw new Error('Commerce Admin fixture token unavailable');
+    fixture.adminToken = token;
+    // Server-side creation is transactional; record the returned category before
+    // validating the response so assertion failures still trigger its cleanup.
+    const catalogue = await fixtureRequest(
+      context.request,
+      'post',
+      `${commerceFixturePath}/catalogue`,
+      token,
+    );
+    fixture.categoryId = catalogue.categoryId;
+    expectTableIdentity(catalogue.categoryId);
+    expectTableIdentity(catalogue.skuId);
+    expect(catalogue.initialStock).toBe(10);
+    return catalogue as {
+      categoryId: number | string;
+      skuId: number | string;
+      title: string;
+      code: string;
+      initialStock: number;
+    };
+  } finally {
+    await context.close();
+  }
+}
+
+async function dispatchOwnedOutcome(
+  request: APIRequestContext,
+  testInfo: TestInfo,
+  checkout: { orderId: number | string; paymentAttemptId: number | string },
+  refundAttemptId?: number | string,
+) {
+  const token = ownedFixture(testInfo).customerToken;
+  if (!token) throw new Error('Commerce customer fixture token unavailable');
+  return await fixtureRequest(
+    request,
+    'post',
+    `${commerceFixturePath}/order/${checkout.orderId}/${refundAttemptId ? 'refund' : 'payment'}/${refundAttemptId ?? checkout.paymentAttemptId}/dispatch`,
+    token,
+  );
+}
+
+// Playwright invokes afterEach even for partial setup and failed assertions. Never delete
+// shared seed stock: remove only the IDs created by these tests, in reverse dependency order.
+test.afterEach(async ({ request }, testInfo) => {
+  const fixture = ownedFixtures.get(testInfo.testId);
+  if (!fixture) return;
+  ownedFixtures.delete(testInfo.testId);
+  const errors: Error[] = [];
+  const clean = async (label: string, action: () => Promise<unknown>) => {
+    try {
+      await action();
+    } catch (error) {
+      errors.push(new Error(`${label}: ${String(error)}`));
+    }
+  };
+  if (fixture.customerToken) {
+    for (const orderId of fixture.orderIds.toReversed()) {
+      await clean(`order ${orderId}`, () =>
+        fixtureRequest(
+          request,
+          'delete',
+          `${commerceFixturePath}/order/${orderId}`,
+          fixture.customerToken!,
+        ),
+      );
+    }
+    if (!errors.length) {
+      await clean('customer Commerce resources', () =>
+        fixtureRequest(
+          request,
+          'delete',
+          `${commerceFixturePath}/customer`,
+          fixture.customerToken!,
+        ),
+      );
+    }
+    // Keep the identity when Commerce cleanup fails, so its surviving records
+    // retain their owner and can be identified and removed without a global sweep.
+    if (!errors.length) {
+      await clean('customer account', () =>
+        fixtureRequest(
+          request,
+          'delete',
+          '/api/home/user/passportTest/removeCurrentFixture',
+          fixture.customerToken!,
+        ),
+      );
+    }
+  }
+  // Preserve the catalogue if order/cart cleanup failed: deleting its SKU would
+  // otherwise obscure the precise ownership of a surviving customer's records.
+  if (!errors.length && fixture.categoryId && fixture.adminToken) {
+    await clean(`catalogue ${fixture.categoryId}`, () =>
+      fixtureRequest(
+        request,
+        'delete',
+        `${commerceFixturePath}/catalogue/${fixture.categoryId}`,
+        fixture.adminToken!,
+      ),
+    );
+  }
+  if (errors.length) throw new AggregateError(errors, 'Commerce E2E fixture cleanup failed');
+});
 
 interface IAddressFixture {
   addressLine1: string;
@@ -105,7 +254,7 @@ async function registerCustomer(
   testInfo: TestInfo,
 ): Promise<{ password: string; username: string }> {
   const id = `${testInfo.workerIndex}-${testInfo.parallelIndex ?? testInfo.retry}-${Date.now()}`;
-  const username = `e2e-address-${id}`;
+  const username = `e2e-fixture-address-${id}`;
   const password = 'address-e2e-password';
   const captchaResponse = await request.post('/api/captcha/create', {
     data: { scene: 'captcha-simple:simple' },
@@ -131,6 +280,9 @@ async function registerCustomer(
   expect(registerResponse.ok()).toBeTruthy();
   const registration = (await registerResponse.json()).data;
   expect(registration?.jwt?.accessToken).toEqual(expect.any(String));
+  const fixture = ownedFixture(testInfo);
+  fixture.customerToken = registration.jwt.accessToken;
+  fixture.customerName = username;
   const activateResponse = await request.post(passportTestActivateCurrentPath, {
     headers: { Authorization: `Bearer ${registration.jwt.accessToken}` },
   });
@@ -220,7 +372,7 @@ test(
   async ({ page, request }) => {
     const response = await request.get('/commerce');
     expect(response.ok()).toBeTruthy();
-    expect(response.headers()['cache-control']).toBe('no-cache, no-store, must-revalidate');
+    expect(response.headers()['cache-control']).toBe('public, max-age=600');
     const html = await response.text();
     const normalizedHtml = html.toLowerCase();
     expect(normalizedHtml).not.toContain('data-zova-hydrated');
@@ -382,7 +534,7 @@ test(
     for (const [index, response] of responses.entries()) {
       expect(response.status(), `public response ${index}`).toBe(200);
       expect(response.headers()['cache-control'], `public response ${index}`).toBe(
-        'no-cache, no-store, must-revalidate',
+        'public, max-age=600',
       );
       expect(html[index].toLowerCase()).not.toContain('data-zova-hydrated');
       expect(html[index]).toContain('data-ssr-theme-dark-false="light"');
@@ -629,16 +781,22 @@ test(
       testInfo,
     );
     try {
+      const catalogue = await createOwnedCatalogue(browser, testInfo);
       await page.goto('/commerce', { waitUntil: 'load' });
       await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
       await expect(page.getByRole('heading', { name: 'Commerce catalogue' })).toBeVisible();
 
-      const productLink = page.getByRole('link', { name: 'Pour-Over Coffee Set', exact: true });
+      const productLink = page.getByRole('link', { name: catalogue.title, exact: true });
       await expect(productLink).toBeVisible();
       await productLink.click();
       await expect(page).toHaveURL(/\/commerce\/product\/\d+(?:\/|$)/);
-      await expect(page.getByRole('heading', { name: 'Pour-Over Coffee Set' })).toBeVisible();
-      await expect(page.getByText('COF-SET-01')).toBeVisible();
+      await expect(page.getByRole('heading', { name: catalogue.title })).toBeVisible();
+      await expect(
+        page
+          .getByRole('button', { name: 'Add to cart', exact: true })
+          .locator('..')
+          .getByText(catalogue.code),
+      ).toBeVisible();
       await expect(page.getByText('$45.99')).toBeVisible();
 
       const addResponse = waitForApiResponse(page, 'POST', '/api/commerce/trade/cart/items');
@@ -649,7 +807,7 @@ test(
       await expect(page).toHaveURL(/\/commerce\/commerce\/trade\/cart(?:\/|$)/);
       await expect(page.getByRole('heading', { name: 'Cart' })).toBeVisible();
       const cartItem = page.locator('article').filter({ has: page.getByRole('spinbutton') });
-      await expect(cartItem).toContainText('COF-SET-01');
+      await expect(cartItem).toContainText(catalogue.code);
       await expect(cartItem).toContainText('$45.99');
       await expect(cartItem.getByRole('spinbutton')).toHaveValue('1');
 
@@ -669,6 +827,7 @@ test(
       const checkoutResponseValue = await checkoutResponse;
       expect(checkoutResponseValue.ok()).toBeTruthy();
       const checkout = (await checkoutResponseValue.json()).data;
+      ownedFixture(testInfo).orderIds.push(checkout.orderId);
       expectTableIdentity(checkout.orderId);
       expectTableIdentity(checkout.paymentAttemptId);
       expectTableIdentity(checkout.paymentSessionId);
@@ -699,6 +858,11 @@ test(
       );
       await page.getByRole('button', { name: 'Payment succeeded', exact: true }).click();
       expect((await completeResponse).ok()).toBeTruthy();
+      expect(await dispatchOwnedOutcome(request, testInfo, checkout)).toMatchObject({
+        orderState: 'paid',
+        attemptState: 'succeeded',
+        stock: 9,
+      });
       await expect(page).toHaveURL(
         new RegExp(`/commerce/commerce/trade/order/${checkout.orderId}(?:/|$)`),
         {
@@ -717,8 +881,8 @@ test(
       expect(orderHtml).toContain(fixture.recipientName);
       expect(orderHtml).toContain(fixture.addressLine1);
       expect(orderHtml).toContain('Discount: $0.00');
-      expect(orderHtml).toContain('Pour-Over Coffee Set');
-      expect(orderHtml).toContain('COF-SET-01');
+      expect(orderHtml).toContain(catalogue.title);
+      expect(orderHtml).toContain(catalogue.code);
       expect(orderHtml).toContain('1 × $45.99 = $45.99');
 
       const orderDocumentResponse = await page.reload({ waitUntil: 'load' });
@@ -729,8 +893,8 @@ test(
       await expect(page.getByText(fixture.recipientName)).toBeVisible();
       await expect(page.getByText(fixture.addressLine1)).toBeVisible();
       await expect(page.getByText('Discount: $0.00')).toBeVisible();
-      await expect(page.getByRole('heading', { name: 'Pour-Over Coffee Set' })).toBeVisible();
-      await expect(page.getByText('COF-SET-01')).toBeVisible();
+      await expect(page.getByRole('heading', { name: catalogue.title })).toBeVisible();
+      await expect(page.getByRole('paragraph').filter({ hasText: catalogue.code })).toBeVisible();
       await expect(page.getByText('1 × $45.99 = $45.99')).toBeVisible();
 
       const shipmentCarrier = 'Cabloy Express';
@@ -766,8 +930,9 @@ test(
         await expect(adminPage.getByText('Purchased lines').first()).toBeVisible();
         await expect(adminPage.getByText('addressSnapshot').first()).toBeVisible();
         await expect(adminPage.getByText('couponSnapshot').first()).toBeVisible();
-        await expect(adminPage.getByText('Pour-Over Coffee Set')).toBeVisible();
-        await expect(adminPage.getByText('COF-SET-01')).toBeVisible();
+        await expect(
+          adminPage.getByRole('cell', { name: catalogue.title, exact: true }),
+        ).toHaveCount(2);
         await expect(adminPage.getByRole('button', { name: 'Submit', exact: true })).toHaveCount(0);
         await adminPage.getByRole('button', { name: 'Back', exact: true }).click();
         await expect(orderRow).toBeVisible();
@@ -844,15 +1009,16 @@ test(
       testInfo,
     );
     try {
+      const catalogue = await createOwnedCatalogue(browser, testInfo);
       await page.goto('/commerce', { waitUntil: 'load' });
-      const productLink = page.getByRole('link', { name: 'Pour-Over Coffee Set', exact: true });
+      const productLink = page.getByRole('link', { name: catalogue.title, exact: true });
       await expect(productLink).toBeVisible();
       await productLink.click();
       await expect(page).toHaveURL(/\/commerce\/product\/\d+(?:\/|$)/);
       await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
-      await expect(page.getByRole('heading', { name: 'Pour-Over Coffee Set' })).toBeVisible();
-      await expect(page.getByText('COF-SET-01')).toBeVisible();
+      await expect(page.getByRole('heading', { name: catalogue.title })).toBeVisible();
       const addToCartButton = page.getByRole('button', { name: 'Add to cart', exact: true });
+      await expect(addToCartButton.locator('..')).toContainText(catalogue.code);
       await expect(addToCartButton).toBeEnabled();
       const addResponse = waitForApiResponse(page, 'POST', '/api/commerce/trade/cart/items');
       await addToCartButton.click();
@@ -868,6 +1034,7 @@ test(
       const checkoutResponseValue = await checkoutResponse;
       expect(checkoutResponseValue.ok()).toBeTruthy();
       const checkout = (await checkoutResponseValue.json()).data;
+      ownedFixture(testInfo).orderIds.push(checkout.orderId);
       expectTableIdentity(checkout.orderId);
       expectTableIdentity(checkout.paymentSessionId);
       const startResponse = waitForApiResponse(
@@ -885,6 +1052,11 @@ test(
       );
       await page.getByRole('button', { name: 'Payment succeeded', exact: true }).click();
       expect((await completeResponse).ok()).toBeTruthy();
+      expect(await dispatchOwnedOutcome(request, testInfo, checkout)).toMatchObject({
+        orderState: 'paid',
+        attemptState: 'succeeded',
+        stock: 9,
+      });
       await expect(page).toHaveURL(
         new RegExp(`/commerce/commerce/trade/order/${checkout.orderId}(?:/|$)`),
         {
@@ -951,15 +1123,16 @@ test(
       testInfo,
     );
     try {
+      const catalogue = await createOwnedCatalogue(browser, testInfo);
       await page.goto('/commerce', { waitUntil: 'load' });
-      const productLink = page.getByRole('link', { name: 'Pour-Over Coffee Set', exact: true });
+      const productLink = page.getByRole('link', { name: catalogue.title, exact: true });
       await expect(productLink).toBeVisible();
       await productLink.click();
       await expect(page).toHaveURL(/\/commerce\/product\/\d+(?:\/|$)/);
       await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
-      await expect(page.getByRole('heading', { name: 'Pour-Over Coffee Set' })).toBeVisible();
-      await expect(page.getByText('COF-SET-01')).toBeVisible();
+      await expect(page.getByRole('heading', { name: catalogue.title })).toBeVisible();
       const addToCartButton = page.getByRole('button', { name: 'Add to cart', exact: true });
+      await expect(addToCartButton.locator('..')).toContainText(catalogue.code);
       await expect(addToCartButton).toBeEnabled();
       const addResponse = waitForApiResponse(page, 'POST', '/api/commerce/trade/cart/items');
       await addToCartButton.click();
@@ -975,6 +1148,7 @@ test(
       const checkoutResponseValue = await checkoutResponse;
       expect(checkoutResponseValue.ok()).toBeTruthy();
       const checkout = (await checkoutResponseValue.json()).data;
+      ownedFixture(testInfo).orderIds.push(checkout.orderId);
       expectTableIdentity(checkout.orderId);
       expectTableIdentity(checkout.paymentSessionId);
       expect(checkout.state).toBe('awaiting_payment');
@@ -1077,13 +1251,14 @@ test(
       testInfo,
     );
     try {
+      const catalogue = await createOwnedCatalogue(browser, testInfo);
       await page.goto('/commerce', { waitUntil: 'load' });
       await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
-      const productLink = page.getByRole('link', { name: 'Pour-Over Coffee Set', exact: true });
+      const productLink = page.getByRole('link', { name: catalogue.title, exact: true });
       await expect(productLink).toBeVisible();
       await productLink.click();
       await expect(page).toHaveURL(/\/commerce\/product\/\d+(?:\/|$)/);
-      await expect(page.getByRole('heading', { name: 'Pour-Over Coffee Set' })).toBeVisible();
+      await expect(page.getByRole('heading', { name: catalogue.title })).toBeVisible();
       const addResponse = waitForApiResponse(page, 'POST', '/api/commerce/trade/cart/items');
       await page.getByRole('button', { name: 'Add to cart', exact: true }).click();
       expect((await addResponse).ok()).toBeTruthy();
@@ -1100,6 +1275,7 @@ test(
       const checkoutResponseValue = await checkoutResponse;
       expect(checkoutResponseValue.ok()).toBeTruthy();
       const checkout = (await checkoutResponseValue.json()).data;
+      ownedFixture(testInfo).orderIds.push(checkout.orderId);
       expectTableIdentity(checkout.orderId);
       expectTableIdentity(checkout.paymentSessionId);
       const startResponse = waitForApiResponse(
@@ -1118,6 +1294,11 @@ test(
       );
       await page.getByRole('button', { name: 'Cancel payment', exact: true }).click();
       expect((await cancelResponse).ok()).toBeTruthy();
+      expect(await dispatchOwnedOutcome(request, testInfo, checkout)).toMatchObject({
+        orderState: 'cancelled',
+        attemptState: 'cancelled',
+        stock: 10,
+      });
       await expect(page).toHaveURL(
         new RegExp(`/commerce/commerce/trade/order/${checkout.orderId}(?:/|$)`),
         {
@@ -1144,15 +1325,21 @@ test(
       testInfo,
     );
     try {
+      const catalogue = await createOwnedCatalogue(browser, testInfo);
       await page.goto('/commerce', { waitUntil: 'load' });
       await expect(page.locator('html')).toHaveAttribute('data-zova-hydrated', 'commerce');
       await expect(page.getByRole('heading', { name: 'Commerce catalogue' })).toBeVisible();
-      const productLink = page.getByRole('link', { name: 'Pour-Over Coffee Set', exact: true });
+      const productLink = page.getByRole('link', { name: catalogue.title, exact: true });
       await expect(productLink).toBeVisible();
       await productLink.click();
       await expect(page).toHaveURL(/\/commerce\/product\/\d+(?:\/|$)/);
-      await expect(page.getByRole('heading', { name: 'Pour-Over Coffee Set' })).toBeVisible();
-      await expect(page.getByText('COF-SET-01')).toBeVisible();
+      await expect(page.getByRole('heading', { name: catalogue.title })).toBeVisible();
+      await expect(
+        page
+          .getByRole('button', { name: 'Add to cart', exact: true })
+          .locator('..')
+          .getByText(catalogue.code),
+      ).toBeVisible();
       await expect(page.getByText('$45.99')).toBeVisible();
       const addResponse = waitForApiResponse(page, 'POST', '/api/commerce/trade/cart/items');
       await page.getByRole('button', { name: 'Add to cart', exact: true }).click();
@@ -1169,6 +1356,7 @@ test(
       const checkoutResponseValue = await checkoutResponse;
       expect(checkoutResponseValue.ok()).toBeTruthy();
       const checkout = (await checkoutResponseValue.json()).data;
+      ownedFixture(testInfo).orderIds.push(checkout.orderId);
       expectTableIdentity(checkout.orderId);
       expectTableIdentity(checkout.paymentAttemptId);
       expectTableIdentity(checkout.paymentSessionId);
@@ -1189,6 +1377,11 @@ test(
       );
       await page.getByRole('button', { name: 'Payment succeeded', exact: true }).click();
       expect((await completeResponse).ok()).toBeTruthy();
+      expect(await dispatchOwnedOutcome(request, testInfo, checkout)).toMatchObject({
+        orderState: 'paid',
+        attemptState: 'succeeded',
+        stock: 9,
+      });
       await expect(page.getByText('paid · $45.99')).toBeVisible({ timeout: 40_000 });
 
       const requestResponse = waitForApiResponse(
@@ -1329,15 +1522,23 @@ test(
             exact: true,
           }),
         ).toHaveCount(0);
-        const completeRefundResponse = waitForApiResponse(
-          adminPage,
-          'POST',
+        // The Admin mock button is intentionally hidden in the production-built SSR UI.
+        // Use the existing dev/test Admin API to submit its signed mock webhook, then
+        // dispatch the linked event under the customer's separate identity.
+        const adminToken = ownedFixture(testInfo).adminToken;
+        if (!adminToken) throw new Error('Commerce Admin fixture token unavailable');
+        const completeRefund = await adminContext.request.post(
           `/api/pay/mock/payment-session/refund-operation/${executeResult.refundOperationId}/complete`,
+          { headers: { Authorization: `Bearer ${adminToken}` }, data: { outcome: 'succeeded' } },
         );
-        await refundExecutionDialog
-          .getByRole('button', { name: 'Complete mock refund', exact: true })
-          .click();
-        expect((await completeRefundResponse).ok()).toBeTruthy();
+        expect(completeRefund.ok()).toBeTruthy();
+        expect(
+          await dispatchOwnedOutcome(request, testInfo, checkout, executeResult.refundAttemptId),
+        ).toMatchObject({
+          orderState: 'refunded',
+          refundState: 'refunded',
+          stock: 10,
+        });
         await expect
           .poll(
             async () => {