@meshxdata/fops 0.1.36 → 0.1.38

package/src/plugins/bundled/fops-plugin-azure/lib/commands/test-cmds.js

@@ -0,0 +1,314 @@
+/**
+ * QA test and CVE scan commands.
+ */
+import chalk from "chalk";
+import { resolveRemoteAuth, suppressTlsWarning } from "../azure-auth.js";
+import { parsePytestSummary, parsePytestDurations } from "../pytest-parse.js";
+
+export function registerTestCommands(azure) {
+  const test = azure
+    .command("test")
+    .description("Run and manage QA test results");
+
+  test
+    .command("run [name]", { isDefault: true })
+    .description("Run QA automation tests locally against a remote VM")
+    .option("--vm-name <name>", "Target VM (default: active)")
+    .action(async (name, opts) => {
+      const { requireVmState, knockForVm } = await import("../azure.js");
+      const { resolveCliSrc } = await import("../azure-helpers.js");
+      const { rootDir } = await import(resolveCliSrc("project.js"));
+      const fsp = await import("node:fs/promises");
+      const path = await import("node:path");
+
+      const state = requireVmState(opts.vmName || name);
+      const ip = state.publicIp;
+      if (!ip) {
+        console.error(chalk.red("\n  No IP address. Is the VM running? Try: fops azure start\n"));
+        process.exit(1);
+      }
+
+      const root = rootDir();
+      if (!root) {
+        console.error(chalk.red("\n  Foundation project root not found. Run from the compose repo or set FOUNDATION_ROOT.\n"));
+        process.exit(1);
+      }
+
+      const qaDir = path.join(root, "foundation-qa-automation");
+      try {
+        await fsp.access(qaDir);
+      } catch {
+        console.error(chalk.red("\n  foundation-qa-automation/ not found in project root."));
+        console.error(chalk.dim("  Run: git submodule update --init\n"));
+        process.exit(1);
+      }
+
+      const vmUrl = state.publicUrl || `https://${ip}`;
+      const apiUrl = `${vmUrl}/api`;
+      const { execa: execaFn } = await import("execa");
+      const { sshCmd, MUX_OPTS } = await import("../azure.js");
+
+      console.log(chalk.dim(`  Authenticating against ${vmUrl}…`));
+      const auth = await resolveRemoteAuth({
+        apiUrl, ip, vmState: state,
+        execaFn, sshCmd, knockForVm, suppressTlsWarning,
+      });
+      let { bearerToken, qaUser, qaPass, useTokenMode } = auth;
+
+      if (!bearerToken && !qaUser) {
+        console.error(chalk.red("\n  No credentials found (local or remote)."));
+        console.error(chalk.dim("  Set BEARER_TOKEN or QA_USERNAME/QA_PASSWORD, or ensure the VM has Auth0 configured in .env\n"));
+        process.exit(1);
+      }
+
+      // Write .env pointed at the remote VM
+      const envPath = path.join(qaDir, ".env");
+      const examplePath = path.join(qaDir, ".env.example");
+      let envContent;
+      try {
+        envContent = await fsp.readFile(examplePath, "utf8");
+      } catch {
+        envContent = await fsp.readFile(envPath, "utf8").catch(() => "");
+      }
+
+      const setVar = (content, key, value) => {
+        const re = new RegExp(`^${key}=.*`, "m");
+        return re.test(content)
+          ? content.replace(re, `${key}=${value}`)
+          : content + `\n${key}=${value}`;
+      };
+
+      envContent = setVar(envContent, "API_URL", apiUrl);
+      envContent = setVar(envContent, "DEV_API_URL", apiUrl);
+      envContent = setVar(envContent, "LIVE_API_URL", apiUrl);
+      envContent = setVar(envContent, "QA_USERNAME", qaUser);
+      envContent = setVar(envContent, "QA_PASSWORD", qaPass);
+      envContent = setVar(envContent, "QA_X_ACCOUNT", "root");
+      envContent = setVar(envContent, "ADMIN_USERNAME", qaUser);
+      envContent = setVar(envContent, "ADMIN_PASSWORD", qaPass);
+      envContent = setVar(envContent, "ADMIN_X_ACCOUNT", "root");
+      envContent = setVar(envContent, "OWNER_EMAIL", qaUser);
+      envContent = setVar(envContent, "OWNER_NAME", "Foundation Operator");
+      if (bearerToken) {
+        envContent = setVar(envContent, "BEARER_TOKEN", bearerToken);
+        envContent = setVar(envContent, "TOKEN_AUTH0", bearerToken);
+      }
+
+      await fsp.writeFile(envPath, envContent);
+      console.log(chalk.green(`  ✓ Configured QA .env → ${apiUrl}`));
+
+      // Ensure venv + deps
+      try {
+        await fsp.access(path.join(qaDir, "venv"));
+      } catch {
+        console.log(chalk.cyan("  Setting up QA automation environment…"));
+        await execaFn("python3", ["-m", "venv", "venv"], { cwd: qaDir, stdio: "inherit" });
+        await execaFn("bash", ["-c", "source venv/bin/activate && pip install -r requirements.txt && playwright install"], { cwd: qaDir, stdio: "inherit" });
+      }
+
+      // Knock to ensure VM is reachable
+      await knockForVm(state);
+
+      const authMode = useTokenMode ? "bearer token (--use-token)" : `user/pass (${qaUser})`;
+      console.log(chalk.cyan(`\n  Running QA tests against ${state.vmName} (${vmUrl}) [${authMode}]…\n`));
+      const pytestArgsList = [
+        "tests/",
+        "--env", "staging",
+        "--role", "FOUNDATION_ADMIN",
+        "--numprocesses=0",
+        "-v",
+        "--durations=0",
+        "--html=./playwright-report/report.html",
+        "--self-contained-html",
+        "--ignore=tests/e2e/landscape",
+        "--ignore=tests/e2e/procedures",
+        "--ignore=tests/e2e/upload_file_s3",
+        "--ignore=tests/roles",
+        "--ignore=tests/unit/data_product/test_data_product_consumers_v2.py",
+        "--ignore=tests/unit/data_product/test_data_product_query.py",
+        "--ignore=tests/unit/data_product/test_data_product_quality_v2.py",
+        "--ignore=tests/unit/data_product/test_data_product_schema_v2.py",
+      ];
+      if (useTokenMode) pytestArgsList.push("--use-token");
+      const pytestArgs = pytestArgsList.join(" ");
+
+      const testEnv = {
+        ...process.env,
+        API_URL: apiUrl,
+        DEV_API_URL: apiUrl,
+        LIVE_API_URL: apiUrl,
+        ROLE_NAME: "FOUNDATION_ADMIN",
+        QA_USERNAME: qaUser,
+        QA_PASSWORD: qaPass,
+        CDO_USERNAME: qaUser,
+        CDO_PASSWORD: qaPass,
+        ADMIN_USERNAME: qaUser,
+        ADMIN_PASSWORD: qaPass,
+        QA_X_ACCOUNT: "root",
+        ADMIN_X_ACCOUNT: "root",
+        CDO_X_ACCOUNT: "root",
+        OWNER_EMAIL: qaUser,
+        OWNER_NAME: "Foundation Operator",
+      };
+      if (bearerToken) {
+        testEnv.BEARER_TOKEN = bearerToken;
+        testEnv.TOKEN_AUTH0 = bearerToken;
+      }
+
+      const startMs = Date.now();
+      const proc = execaFn(
+        "bash",
+        ["-c", `source venv/bin/activate && pytest ${pytestArgs}`],
+        { cwd: qaDir, timeout: 600_000, reject: false, env: testEnv },
+      );
+      let captured = "";
+      proc.stdout?.on("data", (d) => { const s = d.toString(); captured += s; process.stdout.write(s); });
+      proc.stderr?.on("data", (d) => { const s = d.toString(); captured += s; process.stderr.write(s); });
+      const { exitCode } = await proc;
+      const wallSec = Math.round((Date.now() - startMs) / 1000);
+
+      const counts = parsePytestSummary(captured);
+      const timing = parsePytestDurations(captured);
+      const { writeVmState } = await import("../azure-state.js");
+      const qaResult = {
+        passed: exitCode === 0,
+        exitCode,
+        at: new Date().toISOString(),
+        ...(counts.passed != null && { numPassed: counts.passed }),
+        ...(counts.failed != null && { numFailed: counts.failed }),
+        ...(counts.error != null && { numErrors: counts.error }),
+        ...(counts.errors != null && { numErrors: counts.errors }),
+        ...(counts.skipped != null && { numSkipped: counts.skipped }),
+        durationSec: counts.durationSec || wallSec,
+        ...(timing && { timing }),
+      };
+      writeVmState(state.vmName, { qa: qaResult });
+
+      if (exitCode === 0) {
+        console.log(chalk.green("\n  ✓ QA tests passed\n"));
+      } else {
+        console.error(chalk.red(`\n  QA tests failed (exit ${exitCode}).`));
+        console.error(chalk.dim(`  Report: ${path.join(qaDir, "playwright-report", "report.html")}\n`));
+        process.exitCode = 1;
+      }
+
+      try {
+        const { resultsPush } = await import("../azure-results.js");
+        const enriched = { ...qaResult };
+        try {
+          const gitExeca = (await import("execa")).execa;
+          const { stdout: branch } = await gitExeca("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: qaDir, reject: false, timeout: 5000 });
+          const { stdout: sha } = await gitExeca("git", ["rev-parse", "--short", "HEAD"], { cwd: qaDir, reject: false, timeout: 5000 });
+          if (branch?.trim()) enriched.branch = branch.trim();
+          if (sha?.trim()) enriched.sha = sha.trim();
+        } catch {}
+        await resultsPush(state.vmName, enriched, { quiet: false });
+      } catch (pushErr) {
+        console.log(chalk.dim(`  (Result push skipped: ${pushErr.message})`));
+      }
+    });
+
+  test
+    .command("setup")
+    .description("Configure the Azure Blob Storage account for test results")
+    .option("--account <name>", "Storage account name")
+    .action(async (opts) => {
+      const { resultsSetup } = await import("../azure-results.js");
+      await resultsSetup({ account: opts.account });
+    });
+
+  test
+    .command("list [target]")
+    .description("List stored test results across VMs (optionally filter by name)")
+    .option("--last <n>", "Number of results to show", "20")
+    .action(async (target, opts) => {
+      const { resultsList } = await import("../azure-results.js");
+      await resultsList({ target, last: parseInt(opts.last) });
+    });
+
+  test
+    .command("show <target>")
+    .description("Show details of the latest test result for a VM/cluster")
+    .option("--run <id>", "Show a specific run by timestamp")
+    .action(async (target, opts) => {
+      const { resultsShow } = await import("../azure-results.js");
+      await resultsShow({ target, run: opts.run });
+    });
+
+  test
+    .command("compare [target]")
+    .description("Compare test runs across time — detect regressions and improvements")
+    .option("--last <n>", "Number of runs to compare", "10")
+    .action(async (target, opts) => {
+      const { resultsCompare } = await import("../azure-results.js");
+      await resultsCompare({ target, last: parseInt(opts.last) });
+    });
+
+  test
+    .command("push [target]")
+    .description("Push local QA results to blob storage (default: all VMs with results)")
+    .action(async (target) => {
+      const { readVmState, listVms } = await import("../azure-state.js");
+      const { resultsPush } = await import("../azure-results.js");
+
+      const targets = [];
+      if (target) {
+        targets.push(target);
+      } else {
+        const { activeVm, vms } = listVms();
+        const names = Object.keys(vms);
+        if (names.length === 0) {
+          console.log(chalk.dim("\n  No VMs tracked.\n"));
+          return;
+        }
+        for (const name of names) {
+          const st = readVmState(name);
+          if (st?.qa) targets.push(name);
+        }
+        if (targets.length === 0) {
+          console.log(chalk.dim("\n  No local QA results found. Run tests first: fops azure test <vm>\n"));
+          return;
+        }
+      }
+
+      let pushed = 0;
+      for (const t of targets) {
+        const state = readVmState(t);
+        if (!state?.qa) {
+          console.log(chalk.dim(`  ${t}: no local QA result — skipped`));
+          continue;
+        }
+        await resultsPush(t, state.qa);
+        pushed++;
+      }
+      if (pushed === 0) {
+        console.log(chalk.dim("\n  No results to push.\n"));
+      }
+    });
+
+  // ── Scan ───────────────────────────────────────────────────────────────
+
+  azure
+    .command("scan [name]")
+    .description("Scan stack container images for CVEs using Trivy (same as fops scan)")
+    .option("--severity <levels>", "Comma-separated severity filter (default: CRITICAL,HIGH)", "CRITICAL,HIGH")
+    .option("--json", "Output raw JSON instead of table")
+    .option("--fix", "Show only vulnerabilities with a fix available")
+    .option("--service <name>", "Scan a specific compose service's image")
+    .action(async (name, opts) => {
+      const { resolveCliSrc } = await import("../azure-helpers.js");
+      const { rootDir } = await import(resolveCliSrc("project.js"));
+      const root = rootDir();
+      if (!root) {
+        console.error(chalk.red("\n  Foundation project root not found. Run from the compose repo or set FOUNDATION_ROOT.\n"));
+        process.exit(1);
+      }
+      const { runScan } = await import(resolveCliSrc("commands/lifecycle.js"));
+      await runScan(root, {
+        severity: opts.severity,
+        json: opts.json,
+        fix: opts.fix,
+        service: opts.service,
+      });
+    });
+}