systemview 1.18.1 → 1.20.0

package/cli/runTests.js

@@ -1,17 +1,59 @@
 const fs = require("fs");
 const path = require("path");
 const { createCookieClient } = require("./cookieClient");
-const Client = createCookieClient();
 const { initializeSavedTests } = require("../testing-utilities/transformTests");
 const FullTestController = require("../testing-utilities/FullTestController");
 const log = require("./logger");
 const validationMessages = require("../testing-utilities/validtionMessages");
+const { truncate, TruncationMarker } = require("./utils/truncate");
+
+function formatTruncated(value, indent = 0) {
+  const pad = "  ".repeat(indent);
+  const inner = "  ".repeat(indent + 1);
+  if (value instanceof TruncationMarker) return chalk.dim(value.message);
+  if (value === null) return "null";
+  if (typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) {
+    if (!value.length) return "[]";
+    const items = value.map((v) =>
+      v instanceof TruncationMarker
+        ? inner + chalk.dim(v.message)
+        : inner + formatTruncated(v, indent + 1)
+    );
+    return "[\n" + items.join(",\n") + "\n" + pad + "]";
+  }
+  const keys = Object.keys(value);
+  if (!keys.length) return "{}";
+  const entries = keys.map((k) => {
+    const v = value[k];
+    if (k === "__more__" && v instanceof TruncationMarker)
+      return inner + chalk.dim(v.message);
+    return inner + JSON.stringify(k) + ": " + formatTruncated(v, indent + 1);
+  });
+  return "{\n" + entries.join(",\n") + "\n" + pad + "}";
+}
 const { runFullTest } = new FullTestController();
 
 const chalk = require("chalk");
 const DIVIDER = chalk.dim("  " + "─".repeat(60));
+const SUITE_DIVIDER = chalk.cyan("  " + "─".repeat(60));
 
