@open-mercato/cli 0.4.9-develop-7afbe1e834 → 0.4.9-develop-94fb251ed3

package/dist/lib/testing/integration.js

@@ -12,12 +12,13 @@ import { resolveDockerHostFromContext, runCommandAndCapture } from "./runtime-ut
 function shouldUseIsolatedPortForFreshEnvironment(options) {
   return options.reuseExisting === false || options.existingStateBeforeReuseAttempt !== null;
 }
-const APP_READY_TIMEOUT_MS = 9e4;
+const DEFAULT_APP_READY_TIMEOUT_MS = 9e4;
 const APP_READY_INTERVAL_MS = 1e3;
 const DEFAULT_EPHEMERAL_APP_PORT = 5001;
 const EPHEMERAL_ENV_LOCK_TIMEOUT_MS = 6e4;
 const EPHEMERAL_ENV_LOCK_POLL_MS = 500;
 const DEFAULT_BUILD_CACHE_TTL_SECONDS = 600;
+const APP_READY_TIMEOUT_ENV_VAR = "OM_INTEGRATION_APP_READY_TIMEOUT_SECONDS";
 const BUILD_CACHE_TTL_ENV_VAR = "OM_INTEGRATION_BUILD_CACHE_TTL_SECONDS";
 const PLAYWRIGHT_ENV_UNAVAILABLE_PATTERNS = [
   /net::ERR_CONNECTION_REFUSED/i,
@@ -32,7 +33,6 @@ const PLAYWRIGHT_QUICK_FAILURE_THRESHOLD = 6;
 const PLAYWRIGHT_QUICK_FAILURE_MAX_DURATION_MS = 1500;
 const PLAYWRIGHT_HEALTH_PROBE_INTERVAL_MS = 3e3;
 const ANSI_ESCAPE_REGEX = /\x1b\[[0-?]*[ -/]*[@-~]/g;
-const NEXT_STATIC_ASSET_PATTERN = /\/_next\/static\/[^"'`\s)]+?\.(?:js|css)/g;
 const resolver = createResolver();
 const projectRootDirectory = resolver.getRootDir();
 const EPHEMERAL_ENV_FILE_PATH = path.join(projectRootDirectory, ".ai", "qa", "ephemeral-env.json");
@@ -410,6 +410,20 @@ function resolveBuildCacheTtlSeconds(logPrefix) {
   }
   return parsed;
 }
+function resolveAppReadyTimeoutMs(logPrefix) {
+  const rawValue = process.env[APP_READY_TIMEOUT_ENV_VAR];
+  if (!rawValue) {
+    return DEFAULT_APP_READY_TIMEOUT_MS;
+  }
+  const parsedSeconds = Number.parseInt(rawValue, 10);
+  if (!Number.isFinite(parsedSeconds) || parsedSeconds < 1) {
+    console.warn(
+      `[${logPrefix}] Invalid ${APP_READY_TIMEOUT_ENV_VAR} value "${rawValue}". Using default ${DEFAULT_APP_READY_TIMEOUT_MS / 1e3}s.`
+    );
+    return DEFAULT_APP_READY_TIMEOUT_MS;
+  }
+  return parsedSeconds * 1e3;
+}
 function buildCacheDefaults(overrides = {}) {
   return {
     artifactPaths: overrides.artifactPaths ?? APP_BUILD_ARTIFACTS,
@@ -755,53 +769,55 @@ async function readEphemeralEnvironmentState() {
     startedAt: record.startedAt
   };
 }
-async function isApplicationReachable(baseUrl) {
+function isLoginHtmlHealthy(html) {
+  return !/Application error: a client-side exception has occurred/i.test(html);
+}
+function isSuccessfulBrowserNavigationStatus(status) {
+  return status === 200 || status >= 300 && status < 400;
+}
+async function probeLoginPage(baseUrl) {
   try {
     const response = await fetch(`${baseUrl}/login`, {
       method: "GET",
       redirect: "manual"
     });
-    if (response.status === 302) {
-      return true;
+    if (!isSuccessfulBrowserNavigationStatus(response.status)) {
+      return {
+        status: response.status,
+        healthy: false,
+        detail: `GET /login returned ${response.status}`
+      };
     }
     if (response.status !== 200) {
-      return false;
+      return {
+        status: response.status,
+        healthy: true,
+        detail: `GET /login returned redirect ${response.status}`
+      };
     }
-    const html = await response.text();
-    return isLoginHtmlHealthy(html) && await areReferencedNextAssetsReachable(baseUrl, html);
-  } catch {
-    return false;
-  }
-}
-function isLoginHtmlHealthy(html) {
-  return !/Application error: a client-side exception has occurred/i.test(html);
-}
-function extractReferencedNextAssets(html, maxAssets = 8) {
-  const matches = html.match(NEXT_STATIC_ASSET_PATTERN) ?? [];
-  const unique = Array.from(new Set(matches));
-  return unique.slice(0, maxAssets);
-}
-async function areReferencedNextAssetsReachable(baseUrl, html) {
-  const assets = extractReferencedNextAssets(html);
-  if (assets.length === 0) {
-    return false;
-  }
-  for (const assetPath of assets) {
-    try {
-      const response = await fetch(`${baseUrl}${assetPath}`, {
-        method: "GET",
-        redirect: "manual"
-      });
-      if (response.status !== 200 && response.status !== 304) {
-        return false;
-      }
-    } catch {
-      return false;
+    const html = await response.text().catch(() => "");
+    if (!isLoginHtmlHealthy(html)) {
+      return {
+        status: response.status,
+        healthy: false,
+        detail: "GET /login returned client-side exception HTML"
+      };
     }
+    return {
+      status: response.status,
+      healthy: true,
+      detail: "GET /login returned healthy HTML"
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      status: null,
+      healthy: false,
+      detail: `GET /login failed: ${message}`
+    };
   }
-  return true;
 }
-async function isBackendLoginEndpointHealthy(baseUrl) {
+async function probeBackendLoginEndpoint(baseUrl) {
   try {
     const form = new URLSearchParams();
     form.set("email", "integration-healthcheck@example.invalid");
@@ -814,11 +830,32 @@ async function isBackendLoginEndpointHealthy(baseUrl) {
       },
       body: form.toString()
     });
-    return response.status === 200 || response.status === 400 || response.status === 401 || response.status === 403;
-  } catch {
-    return false;
+    const healthy = response.status === 200 || response.status === 400 || response.status === 401 || response.status === 403;
+    return {
+      status: response.status,
+      healthy,
+      detail: healthy ? `POST /api/auth/login returned ${response.status}` : `POST /api/auth/login returned unexpected ${response.status}`
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      status: null,
+      healthy: false,
+      detail: `POST /api/auth/login failed: ${message}`
+    };
   }
 }
+async function probeApplicationReadiness(baseUrl) {
+  const [frontend, backend] = await Promise.all([
+    probeLoginPage(baseUrl),
+    probeBackendLoginEndpoint(baseUrl)
+  ]);
+  return {
+    ready: frontend.healthy && backend.healthy,
+    frontend,
+    backend
+  };
+}
 async function acquireEphemeralEnvironmentLock(logPrefix) {
   await mkdir(path.dirname(EPHEMERAL_ENV_LOCK_PATH), { recursive: true });
   const deadlineTimestamp = Date.now() + EPHEMERAL_ENV_LOCK_TIMEOUT_MS;
@@ -914,8 +951,11 @@ function buildReusableEnvironment(baseUrl, captureScreenshots) {
   return buildEnvironment({
     BASE_URL: baseUrl,
     NODE_ENV: "production",
+    JWT_SECRET: process.env.JWT_SECRET ?? "om-ephemeral-integration-jwt-secret",
+    OM_SECURITY_MFA_SETUP_SECRET: process.env.OM_SECURITY_MFA_SETUP_SECRET ?? "om-ephemeral-integration-mfa-setup-secret",
     OM_ENABLE_ENTERPRISE_MODULES: process.env.OM_ENABLE_ENTERPRISE_MODULES ?? "false",
     OM_ENABLE_ENTERPRISE_MODULES_SSO: process.env.OM_ENABLE_ENTERPRISE_MODULES_SSO ?? "false",
+    OM_ENABLE_ENTERPRISE_MODULES_SECURITY: process.env.OM_ENABLE_ENTERPRISE_MODULES_SECURITY ?? "false",
     OM_TEST_MODE: "1",
     ENABLE_CRUD_API_CACHE: "true",
     NEXT_PUBLIC_OM_EXAMPLE_INJECTION_WIDGETS_ENABLED: "true",
@@ -980,42 +1020,21 @@ async function tryReuseExistingEnvironment(options) {
     }
   };
 }
-async function waitForApplicationReadiness(baseUrl, appProcess) {
+async function waitForApplicationReadiness(baseUrl, appProcess, options) {
   const startTimestamp = Date.now();
   const exitPromise = getProcessExitPromise(appProcess);
   const readinessStabilizationMs = 600;
-  while (Date.now() - startTimestamp < APP_READY_TIMEOUT_MS) {
-    const responsePromise = fetch(`${baseUrl}/login`, {
-      method: "GET",
-      redirect: "manual"
-    }).then(async (response) => ({
-      response,
-      body: response.status === 200 ? await response.text().catch(() => "") : ""
-    })).catch(() => null);
+  let lastProbe = null;
+  while (Date.now() - startTimestamp < options.timeoutMs) {
     const result = await Promise.race([
-      responsePromise.then((payload) => {
-        if (!payload) {
-          return { kind: "network_error" };
-        }
-        return {
-          kind: "response",
-          status: payload.response.status,
-          body: payload.body
-        };
-      }),
+      probeApplicationReadiness(baseUrl).then((probe) => ({ kind: "probe", probe })),
       exitPromise.then((code) => ({ kind: "exit", code })),
       delay(APP_READY_INTERVAL_MS).then(() => ({ kind: "timeout" }))
     ]);
-    if (result.kind === "response" && (result.status === 200 || result.status === 302)) {
-      if (result.status === 200) {
-        const loginHtml = result.body ?? "";
-        if (!isLoginHtmlHealthy(loginHtml)) {
-          continue;
-        }
-        const assetsReachable = await areReferencedNextAssetsReachable(baseUrl, loginHtml);
-        if (!assetsReachable) {
-          continue;
-        }
+    if (result.kind === "probe") {
+      lastProbe = result.probe;
+      if (!result.probe.ready) {
+        continue;
       }
       const processExited = await Promise.race([
         exitPromise.then(() => true),
@@ -1030,7 +1049,11 @@ async function waitForApplicationReadiness(baseUrl, appProcess) {
       throw new Error(`Application process exited before readiness check (exit ${result.code ?? "unknown"})`);
     }
   }
-  throw new Error(`Application did not become ready within ${APP_READY_TIMEOUT_MS / 1e3} seconds`);
+  const lastFrontendDetail = lastProbe?.frontend.detail ?? "GET /login was never observed";
+  const lastBackendDetail = lastProbe?.backend.detail ?? "POST /api/auth/login was never observed";
+  throw new Error(
+    `Application did not become ready within ${options.timeoutMs / 1e3} seconds. Last probe: ${lastFrontendDetail}; ${lastBackendDetail}`
+  );
 }
 function parseOptions(rawArgs) {
   let keep = false;
@@ -1847,11 +1870,8 @@ async function runIntegrationTestSuiteOnce(environment, options) {
   });
 }
 async function isEnvironmentUnavailable(baseUrl) {
-  const [applicationReachable, backendHealthy] = await Promise.all([
-    isApplicationReachable(baseUrl),
-    isBackendLoginEndpointHealthy(baseUrl)
-  ]);
-  return !applicationReachable || !backendHealthy;
+  const readiness = await probeApplicationReadiness(baseUrl);
+  return !readiness.ready;
 }
 function isEnvironmentUnavailableError(error) {
   if (!(error instanceof Error)) {
@@ -1991,7 +2011,8 @@ async function startEphemeralEnvironment(options) {
     const commandEnvironment = buildEnvironment({
       DATABASE_URL: databaseUrl,
       BASE_URL: applicationBaseUrl,
-      JWT_SECRET: "om-ephemeral-integration-jwt-secret",
+      JWT_SECRET: process.env.JWT_SECRET ?? "om-ephemeral-integration-jwt-secret",
+      OM_SECURITY_MFA_SETUP_SECRET: process.env.OM_SECURITY_MFA_SETUP_SECRET ?? "om-ephemeral-integration-mfa-setup-secret",
       NODE_ENV: "production",
       DB_POOL_MIN: "0",
       DB_POOL_MAX: "5",
@@ -2001,6 +2022,7 @@ async function startEphemeralEnvironment(options) {
       DB_IDLE_IN_TRANSACTION_TIMEOUT_MS: "30000",
       OM_ENABLE_ENTERPRISE_MODULES: process.env.OM_ENABLE_ENTERPRISE_MODULES ?? "false",
       OM_ENABLE_ENTERPRISE_MODULES_SSO: process.env.OM_ENABLE_ENTERPRISE_MODULES_SSO ?? "false",
+      OM_ENABLE_ENTERPRISE_MODULES_SECURITY: process.env.OM_ENABLE_ENTERPRISE_MODULES_SECURITY ?? "false",
       OM_TEST_MODE: "1",
       OM_TEST_AUTH_RATE_LIMIT_MODE: "opt-in",
       OM_DISABLE_EMAIL_DELIVERY: "1",
@@ -2030,6 +2052,7 @@ async function startEphemeralEnvironment(options) {
       await clearEphemeralEnvironmentState();
     };
     try {
+      const appReadyTimeoutMs = resolveAppReadyTimeoutMs(options.logPrefix);
       const buildCacheTtlSeconds = resolveBuildCacheTtlSeconds(options.logPrefix);
       let sourceFingerprintValue = null;
       let needsBuild = true;
@@ -2091,7 +2114,14 @@ async function startEphemeralEnvironment(options) {
         silent: !options.verbose
       });
       applicationProcess = startedAppProcess;
-      await runTimedStep(options.logPrefix, "Waiting for application readiness", { expectedSeconds: 12 }, async () => waitForApplicationReadiness(applicationBaseUrl, startedAppProcess));
+      await runTimedStep(
+        options.logPrefix,
+        "Waiting for application readiness",
+        { expectedSeconds: Math.max(12, Math.ceil(appReadyTimeoutMs / 1e3)) },
+        async () => waitForApplicationReadiness(applicationBaseUrl, startedAppProcess, {
+          timeoutMs: appReadyTimeoutMs
+        })
+      );
       console.log(`[${options.logPrefix}] Application is ready at ${applicationBaseUrl}`);
       await writeEphemeralEnvironmentState({
         baseUrl: applicationBaseUrl,
@@ -2352,6 +2382,7 @@ export {
   parseInteractiveIntegrationOptions,
   parseOptions,
   readEphemeralEnvironmentState,
+  resolveAppReadyTimeoutMs,
   resolveBuildCacheTtlSeconds,
   runEphemeralAppForQa,
   runIntegrationCoverageReport,