@elench/testkit 0.1.108 → 0.1.109

package/lib/runner/maintenance.mjs

@@ -1,15 +1,14 @@
 import fs from "fs";
+import path from "path";
 import {
   cleanupOrphanedLocalInfrastructure,
-  collectServiceDatabaseStatus,
   destroyRuntimeDatabase,
   destroyServiceDatabaseCache,
   isDatabaseStateDir,
 } from "../database/index.mjs";
-import { cleanupRuns, formatRunSummary } from "./lifecycle.mjs";
-import { buildRunStatusLines } from "./readiness.mjs";
+import { cleanupRuns, formatRunSummary, isPidRunning, listRunManifests } from "./lifecycle.mjs";
 import { findGraphDirsForService, findRuntimeStateDirs } from "./state.mjs";
-import { collectStateDirLines } from "./state-io.mjs";
+import { collectCleanupTargets, collectStatusModel } from "./status-model.mjs";
 
 export async function destroy(config) {
   await cleanupRuns(config.productDir, { includeActive: true });
@@ -34,50 +33,152 @@ export async function destroy(config) {
   await cleanupOrphanedLocalInfrastructure(config.productDir);
 }
 
-export function showStatus(config) {
-  const lines = [...buildRunStatusLines(config.productDir)];
-  const graphDirs = findGraphDirsForService(config.productDir, config.name);
-  const hasDirectState = fs.existsSync(config.stateDir);
-  const hasGraphState = graphDirs.length > 0;
-
-  if (!hasDirectState && !hasGraphState) {
-    lines.push("No state — run tests first.");
-  } else {
-    if (hasDirectState) {
-      lines.push("  service-state/");
-      lines.push(...collectStateDirLines(config.stateDir, "    "));
+export function showStatus(config, options = {}) {
+  return collectStatusModel(config, options);
+}
+
+export async function cleanup(productDir, options = {}) {
+  const dryRun = Boolean(options.dryRun);
+  const allConfigs = options.allConfigs || [];
+  const serviceName = options.serviceName || null;
+  const cache = normalizeCacheSelection(options.cache);
+  const summary = dryRun
+    ? collectRunCleanupPreview(productDir)
+    : await cleanupRuns(productDir, { includeActive: false });
+  const targets = collectCleanupTargets(productDir, {
+    allConfigs,
+    serviceName,
+    cache,
+  });
+
+  const runtimeCleaned = [];
+  const bundleCleaned = [];
+  const assistantCleaned = [];
+
+  if (!dryRun) {
+    for (const target of targets.runtime) {
+      await cleanupRuntimeDir(productDir, target.path);
+      runtimeCleaned.push(target);
+    }
+    for (const target of targets.bundles) {
+      fs.rmSync(target.path, { force: true });
+      bundleCleaned.push(target);
     }
-    for (const graphDir of graphDirs) {
-      lines.push(`  graph-state/${graphDir.split("/").at(-1)}/`);
-      lines.push(...collectStateDirLines(graphDir, "    "));
+    for (const target of targets.assistant) {
+      fs.rmSync(target.path, { force: true });
+      assistantCleaned.push(target);
     }
+    pruneKnownEmptyDirs(productDir);
   }
 
-  lines.push(...collectServiceDatabaseStatus(config.productDir, config.name));
-  return {
-    name: config.name,
-    lines,
-  };
-}
+  const lines = [];
+  for (const manifest of summary.cleaned) {
+    lines.push(`${dryRun ? "Would clean" : "Cleaned"} stale run ${formatRunSummary(manifest)}`);
+  }
+  for (const manifest of summary.skippedActive) {
+    lines.push(`Active run still present: ${formatRunSummary(manifest)}`);
+  }
+  for (const target of targets.runtime) {
+    lines.push(`${dryRun ? "Would remove" : "Removed"} stale runtime ${target.graph}/${target.runtimeId}`);
+  }
+  appendBoundedFileCleanupLines(lines, {
+    productDir,
+    targets: targets.bundles,
+    label: "bundle cache file",
+    dryRun,
+  });
+  appendBoundedFileCleanupLines(lines, {
+    productDir,
+    targets: targets.assistant,
+    label: "assistant command result",
+    dryRun,
+  });
 
-export async function cleanup(productDir) {
-  const summary = await cleanupRuns(productDir, { includeActive: false });
-  if (summary.cleaned.length === 0 && summary.skippedActive.length === 0) {
+  if (lines.length === 0) {
     return {
       ...summary,
+      dryRun,
+      targets,
+      runtimeCleaned,
+      bundleCleaned,
+      assistantCleaned,
       lines: ["No stale runs to clean."],
     };
   }
 
-  const lines = [];
-  for (const manifest of summary.cleaned) {
-    lines.push(`Cleaned stale run ${formatRunSummary(manifest)}`);
-  }
-  for (const manifest of summary.skippedActive) {
-    lines.push(`Active run still present: ${formatRunSummary(manifest)}`);
-  }
   return {
     ...summary,
+    dryRun,
+    targets,
+    runtimeCleaned,
+    bundleCleaned,
+    assistantCleaned,
     lines,
   };
 }
+
+async function cleanupRuntimeDir(productDir, runtimeDir) {
+  if (!runtimeDir || !fs.existsSync(runtimeDir)) return;
+  const runtimeStateDirs = findRuntimeStateDirs(runtimeDir, isDatabaseStateDir);
+  for (const stateDir of runtimeStateDirs) {
+    await destroyRuntimeDatabase({ productDir, stateDir });
+  }
+  fs.rmSync(runtimeDir, { recursive: true, force: true });
+}
+
+function normalizeCacheSelection(cache) {
+  const values = Array.isArray(cache) ? cache.filter(Boolean).map(String) : [cache].filter(Boolean).map(String);
+  if (values.includes("all")) return ["runtime", "bundles", "assistant"];
+  return values;
+}
+
+function pruneKnownEmptyDirs(productDir) {
+  for (const dir of [
+    path.join(productDir, ".testkit", "assistant", "command-results"),
+    path.join(productDir, ".testkit", "assistant"),
+    path.join(productDir, ".testkit", "_bundles"),
+    path.join(productDir, ".testkit", "_graphs"),
+  ]) {
+    pruneEmptyDir(dir);
+  }
+}
+
+function pruneEmptyDir(dir) {
+  if (!fs.existsSync(dir)) return;
+  try {
+    if (fs.readdirSync(dir).length === 0) fs.rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // Best-effort cleanup only.
+  }
+}
+
+function relativeToProduct(productDir, filePath) {
+  return path.relative(productDir, filePath).split(path.sep).join("/");
+}
+
+function appendBoundedFileCleanupLines(lines, { productDir, targets, label, dryRun }) {
+  if (!targets || targets.length === 0) return;
+  const verb = dryRun ? "Would remove" : "Removed";
+  lines.push(`${verb} ${targets.length} ${label}${targets.length === 1 ? "" : "s"}.`);
+  for (const target of targets.slice(0, 10)) {
+    lines.push(`  ${relativeToProduct(productDir, target.path)}`);
+  }
+  if (targets.length > 10) {
+    lines.push(`  ... ${targets.length - 10} more ${label}${targets.length - 10 === 1 ? "" : "s"}`);
+  }
+}
+
+function collectRunCleanupPreview(productDir) {
+  const summary = {
+    cleaned: [],
+    skippedActive: [],
+  };
+  for (const manifest of listRunManifests(productDir)) {
+    if (isPidRunning(manifest.pid)) {
+      summary.skippedActive.push(manifest);
+    } else {
+      summary.cleaned.push(manifest);
+    }
+  }
+  return summary;
+}

package/lib/runner/planning.mjs

@@ -4,7 +4,7 @@ import {
   suiteSelectionType,
 } from "./suite-selection.mjs";
 
-const TYPE_ORDER = ["dal", "integration", "e2e", "scenario", "load"];
+const TYPE_ORDER = ["ui", "e2e", "scenario", "integration", "dal", "load"];
 
 export function taskNeedsLocalRuntime(task) {
   return task.type !== "dal";

package/lib/runner/results.mjs

@@ -263,7 +263,6 @@ function finalizeSuite(suite) {
   return {
     name: suite.name,
     type: suite.displayType,
-    framework: formatFrameworkForArtifact(suite.framework),
     failed: suite.failedFiles.length > 0,
     fileCount: suite.fileCount,
     completedFileCount: suite.completedFileCount,
@@ -285,11 +284,6 @@ function normalizePathSeparators(filePath) {
   return filePath.split(path.sep).join("/");
 }
 
-function formatFrameworkForArtifact(framework) {
-  if (framework === "k6") return "default";
-  return framework;
-}
-
 function normalizeOutcomeStatus(outcome) {
   if (outcome?.status === "not_run") return "not_run";
   if (outcome?.status === "skipped") return "skipped";