@monster-orange/den 0.0.0 → 0.2.0

package/src/pillars/smoke/global-setup.ts

@@ -0,0 +1,273 @@
+/**
+ * Smoke Test Global Setup
+ *
+ * Runs once before any smoke test worker starts:
+ *   1. Checks API reachability (same VPN-aware logic as integration global-setup)
+ *   2. Pre-warms JWT tokens for all roles declared in the service manifest
+ *   3. Exports tokens to process.env so workers inherit them at fork time
+ *
+ * Environment variables read:
+ *   E2E_ENVIRONMENT   — which env config to load (default: local)
+ *   SMOKE_SERVICE     — service name from the manifest (default: api)
+ *   SMOKE_REPO        — repo name from .den/ (required)
+ *   BASE_API_URL      — override the API base URL
+ *
+ * Environment variables written (inherited by workers):
+ *   SMOKE_ADMIN_TOKEN      — API JWT for admin role      (required)
+ *   SMOKE_USER_TOKEN       — API JWT for user role       (required)
+ *   SMOKE_BETA_TOKEN       — API JWT for beta role       (optional — warns if missing)
+ *   SMOKE_ROOT_ADMIN_TOKEN — API JWT for root_admin role (optional — warns if missing)
+ */
+
+import { type FullConfig } from "@playwright/test";
+import { envSelector } from "../../shared/environment/env-selector.js";
+import { getApiToken } from "../../shared/auth/api-token.js";
+import { findManifest, resolveRepoPath, resolveService } from "./discover.js";
+import type { Environment } from "../../shared/types/index.js";
+import { resolveSmokeBaseUrlForService } from "./base-url.js";
+import { assertStorageAdminProbe } from "./admin-probe.js";
+import {
+  resolveSmokeCleanupFixture,
+  resolveSmokeStorageFixture,
+} from "./fixtures.js";
+import { acquireFixture, fixtureInstanceId } from "./cleanup.js";
+import {
+  registerSmokeFixtureReleaseHandles,
+  smokeFixtureConsumerKey,
+  writeSmokeFixtureHandoff,
+  type SmokeFixtureHandoffPayload,
+} from "./global-teardown.js";
+import { smokeRepoName } from "./smoke-repo.js";
+
+import { product } from "../../shared/product.js";
+async function globalSetup(_config: FullConfig) {
+  const environment = (process.env.E2E_ENVIRONMENT as Environment) || "local";
+  const serviceName = process.env.SMOKE_SERVICE || "api";
+  const repoName = smokeRepoName();
+
+  const envConfig = await envSelector.loadEnvironment(environment);
+
+  // Resolve the service manifest to get baseUrlKey and auth roles
+  const discovered = findManifest(repoName);
+  if (!discovered) {
+    console.error(
+      `\n❌ No manifest found for repo "${repoName}" in .${product().name}/`,
+    );
+    console.error(`   Run: make smoke-link repo=${repoName}\n`);
+    process.exit(1);
+  }
+
+  const svc = resolveService(discovered, serviceName);
+  if (!svc) {
+    const available = Object.keys(discovered.manifest.smoke ?? {}).join(", ");
+    console.error(
+      `\n❌ Service "${serviceName}" not found in ${repoName}/${product().manifestJson}`,
+    );
+    console.error(`   Available: ${available}\n`);
+    process.exit(1);
+  }
+
+  const baseUrl = resolveSmokeBaseUrlForService(
+    discovered.manifest,
+    repoName,
+    serviceName,
+    svc,
+    environment,
+    envConfig,
+    process.env.BASE_API_URL,
+  );
+  const needsVpn = baseUrl.includes(".internal.");
+
+  console.log(`\n💨 Smoke Test Setup`);
+  console.log(`   Repo:        ${repoName}`);
+  console.log(`   Service:     ${serviceName}`);
+  console.log(`   Environment: ${environment}`);
+  console.log(`   Base URL:    ${baseUrl}\n`);
+
+  // ── Reachability check ──────────────────────────────────────────────────
+  try {
+    let response: Response;
+    try {
+      response = await fetch(`${baseUrl}/healthz`, {
+        signal: AbortSignal.timeout(5000),
+      });
+    } catch {
+      response = await fetch(baseUrl, { signal: AbortSignal.timeout(5000) });
+    }
+    console.log(`✅ Service is reachable (status: ${response.status})`);
+  } catch (error: unknown) {
+    console.error(`❌ Cannot reach service: ${baseUrl}`);
+    console.error(`   Error: ${(error as Error).message}`);
+    if (needsVpn) {
+      console.error(
+        `\n💡 VPN-protected URL. Check that your VPN is connected.`,
+      );
+      console.error(
+        `   Synthetic (browser) tests do NOT require VPN — only smoke/API tests do.\n`,
+      );
+    }
+    process.exit(1);
+  }
+
+  // Handoff bookkeeping shared by the storage + cleanup fixture blocks; the
+  // handoff file is written once, after every fixture has been acquired.
+  const consumersInAcquireOrder: string[] = [];
+  const bindings: SmokeFixtureHandoffPayload["bindings"] = [];
+
+  // ── Storage smoke fixtures (acquire + env for workers) ─────────────────────
+  if (svc.fixtures?.storage?.[environment]) {
+    const workerCount = _config.workers;
+    if (!Number.isInteger(workerCount) || workerCount <= 0) {
+      throw new Error(
+        "Smoke fixture teardown requires a positive Playwright worker count",
+      );
+    }
+    const useLocalCheckout = process.env.USE_LOCAL_CHECKOUT === "1";
+    const lifecycle = resolveSmokeStorageFixture(
+      discovered.manifest,
+      serviceName,
+      environment,
+    );
+    if (lifecycle.adminProbePath) {
+      await assertStorageAdminProbe({
+        baseUrl,
+        adminProbePath: lifecycle.adminProbePath,
+        label: `${repoName} / ${serviceName}`,
+        ...(lifecycle.adminProbe403Hint
+          ? { hintOn403: () => lifecycle.adminProbe403Hint! }
+          : {}),
+      });
+    }
+    const cwd = resolveRepoPath(discovered, environment, useLocalCheckout);
+    const resolvedBaseUrl = baseUrl;
+    const fixtureEnv = {
+      ...process.env,
+      BASE_API_URL: resolvedBaseUrl,
+      SMOKE_BASE_URL: resolvedBaseUrl,
+      ...lifecycle.envVars,
+      SMOKE_WORKER_COUNT: String(workerCount),
+    };
+    const release = await acquireFixture({
+      fixtureKey: lifecycle.fixtureKey,
+      resolvedPayload: lifecycle.resolvedPayload as unknown as Record<
+        string,
+        unknown
+      >,
+      cwd,
+      env: fixtureEnv,
+      setup: lifecycle.setup,
+      teardown: lifecycle.teardown,
+    });
+    Object.assign(process.env, fixtureEnv);
+    const consumerKey = smokeFixtureConsumerKey(repoName, serviceName);
+    registerSmokeFixtureReleaseHandles(consumerKey, [release]);
+    consumersInAcquireOrder.push(consumerKey);
+    bindings.push({
+      consumerKey,
+      fixtureInstanceId: fixtureInstanceId(
+        lifecycle.fixtureKey,
+        lifecycle.resolvedPayload as unknown as Record<string, unknown>,
+      ),
+    });
+  }
+
+  // ── Pre-warm JWT tokens ─────────────────────────────────────────────────
+  // Tokens are written to process.env here. Worker processes inherit env at
+  // fork time (after globalSetup completes), so they all get cache hits.
+  // Required roles: admin + user — fatal if credentials or token fetch fails.
+  // Optional roles: beta + root_admin — warn and continue (accounts may not exist in all envs).
+  const optionalRoles = new Set(["beta", "root_admin"]);
+  const roles = (svc.auth ?? ["admin", "user"]) as (
+    | "admin"
+    | "user"
+    | "beta"
+    | "root_admin"
+  )[];
+
+  if (roles.length > 0) {
+    console.log(`\n🔑 Warming JWT token cache...`);
+    for (const role of roles) {
+      const isOptional = optionalRoles.has(role);
+      try {
+        const token = await getApiToken(role, environment);
+        process.env[`SMOKE_${role.toUpperCase()}_TOKEN`] = token;
+      } catch (err: unknown) {
+        const msg = (err as Error).message ?? String(err);
+        if (isOptional) {
+          console.warn(
+            `  ⚠  No token for ${role} — ${role} tests will be skipped`,
+          );
+        } else {
+          console.error(`\n❌ Failed to fetch ${role} JWT: ${msg}\n`);
+          process.exit(1);
+        }
+      }
+    }
+  }
+
+  // ── Cleanup smoke fixture (teardown-only sweep) ─────────────────────────────
+  // Acquired AFTER token warming on purpose: the fixture env is snapshotted at
+  // acquire time, so the teardown command inherits SMOKE_*_TOKEN — required by
+  // repos whose sweep authenticates against JWT-guarded APIs.
+  const cleanupLifecycle = resolveSmokeCleanupFixture(
+    discovered.manifest,
+    serviceName,
+    environment,
+  );
+  if (cleanupLifecycle) {
+    const workerCount = _config.workers;
+    if (!Number.isInteger(workerCount) || workerCount <= 0) {
+      throw new Error(
+        "Smoke fixture teardown requires a positive Playwright worker count",
+      );
+    }
+    const useLocalCheckout = process.env.USE_LOCAL_CHECKOUT === "1";
+    if (cleanupLifecycle.adminProbePath) {
+      await assertStorageAdminProbe({
+        baseUrl,
+        adminProbePath: cleanupLifecycle.adminProbePath,
+        label: `${repoName} / ${serviceName}`,
+        ...(cleanupLifecycle.adminProbe403Hint
+          ? { hintOn403: () => cleanupLifecycle.adminProbe403Hint! }
+          : {}),
+      });
+    }
+    const cwd = resolveRepoPath(discovered, environment, useLocalCheckout);
+    const fixtureEnv = {
+      ...process.env,
+      BASE_API_URL: baseUrl,
+      SMOKE_BASE_URL: baseUrl,
+      ...cleanupLifecycle.envVars,
+      SMOKE_WORKER_COUNT: String(workerCount),
+    };
+    const release = await acquireFixture({
+      fixtureKey: cleanupLifecycle.fixtureKey,
+      resolvedPayload: cleanupLifecycle.resolvedPayload,
+      cwd,
+      env: fixtureEnv,
+      setup: cleanupLifecycle.setup,
+      teardown: cleanupLifecycle.teardown,
+    });
+    const consumerKey = smokeFixtureConsumerKey(repoName, serviceName);
+    registerSmokeFixtureReleaseHandles(consumerKey, [release]);
+    consumersInAcquireOrder.push(consumerKey);
+    bindings.push({
+      consumerKey,
+      fixtureInstanceId: fixtureInstanceId(
+        cleanupLifecycle.fixtureKey,
+        cleanupLifecycle.resolvedPayload,
+      ),
+    });
+    console.log(
+      `🧹 Cleanup fixture armed for ${repoName}/${serviceName} (${environment})`,
+    );
+  }
+
+  if (consumersInAcquireOrder.length > 0) {
+    writeSmokeFixtureHandoff({ consumersInAcquireOrder, bindings });
+  }
+
+  console.log();
+}
+
+export default globalSetup;

