test(web): restructure e2e suite with shared fixtures and tag taxonomy

Introduce e2e/fixtures/{api,product,test,seller}.ts: API URL resolution, product
factory with auto-cleanup, combined test export, shadcn-select helper.

Move all 28 specs into route-based folders mirroring /seller URL tree; drop
redundant seller- prefix. Apply @smoke / @regression / @seed-dependent tag
taxonomy plus per-feature tags. Factory-ize edit/preview/create-duplicate tests
so they pass against any catalog state. Isolate seed-dependent assertions
(specific SKUs, hardcoded counts, page-1 ordering) under @seed-dependent so the
smoke gate stays deterministic.

Fix create form Status field to use shadcn combobox interaction (commit
c5aaef4 changed the rendering from native select to button[role=combobox]).

Harden playwright config: CI workers default to 2, expect.timeout=5000,
video retain-on-failure, optional blob reporter via PLAYWRIGHT_BLOB_REPORT.
Drop test.setTimeout(90_000) and serial mode from pagination spec.

Add e2e:smoke and e2e:seed-dependent npm scripts. Ignore Playwright artifacts.

Smoke: 46/46 passing against live Aspire stack. Full suite: 105/112, with
7 known @seed-dependent failures isolated for a separate seeded-DB run.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: baotoq

src/web/.gitignore

@@ -39,3 +39,12 @@ yarn-error.log*
 # typescript
 *.tsbuildinfo
 next-env.d.ts
+
+# Playwright
+/test-results/
+/playwright-report/
+/blob-report/
+/playwright/.cache/
+
+# OMC subagent state
+.omc/

src/web/e2e/fixtures/api.ts

@@ -0,0 +1,10 @@
+// Resolves the Catalog API base URL from Aspire's injected env var first,
+// then a developer override, then a sensible local default. Centralising this
+// here keeps the 28 spec files free of duplicated env-resolution logic.
+export const API_URL =
+  process.env.services__catalog_api__http__0 ??
+  process.env.API_URL ??
+  "http://localhost:5000";
+
+export const productEndpoint = (sku: string) =>
+  `${API_URL}/api/products/${encodeURIComponent(sku)}`;

src/web/e2e/fixtures/product.ts

@@ -0,0 +1,56 @@
+import type { APIRequestContext, TestInfo } from "@playwright/test";
+import { API_URL, productEndpoint } from "./api";
+
+export type ProductPayload = {
+  sku: string;
+  name: string;
+  category: string;
+  price: number;
+  inventory: number;
+  status: "active" | "draft";
+};
+
+const defaults: Omit<ProductPayload, "sku"> = {
+  name: "Test Product",
+  category: "Ceramics",
+  price: 49.99,
+  inventory: 5,
+  status: "active",
+};
+
+// `testInfo.parallelIndex` + `testInfo.testId` make the SKU unique across both
+// workers and tests, so concurrent mutations against a shared Catalog DB never
+// collide. `Date.now()` alone breaks at sub-millisecond test starts.
+export const uniqueSku = (testInfo: TestInfo, prefix = "TEST") =>
+  `${prefix}-W${testInfo.parallelIndex}-${testInfo.testId.slice(0, 6).toUpperCase()}`;
+
+export const createProduct = async (
+  request: APIRequestContext,
+  payload: Partial<ProductPayload> & { sku: string },
+): Promise<ProductPayload> => {
+  const body: ProductPayload = { ...defaults, ...payload };
+  const res = await request.post(`${API_URL}/api/products`, { data: body });
+  if (!res.ok()) {
+    throw new Error(
+      `createProduct failed: ${res.status()} ${await res.text()}`,
+    );
+  }
+  return body;
+};
+
+export const deleteProduct = async (
+  request: APIRequestContext,
+  sku: string,
+): Promise<void> => {
+  // Cleanup is best-effort: a teardown failure shouldn't fail the test, but it
+  // shouldn't be silently swallowed either — Playwright surfaces it in trace.
+  const res = await request.delete(productEndpoint(sku));
+  if (!res.ok() && res.status() !== 404) {
+    throw new Error(
+      `deleteProduct failed for ${sku}: ${res.status()} ${await res.text()}`,
+    );
+  }
+};
+
+export const getProduct = async (request: APIRequestContext, sku: string) =>
+  request.get(productEndpoint(sku));

src/web/e2e/fixtures/seller.ts

@@ -0,0 +1,32 @@
+import type { Page } from "@playwright/test";
+
+export const sellerRoutes = {
+  dashboard: "/seller",
+  listings: "/seller/listings",
+  listingsNew: "/seller/listings/new",
+  listingsBulk: "/seller/listings/bulk",
+  listingsPublished: "/seller/listings/published",
+  listingEdit: (sku: string) =>
+    `/seller/listings/${encodeURIComponent(sku)}/edit`,
+  listingPreview: (sku: string) =>
+    `/seller/listings/${encodeURIComponent(sku)}/preview`,
+  promos: "/seller/promos",
+  orders: "/seller/orders",
+  payouts: "/seller/payouts",
+  analytics: "/seller/analytics",
+  marketing: "/seller/marketing",
+  welcome: "/seller/welcome",
+  apply: "/seller/apply",
+} as const;
+
+// shadcn Select renders as <button role="combobox"> + Radix listbox, so
+// Playwright's `selectOption` (which targets native <select>) fails. Open the
+// trigger then click the option by visible name.
+export const selectShadcnOption = async (
+  page: Page,
+  labelText: string,
+  optionName: string,
+) => {
+  await page.getByLabel(labelText).click();
+  await page.getByRole("option", { name: optionName }).click();
+};

src/web/e2e/fixtures/test.ts

@@ -0,0 +1,55 @@
+import { test as base } from "@playwright/test";
+import {
+  createProduct,
+  deleteProduct,
+  type ProductPayload,
+  uniqueSku,
+} from "./product";
+
+type ProductFactory = {
+  create: (
+    overrides?: Partial<ProductPayload> & { skuPrefix?: string },
+  ) => Promise<ProductPayload>;
+};
+
+type Fixtures = {
+  productFactory: ProductFactory;
+};
+
+// Test-scoped factory: every created SKU is tracked and cleaned up after the
+// test, even on failure. Removes the inline POST/DELETE boilerplate that was
+// duplicated across the mutation specs.
+export const test = base.extend<Fixtures>({
+  productFactory: async ({ request }, use, testInfo) => {
+    const created: string[] = [];
+
+    const factory: ProductFactory = {
+      create: async (overrides = {}) => {
+        const { skuPrefix, ...rest } = overrides;
+        const sku = rest.sku ?? uniqueSku(testInfo, skuPrefix);
+        const product = await createProduct(request, { ...rest, sku });
+        created.push(sku);
+        return product;
+      },
+    };
+
+    await use(factory);
+
+    await Promise.all(
+      created.map((sku) =>
+        deleteProduct(request, sku).catch((err) => {
+          // Cleanup errors are visible in the trace via this annotation; the
+          // test result itself is preserved.
+          testInfo.annotations.push({
+            type: "cleanup-failed",
+            description: `${sku}: ${err.message}`,
+          });
+        }),
+      ),
+    );
+  },
+});
+
+export { expect } from "@playwright/test";
+export { API_URL, productEndpoint } from "./api";
+export { createProduct, deleteProduct, getProduct, uniqueSku } from "./product";