-module.exports = async function runTests(url, project_code, namespace, { json = false, verbose = false, manifest: manifestPath } = {}) {
+module.exports = async function runTests(
+  url,
+  project_code,
+  namespace,
+  {
+    json = false,
+    verbose = false,
+    manifest: manifestPath,
+    headers: cliHeaders = {},
+    bail = false,
+    dryRun = false,
+    phase: phaseFilter = null,
+    index: indexFilter = undefined,
+    skip: skipPatterns = [],
+  } = {}
+) {
   const api = `${url}/systemview/api`;
 
   if (!project_code) {
@@ -19,26 +61,34 @@ module.exports = async function runTests(url, project_code, namespace, { json =
     return 1;
   }
 
-  const connectedServices = await resolveServices(api, project_code, manifestPath);
+  const { services: connectedServices, probeHeaders: manifestHeaders } = await resolveServices(
+    api,
+    project_code,
+    manifestPath
+  );
   if (!connectedServices || !connectedServices.length) {
     log.warn("No connected services found for project: " + project_code);
     return 1;
   }
 
+  const extraHeaders = { ...manifestHeaders, ...cliHeaders };
+  const Client = createCookieClient(extraHeaders);
+
   if (!json) {
     connectedServices.forEach(({ serviceId, system }) => {
       log.success(`connected: ${serviceId} @ ${system.connectionData.serviceUrl}`);
     });
   }
 
-  const allTestLists = await getTests(connectedServices);
+  const allTestLists = await getTests(connectedServices, Client);
   const testToRun = allTestLists
     .map((list) =>
-      namespace
-        ? list.filter(({ namespace: n }) =>
-            `${n.serviceId}.${n.moduleName}.${n.methodName}`.includes(namespace)
-          )
-        : list
+      list.filter(({ namespace: n }) => {
+        const full = `${n.serviceId}.${n.moduleName}.${n.methodName}`;
+        const matchesInclude = !namespace || full.includes(namespace);
+        const matchesSkip = skipPatterns.length && skipPatterns.some((p) => full.includes(p));
+        return matchesInclude && !matchesSkip;
+      })
     )
     .filter((list) => list.length);
 
@@ -47,8 +97,24 @@ module.exports = async function runTests(url, project_code, namespace, { json =
     return 0;
   }
 
+  if (dryRun) {
+    const total = testToRun.reduce((n, list) => n + list.length, 0);
+    console.log("");
+    console.log(`  Would run ${total} ${total === 1 ? "test" : "tests"}:`);
+    console.log("");
+    testToRun.forEach((list) => {
+      list.forEach(({ namespace: n, title }) => {
+        console.log(`  ${chalk.cyan(`${n.serviceId}.${n.moduleName}.${n.methodName}`)} — "${title}"`);
+      });
+    });
+    console.log("");
+    return 0;
+  }
+
   const jsonOutput = json ? { projectCode: project_code, passed: 0, failed: 0, tests: [] } : null;
   let totalFailed = 0;
+  const serviceSummaries = [];
+  const allFailures = [];
 
   for (const testList of testToRun) {
     const { serviceId } = testList[0].namespace;
@@ -56,7 +122,14 @@ module.exports = async function runTests(url, project_code, namespace, { json =
 
     try {
       const initialized = initializeSavedTests(testList, connectedServices, Client);
-      const { passed, failed, jsonTests } = await runAllTests(initialized, url, project_code, json, verbose);
+      const { passed, failed, jsonTests, failures } = await runAllTests(
+        initialized,
+        url,
+        project_code,
+        json,
+        verbose,
+        { bail, phaseFilter, indexFilter }
+      );
       totalFailed += failed;
 
       if (json) {
@@ -64,10 +137,11 @@ module.exports = async function runTests(url, project_code, namespace, { json =
         jsonOutput.failed += failed;
         jsonOutput.tests.push(...jsonTests);
       } else {
-        log[failed ? "error" : "success"](
-          `${serviceId}: ${passed + failed} tests, ${passed} passed, ${failed} failed`
-        );
+        serviceSummaries.push({ serviceId, passed, failed });
+        allFailures.push(...failures);
       }
+
+      if (bail && failed > 0) break;
     } catch (error) {
       log.error(`Unexpected error for ${serviceId}: ${error.message}`);
     }
@@ -79,22 +153,67 @@ module.exports = async function runTests(url, project_code, namespace, { json =
     console.log("");
     log.info("TEST COMPLETE");
     console.log("");
+
+    serviceSummaries.forEach(({ serviceId, passed, failed }) => {
+      const total = passed + failed;
+      log[failed ? "error" : "success"](
+        `${serviceId}: ${total} tests, ${passed} passed, ${failed} failed`
+      );
+    });
+
+    if (allFailures.length) {
+      console.log("");
+      log.warn("FAILED:");
+      allFailures.forEach(({ serviceId, moduleName, methodName, title, failedPhases }) => {
+        console.log("");
+        log.error(`  ${serviceId}.${moduleName}.${methodName} — "${title}"`);
+        failedPhases.forEach(({ phase, actions }) => {
+          actions.forEach(({ actionTitle, errors }) => {
+            console.log(`      ${phase}: "${actionTitle}"`);
+            errors.forEach((err) => console.log(`        → ${validationMessages(err)}`));
+          });
+        });
+      });
+      console.log("");
+    }
   }
 
   return totalFailed > 0 ? 1 : 0;
 };
 
-const runAllTests = async (savedTests, url, project_code, json, verbose) => {
-  const sum = { passed: 0, failed: 0, jsonTests: [] };
+const runAllTests = async (savedTests, url, project_code, json, verbose, opts = {}) => {
+  const { bail = false, phaseFilter = null, indexFilter = undefined } = opts;
+  const sum = { passed: 0, failed: 0, jsonTests: [], failures: [] };
+
+  for (const { Before: B, Main: M, Events: E, After: A, title, namespace } of savedTests) {
+    let Before = [...B];
+    let Main = [...M];
+    let Events = [...E];
+    let After = [...A];
+
+    if (phaseFilter) {
+      const allowed = phaseFilter.split(",").map((p) => p.trim().toLowerCase());
+      if (!allowed.includes("before")) Before = [];
+      if (!allowed.includes("main")) Main = [];
+      if (!allowed.includes("events")) Events = [];
+      if (!allowed.includes("after")) After = [];
+    }
+
+    if (indexFilter !== undefined) {
+      Before = Before.slice(indexFilter, indexFilter + 1);
+      Main = Main.slice(indexFilter, indexFilter + 1);
+      Events = Events.slice(indexFilter, indexFilter + 1);
+      After = After.slice(indexFilter, indexFilter + 1);
+    }
 
-  for (const { Before, Main, Events, After, title, namespace } of savedTests) {
-    const { moduleName, methodName, serviceId } = namespace;
     const fullTest = [Before, Main, Events, After];
+    const { moduleName, methodName, serviceId } = namespace;
 
     if (!json) {
-      console.log("");
-      console.log("  " + chalk.bold.cyan(`${serviceId}.${moduleName}.${methodName}(...)`));
-      console.log(chalk.dim(`    UI → ${url}/${project_code}/${serviceId}/${moduleName}/${methodName}`));
+      console.log(SUITE_DIVIDER);
+      console.log("  " + chalk.bold("Test: ") + chalk.bold.cyan(title));
+      console.log(SUITE_DIVIDER);
+      console.log(chalk.dim(`    ${serviceId}.${moduleName}.${methodName} → ${url}/${project_code}/${serviceId}/${moduleName}/${methodName}`));
       console.log("");
     }
 
@@ -103,8 +222,24 @@ const runAllTests = async (savedTests, url, project_code, json, verbose) => {
     const hasFailed =
       countErrors(Before) + countErrors(Main) + countErrors(Events) + countErrors(After) > 0;
 
-    if (hasFailed) sum.failed++;
-    else sum.passed++;
+    if (hasFailed) {
+      sum.failed++;
+      const failedPhases = [];
+      [
+        { phase: "Before", tests: Before },
+        { phase: "Main", tests: Main },
+        { phase: "Events", tests: Events },
+        { phase: "After", tests: After },
+      ].forEach(({ phase, tests }) => {
+        const actions = tests
+          .filter((t) => t.errors && t.errors.length)
+          .map((t) => ({ actionTitle: t.title, errors: t.errors }));
+        if (actions.length) failedPhases.push({ phase, actions });
+      });
+      sum.failures.push({ serviceId, moduleName, methodName, title, failedPhases });
+    } else {
+      sum.passed++;
+    }
 
     if (json) {
       sum.jsonTests.push({
@@ -119,47 +254,65 @@ const runAllTests = async (savedTests, url, project_code, json, verbose) => {
         After: serializePhase(After),
       });
     } else {
-      logPhase(Before, "Before", verbose, verbose);
-      logPhase(Main, "Main", true, verbose);
-      logPhase(Events, "Events", verbose, verbose);
-      logPhase(After, "After", verbose, verbose);
+      const compact = !verbose;
+      logPhase(Before, "Before", verbose, compact, false);
+      logPhase(Main, "Main", verbose, false, true);
+      logPhase(Events, "Events", verbose, compact, false);
+      logPhase(After, "After", verbose, compact, false);
     }
+
+    if (bail && hasFailed) break;
   }
 
   return sum;
 };
 
-function countErrors(tests) {
-  return tests.reduce((n, t) => n + (t.errors ? t.errors.length : 0), 0);
-}
-
-function logPhase(tests, section, logSuccess = false, verbose = false) {
+function logPhase(tests, section, verbose = false, compact = false, isMain = false) {
   tests.forEach(({ errors, results, namespace, title, args }) => {
     const { serviceId, moduleName, methodName } = namespace;
     const failed = errors && errors.length;
-    if (!failed && !logSuccess) return;
-    console.log(chalk.dim(`    ${section}: ${title}`));
-    failed
-      ? log.error(`  ${serviceId}.${moduleName}.${methodName}(...)`)
-      : log.success(`  ${serviceId}.${moduleName}.${methodName}(...)`);
+
+    const label = isMain ? chalk.bold.green(section) : chalk.blue(section);
+    console.log(`    ${label}: ${chalk.dim(title)}`);
+    if (failed) {
+      console.log("  " + chalk.bold.red(`${serviceId}.${moduleName}.${methodName}(...)`));
+    } else if (isMain) {
+      console.log("  " + chalk.bold.green(`${serviceId}.${moduleName}.${methodName}(...)`));
+    } else {
+      log.success(`  ${serviceId}.${moduleName}.${methodName}(...)`);
+    }
+
     if (verbose && args && args.length) {
       console.log("");
       args.forEach(({ name, input }) => {
         console.log(`    ${chalk.dim(name)}`, JSON.stringify(input));
       });
     }
+
     console.log("");
-    console.log("    results:", JSON.stringify(results, null, 2).replace(/\n/g, "\n    "));
+    if (compact) {
+      console.log("    results:", JSON.stringify(truncate(results)));
+    } else if (verbose) {
+      console.log("    results:", JSON.stringify(results, null, 2).replace(/\n/g, "\n    "));
+    } else {
+      console.log("    results:", formatTruncated(truncate(results)).replace(/\n/g, "\n    "));
+    }
     console.log("");
+
     if (failed) {
       log.warn(`  ${errors.length} validation error(s)`);
       errors.forEach((err) => console.log(`    → ${validationMessages(err)}`));
       console.log("");
     }
+
     console.log(DIVIDER);
   });
 }
 
+function countErrors(tests) {
+  return tests.reduce((n, t) => n + (t.errors ? t.errors.length : 0), 0);
+}
+
 function serializePhase(tests) {
   return tests.map((test) => {
     const { title, namespace, args, results, errors, evaluations } = test;
@@ -188,7 +341,7 @@ function serializePhase(tests) {
   });
 }
 
-async function getTests(connectedServices) {
+async function getTests(connectedServices, Client) {
   const results = [];
   for (const { system } of connectedServices) {
     const { connectionData } = system;
@@ -207,25 +360,28 @@ async function resolveServices(api, project_code, manifestPath) {
   if (fs.existsSync(manifestFile)) {
     try {
       const raw = JSON.parse(fs.readFileSync(manifestFile, "utf8"));
-      // Support both { projectCode, services: [] } and single-service { projectCode, serviceId, system, specList }
       const services = raw.services
         ? raw.services
         : [{ serviceId: raw.serviceId, system: raw.system, specList: raw.specList }];
 
       if (project_code && raw.projectCode && raw.projectCode !== project_code) {
-        log.warn(`Manifest projectCode "${raw.projectCode}" doesn't match "${project_code}", falling back to API`);
+        log.warn(
+          `Manifest projectCode "${raw.projectCode}" doesn't match "${project_code}", falling back to API`
+        );
       } else {
-        return services;
+        return { services, probeHeaders: raw.probeHeaders || {} };
       }
     } catch (err) {
       log.warn(`Failed to read manifest: ${err.message}`);
     }
   }
 
-  return await getConnectedServices(api, project_code);
+  const BaseClient = createCookieClient();
+  const services = await getConnectedServices(api, project_code, BaseClient);
+  return { services, probeHeaders: {} };
 }
 
-async function getConnectedServices(api, project_code) {
+async function getConnectedServices(api, project_code, Client) {
   try {
     const { SystemView } = await Client.loadService(api);
     return await SystemView.getServices(project_code);

package/cli/utils/cli.js

@@ -7,6 +7,7 @@ const HELP_TEXT = `
   Commands:
     start [port]                           Launch SystemView UI (default port 3000)
     test <projectCode> [namespace]         Run saved tests for a project
+    list [projectCode] [namespace]         List projects, services, or tests
     connect <serviceId> <url>             Register a service and write manifest
     connect                               Re-probe all services in existing manifest
     probe <ServiceId.Module.method> [args] Call a method ad-hoc
@@ -14,33 +15,82 @@ const HELP_TEXT = `
     shutdown [port]                        Stop a running SystemView instance
 
   Flags:
+    --version                              Print version and exit
     --json                                 Output results as JSON (for agents/CI)
-    --verbose                              Print all phases including Before/After on pass
+    --verbose                              test: full results and args for all phases; list: expand to show methods and test titles
     --manifest <path>                      Path to manifest file (default: ./systemview.manifest.json)
+    --header "Name: Value"                 Extra request header (repeatable; overrides manifest.probeHeaders)
+    --skip <pattern>                       Exclude tests matching pattern (repeatable)
+    --bail                                 Stop after first failure
+    --dry-run                              Print which tests would run without executing
+    --phase <before|main|events|after>     Run only specified phase(s), comma-separated
+    --index <n>                            Run only action at index n within each phase (0-based)
 
   Examples:
     systemview start
     systemview test buAPI
     systemview test buAPI Users.signUp --json
+    systemview test buAPI --skip deleteUser --bail
+    systemview test buAPI Users.signIn --phase main --index 0
+    systemview list
+    systemview list buAPI
+    systemview list buAPI --verbose
+    systemview list buAPI signUp
     systemview connect ProfilesService http://localhost:4100/bu/api/profiles
     systemview probe ProfilesService.Users.getUser '{"userId":"123"}'
+    systemview open buAPI signUp
+    systemview test buAPI --header "X-Api-Key: secret"
 `;
 
 const rawArgs = process.argv.slice(2);
 
+const flagValueArgs = ["--manifest", "--header", "--skip", "--phase", "--index"];
+
 const flags = {
   json: rawArgs.includes("--json"),
   verbose: rawArgs.includes("--verbose") || rawArgs.includes("-v"),
   debug: rawArgs.includes("--debug") || rawArgs.includes("-d"),
+  bail: rawArgs.includes("--bail"),
+  dryRun: rawArgs.includes("--dry-run"),
   manifest: (() => {
     const i = rawArgs.indexOf("--manifest");
     return i !== -1 ? rawArgs[i + 1] : null;
   })(),
+  phase: (() => {
+    const i = rawArgs.indexOf("--phase");
+    return i !== -1 ? rawArgs[i + 1] : null;
+  })(),
+  index: (() => {
+    const i = rawArgs.indexOf("--index");
+    if (i === -1) return undefined;
+    const val = parseInt(rawArgs[i + 1], 10);
+    return isNaN(val) ? 0 : val;
+  })(),
+  skip: (() => {
+    const result = [];
+    rawArgs.forEach((a, i) => {
+      if (a === "--skip" && rawArgs[i + 1]) result.push(rawArgs[i + 1]);
+    });
+    return result;
+  })(),
+  headers: (() => {
+    const result = {};
+    rawArgs.forEach((a, i) => {
+      if (a === "--header" && rawArgs[i + 1]) {
+        const val = rawArgs[i + 1];
+        const colonIdx = val.indexOf(":");
+        if (colonIdx !== -1) {
+          result[val.slice(0, colonIdx).trim()] = val.slice(colonIdx + 1).trim();
+        }
+      }
+    });
+    return result;
+  })(),
 };
 
 const input = rawArgs.filter((a, i) => {
   if (a.startsWith("-")) return false;
-  if (i > 0 && rawArgs[i - 1] === "--manifest") return false;
+  if (i > 0 && flagValueArgs.includes(rawArgs[i - 1])) return false;
   return true;
 });
 

package/cli/utils/resolveNamespace.js

@@ -0,0 +1,16 @@
+module.exports = function resolveNamespace(partial, connectedServices) {
+  if (!partial || !connectedServices || !connectedServices.length) return [];
+  const matches = [];
+  for (const { serviceId, system } of connectedServices) {
+    const modules = (system && system.connectionData && system.connectionData.modules) || [];
+    for (const { name: moduleName, methods = [] } of modules) {
+      for (const { fn: methodName } of methods) {
+        const full = `${serviceId}.${moduleName}.${methodName}`;
+        if (full.includes(partial)) {
+          matches.push({ serviceId, moduleName, methodName });
+        }
+      }
+    }
+  }
+  return matches;
+};

package/cli/utils/truncate.js

@@ -0,0 +1,31 @@
+class TruncationMarker {
+  constructor(message) {
+    this.message = message;
+  }
+  toJSON() {
+    return this.message;
+  }
+}
+
+function truncate(value, maxItems = 3, maxStrLen = 100) {
+  if (Array.isArray(value)) {
+    const slice = value.slice(0, maxItems).map((item) => truncate(item, maxItems, maxStrLen));
+    if (value.length > maxItems) slice.push(new TruncationMarker(`...${value.length - maxItems} more`));
+    return slice;
+  }
+  if (value !== null && typeof value === "object") {
+    const keys = Object.keys(value);
+    const result = {};
+    keys.slice(0, maxItems).forEach((k) => {
+      result[k] = truncate(value[k], maxItems, maxStrLen);
+    });
+    if (keys.length > maxItems) result.__more__ = new TruncationMarker(`...${keys.length - maxItems} more`);
+    return result;
+  }
+  if (typeof value === "string" && value.length > maxStrLen) {
+    return value.slice(0, maxStrLen) + `...[${value.length - maxStrLen} more chars]`;
+  }
+  return value;
+}
+
+module.exports = { truncate, TruncationMarker };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "systemview",
   "description": "A documentation and testing suite for SystemLynx",
-  "version": "1.18.1",
+  "version": "1.20.0",
   "license": "UNLICENSED",
   "bin": {
     "systemview": "cli/index.js"