package/src/pillars/smoke/global-teardown-all.ts

@@ -0,0 +1,8 @@
+import type { FullConfig } from "@playwright/test";
+import { releaseSmokeFixturesFromHandoff } from "./global-teardown.js";
+
+async function globalTeardownAll(_config: FullConfig) {
+  await releaseSmokeFixturesFromHandoff();
+}
+
+export default globalTeardownAll;

package/src/pillars/smoke/global-teardown-global.ts

@@ -0,0 +1,8 @@
+import type { FullConfig } from "@playwright/test";
+import { releaseSmokeFixturesFromHandoff } from "./global-teardown.js";
+
+async function globalTeardownGlobal(_config: FullConfig) {
+  await releaseSmokeFixturesFromHandoff();
+}
+
+export default globalTeardownGlobal;

package/src/pillars/smoke/global-teardown.ts

@@ -0,0 +1,139 @@
+import type { FullConfig } from "@playwright/test";
+import * as fs from "fs";
+import * as path from "path";
+import { releaseFixturesForConsumer } from "./cleanup.js";
+import { getDistRoot } from "../../shared/paths.js";
+
+import { product } from "../../shared/product.js";
+// Den-root anchored: writes the fixture-handoff file that
+// ensure-smoke-teardown.ts re-derives — the two must agree from any cwd.
+const PROJECT_ROOT = getDistRoot();
+const SMOKE_RUN_DIR = path.resolve(PROJECT_ROOT, ".smoke-run");
+
+/** Persisted between global setup and teardown (same Playwright parent process). */
+export const SMOKE_FIXTURE_HANDOFF_PATH = path.join(
+  SMOKE_RUN_DIR,
+  "smoke-fixture-handoff.json",
+);
+
+const smokeFixtureReleaseHandles = new Map<
+  string,
+  Array<() => Promise<void>>
+>();
+
+export function smokeFixtureConsumerKey(
+  repoName: string,
+  serviceName: string,
+): string {
+  return `${repoName}__${serviceName}`;
+}
+
+export function registerSmokeFixtureReleaseHandles(
+  consumerKey: string,
+  handles: ReadonlyArray<() => Promise<void>>,
+): void {
+  if (handles.length === 0) {
+    return;
+  }
+  const prev = smokeFixtureReleaseHandles.get(consumerKey) ?? [];
+  smokeFixtureReleaseHandles.set(consumerKey, [...prev, ...handles]);
+}
+
+export type SmokeFixtureHandoffPayload = {
+  version: 1;
+  /** Acquisition order; teardown releases in reverse (LIFO across consumers). */
+  consumersInAcquireOrder: string[];
+  bindings: Array<{
+    consumerKey: string;
+    fixtureInstanceId: string;
+  }>;
+};
+
+export function writeSmokeFixtureHandoff(
+  payload: Omit<SmokeFixtureHandoffPayload, "version">,
+): void {
+  const full: SmokeFixtureHandoffPayload = { version: 1, ...payload };
+  fs.mkdirSync(SMOKE_RUN_DIR, { recursive: true });
+  fs.writeFileSync(SMOKE_FIXTURE_HANDOFF_PATH, JSON.stringify(full, null, 2));
+}
+
+async function releaseAllRegisteredFixtures(): Promise<void> {
+  const handlesInReverseRegistrationOrder = Array.from(
+    smokeFixtureReleaseHandles.values(),
+  ).reverse();
+  for (const handles of handlesInReverseRegistrationOrder) {
+    await releaseFixturesForConsumer(handles);
+  }
+}
+
+/**
+ * Releases fixtures registered for this run, using the persisted consumer order
+ * (release-driven: refcount / shared instances, not per-repo shell hooks).
+ */
+export async function releaseSmokeFixturesFromHandoff(): Promise<void> {
+  try {
+    if (!fs.existsSync(SMOKE_FIXTURE_HANDOFF_PATH)) {
+      await releaseAllRegisteredFixtures();
+      console.log(
+        `[${product().cli}] smoke global teardown: storage fixture releases completed`,
+      );
+      return;
+    }
+
+    let payload: SmokeFixtureHandoffPayload;
+    try {
+      payload = JSON.parse(
+        fs.readFileSync(SMOKE_FIXTURE_HANDOFF_PATH, "utf-8"),
+      ) as SmokeFixtureHandoffPayload;
+    } catch {
+      await releaseAllRegisteredFixtures();
+      console.log(
+        `[${product().cli}] smoke global teardown: storage fixture releases completed (handoff parse fallback)`,
+      );
+      return;
+    }
+
+    const bindingConsumerKeys = new Set(
+      (payload.bindings ?? []).map((binding) => binding.consumerKey),
+    );
+    const order = (payload.consumersInAcquireOrder ?? []).filter((key) =>
+      bindingConsumerKeys.has(key),
+    );
+    for (let i = order.length - 1; i >= 0; i -= 1) {
+      const key = order[i];
+      const handles = smokeFixtureReleaseHandles.get(key);
+      if (handles?.length) {
+        await releaseFixturesForConsumer(handles);
+      }
+    }
+    // Safety net: any consumer registered in-memory but missing from handoff
+    // order still must release (release fns are idempotent if already run).
+    await releaseAllRegisteredFixtures();
+    console.log(
+      `[${product().cli}] smoke global teardown: storage fixture releases completed`,
+    );
+  } finally {
+    smokeFixtureReleaseHandles.clear();
+
+    try {
+      fs.unlinkSync(SMOKE_FIXTURE_HANDOFF_PATH);
+    } catch {
+      // ignore
+    }
+  }
+}
+
+export function resetSmokeFixtureBridgeForTests(): void {
+  smokeFixtureReleaseHandles.clear();
+  try {
+    fs.unlinkSync(SMOKE_FIXTURE_HANDOFF_PATH);
+  } catch {
+    // ignore
+  }
+}
+
+async function globalTeardown(_config: FullConfig) {
+  await releaseSmokeFixturesFromHandoff();
+}
+
+export default globalTeardown;

package/src/pillars/smoke/playwright-all.config.ts

@@ -0,0 +1,147 @@
+/**
+ * Playwright Configuration — All Smoke Services
+ *
+ * Used by: make test-smk-all
+ *
+ * Creates one Playwright project per service in the linked repo's manifest.
+ * Each project gets its own testDir (.smoke-run/<repo>-<service>/) and
+ * baseURL, so api and web tests can coexist in a single run and produce
+ * a single combined report.
+ *
+ * Environment variables:
+ *   SMOKE_REPO        — repo name in .den/ (required)
+ *   E2E_ENVIRONMENT   — env config to load (default: local)
+ *   BASE_API_URL      — override API base URL
+ */
+
+import { defineConfig } from "@playwright/test";
+import * as fs from "fs";
+import * as path from "path";
+import { findManifest } from "./discover.js";
+import {
+  resolveManifestSmokeBaseUrl,
+  resolveSmokeBaseUrl,
+} from "./base-url.js";
+import type { Environment } from "../../shared/types/index.js";
+import { getDistRoot } from "../../shared/paths.js";
+import { distPath, enginePath } from "../../shared/engine.js";
+import { smokeRepoName } from "./smoke-repo.js";
+
+import { product } from "../../shared/product.js";
+// Den-root anchored in lockstep with setup.ts (the .smoke-run writer).
+const PROJECT_ROOT = getDistRoot();
+
+const repoName = smokeRepoName();
+const environment = (process.env.E2E_ENVIRONMENT || "local") as Environment;
+
+const discovered = findManifest(repoName);
+if (!discovered) {
+  console.error(
+    `\n❌ playwright-all.config: no manifest found for repo "${repoName}" in .${product().name}/`,
+  );
+  console.error(`   Run: make smoke-link repo=${repoName}\n`);
+  process.exit(1);
+}
+
+const configPath = path.resolve(
+  PROJECT_ROOT,
+  `config/environments/${environment}.json`,
+);
+let envConfig: { baseUrls: { api: string; web: string } };
+try {
+  envConfig = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+} catch {
+  console.error(
+    `\n❌ playwright-all.config: no env config found for "${environment}"`,
+  );
+  console.error(`   Expected: config/environments/${environment}.json\n`);
+  process.exit(1);
+}
+
+const smokeServicesFilter = process.env.SMOKE_SERVICES
+  ? new Set(process.env.SMOKE_SERVICES.split(",").map((s) => s.trim()))
+  : null;
+
+const projects = Object.entries(discovered.manifest.smoke ?? {})
+  .filter(
+    ([svcName]) => !smokeServicesFilter || smokeServicesFilter.has(svcName),
+  )
+  .map(([svcName, svc]) => {
+    const stagingDir = path.resolve(
+      PROJECT_ROOT,
+      `.smoke-run/${repoName}-${svcName}`,
+    );
+    if (!fs.existsSync(stagingDir)) {
+      console.error(
+        `\n❌ Staging dir not found: .smoke-run/${repoName}-${svcName}/`,
+      );
+      console.error(
+        `   Run setup first: SMOKE_SERVICE=${svcName} SMOKE_REPO=${repoName} npx tsx src/pillars/smoke/setup.ts\n`,
+      );
+      process.exit(1);
+    }
+
+    const configuredUrl =
+      svc.baseUrlKey === "api"
+        ? envConfig.baseUrls.api
+        : envConfig.baseUrls.web;
+    const manifestUrl = resolveManifestSmokeBaseUrl({
+      manifest: discovered.manifest,
+      repoName,
+      serviceName: svcName,
+      environment,
+      baseUrlKey: svc.baseUrlKey,
+    });
+    const baseUrl = resolveSmokeBaseUrl({
+      baseUrlKey: svc.baseUrlKey,
+      configuredUrl,
+      manifestUrl,
+      overrideUrl: process.env.BASE_API_URL,
+    });
+
+    return {
+      name: svcName,
+      testDir: stagingDir,
+      testMatch: svc.testMatch,
+      use: {
+        baseURL: baseUrl,
+        timeout: 30000,
+        ...(svc.baseUrlKey === "api"
+          ? {
+              extraHTTPHeaders: {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+              },
+            }
+          : {}),
+      },
+    };
+  });
+
+export default defineConfig({
+  globalSetup: enginePath("src/pillars/smoke/global-setup-all.ts"),
+  globalTeardown: enginePath("src/pillars/smoke/global-teardown-all.ts"),
+
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+
+  reporter: [
+    [
+      "html",
+      {
+        outputFolder:
+          process.env.PLAYWRIGHT_HTML_REPORT || distPath("playwright-report"),
+        open: "never",
+      },
+    ],
+    ["list"],
+    ["junit", { outputFile: distPath("reports", "junit-smoke-results.xml") }],
+  ],
+
+  projects,
+
+  timeout: 60000,
+  expect: { timeout: 10000 },
+});