systemview 1.16.10 → 1.17.0

package/cli/runTests.js

@@ -1,168 +1,235 @@
+const fs = require("fs");
+const path = require("path");
 const { Client } = require("systemlynx");
 const { initializeSavedTests } = require("../testing-utilities/transformTests");
 const FullTestController = require("../testing-utilities/FullTestController");
-const log = require("./utils/log");
+const log = require("./logger");
 const validationMessages = require("../testing-utilities/validtionMessages");
 const { runFullTest } = new FullTestController();
 
-const PARTITION =
-  "-----------------------------------------------------------------------------";
+const chalk = require("chalk");
+const DIVIDER = chalk.dim("  " + "─".repeat(60));
 
-module.exports = async function runTests(url, project_code, namespace) {
+module.exports = async function runTests(url, project_code, namespace, { json = false, verbose = false, manifest: manifestPath } = {}) {
   const api = `${url}/systemview/api`;
+
   if (!project_code) {
-    log("project_code and/or service_url are required", "warning", "warning");
-    console.log(`Example -> systemview test myAPI Users`);
-    return;
+    log.warn("project_code required. Example: systemview test myAPI");
+    return 1;
   }
-  // get connected services from the systemview api
-  const connectedServices = await getConnectedServices(api, project_code);
-  //get all the test for each service or the targeted services
-  if (!connectedServices.length) {
-    log("No connected services found!", "warning");
-    console.log(
-      "You may have to refresh your systemlynx apps for project_code: " + project_code
-    );
-    return;
-  } else {
+
+  const connectedServices = await resolveServices(api, project_code, manifestPath);
+  if (!connectedServices || !connectedServices.length) {
+    log.warn("No connected services found for project: " + project_code);
+    return 1;
+  }
+
+  if (!json) {
     connectedServices.forEach(({ serviceId, system }) => {
-      log(`connected! @${system.connectionData.serviceUrl}`, "success", serviceId);
+      log.success(`connected: ${serviceId} @ ${system.connectionData.serviceUrl}`);
     });
   }
 
-  const testsReceived = await getTests(connectedServices);
-  const testToRun = !namespace
-    ? testsReceived
-    : testsReceived
-        .map((testList) => {
-          return testList.filter(({ namespace: n }) => {
-            return `${n.serviceId}.${n.moduleName}.${n.methodName}`.includes(namespace);
-          });
-        })
-        .filter((testList) => testList.length);
-
-  if (testToRun.length) {
-    const summary = {};
-    await new Promise((resolve) => {
-      async function recursiveExecuteTest(i = 0) {
-        if (i === testToRun.length) resolve();
-        else {
-          const { serviceId } = testToRun[i][0].namespace;
-          log(`Initializing Tests...`, "info", serviceId);
-
-          try {
-            const tests = initializeSavedTests(testToRun[i], connectedServices);
-            summary[serviceId] = await runAllTests(tests, url, project_code);
-          } catch (error) {
-            log(`Unexpected error halting test`, "error", serviceId);
-          } finally {
-            recursiveExecuteTest(i + 1);
-          }
-        }
+  const allTestLists = await getTests(connectedServices);
+  const testToRun = allTestLists
+    .map((list) =>
+      namespace
+        ? list.filter(({ namespace: n }) =>
+            `${n.serviceId}.${n.moduleName}.${n.methodName}`.includes(namespace)
+          )
+        : list
+    )
+    .filter((list) => list.length);
+
+  if (!testToRun.length) {
+    log.warn(`No tests found matching: ${project_code}${namespace ? " " + namespace : ""}`);
+    return 0;
+  }
+
+  const jsonOutput = json ? { projectCode: project_code, passed: 0, failed: 0, tests: [] } : null;
+  let totalFailed = 0;
+
+  for (const testList of testToRun) {
+    const { serviceId } = testList[0].namespace;
+    if (!json) log.info(`Initializing tests for ${serviceId}...`);
+
+    try {
+      const initialized = initializeSavedTests(testList, connectedServices);
+      const { passed, failed, jsonTests } = await runAllTests(initialized, url, project_code, json, verbose);
+      totalFailed += failed;
+
+      if (json) {
+        jsonOutput.passed += passed;
+        jsonOutput.failed += failed;
+        jsonOutput.tests.push(...jsonTests);
+      } else {
+        log[failed ? "error" : "success"](
+          `${serviceId}: ${passed + failed} tests, ${passed} passed, ${failed} failed`
+        );
       }
-      recursiveExecuteTest();
-    });
-    console.log(PARTITION);
-    console.log(PARTITION);
-    log("TEST COMPLETE!", "info");
-    for (let key in summary) {
-      const { passed, failed } = summary[key];
-      log(
-        `tests: ${passed + failed}, passed: ${passed}, failed: ${failed}`,
-        failed ? "error" : "success",
-        key
-      );
+    } catch (error) {
+      log.error(`Unexpected error for ${serviceId}: ${error.message}`);
     }
+  }
+
+  if (json) {
+    process.stdout.write(JSON.stringify(jsonOutput, null, 2) + "\n");
   } else {
-    log(`No tests found matching ${project_code} ${namespace}`, "warning", "warning");
+    console.log("");
+    log.info("TEST COMPLETE");
+    console.log("");
   }
+
+  return totalFailed > 0 ? 1 : 0;
 };
 
-const runAllTests = async (savedTest, url, project_code) => {
-  const sum = { passed: 0, failed: 0 };
-  const runTest = async ({ Before, Main, Events, After }) => {
-    const fullTest = [Before, Main, Events, After];
-    const { namespace } = Main[0];
+const runAllTests = async (savedTests, url, project_code, json, verbose) => {
+  const sum = { passed: 0, failed: 0, jsonTests: [] };
+
+  for (const { Before, Main, Events, After, title, namespace } of savedTests) {
     const { moduleName, methodName, serviceId } = namespace;
+    const fullTest = [Before, Main, Events, After];
 
-    console.log(PARTITION);
-    log(
-      `testing -> ${serviceId}.${moduleName}.${methodName}(...)`,
-      "info",
-      namespace.serviceId
-    );
-    console.log(
-      `systemview ui -> @${url}/${project_code}/${serviceId}/${moduleName}/${methodName}`
-    );
-    console.log(PARTITION);
+    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("");
+    }
 
     await runFullTest(fullTest);
-    if (
-      logResults(Before, "Before") +
-      logResults(Main, "Main", true) +
-      logResults(Events, "Events", true) +
-      logResults(After, "After")
-    ) {
-      sum.failed++;
+
+    const hasFailed =
+      countErrors(Before) + countErrors(Main) + countErrors(Events) + countErrors(After) > 0;
+
+    if (hasFailed) sum.failed++;
+    else sum.passed++;
+
+    if (json) {
+      sum.jsonTests.push({
+        title,
+        serviceId,
+        moduleName,
+        methodName,
+        status: hasFailed ? "failed" : "passed",
+        Before: serializePhase(Before),
+        Main: serializePhase(Main),
+        Events: serializePhase(Events),
+        After: serializePhase(After),
+      });
     } else {
-      sum.passed++;
+      logPhase(Before, "Before", verbose, verbose);
+      logPhase(Main, "Main", true, verbose);
+      logPhase(Events, "Events", verbose, verbose);
+      logPhase(After, "After", verbose, verbose);
     }
-  };
+  }
+
+  return sum;
+};
+
+function countErrors(tests) {
+  return tests.reduce((n, t) => n + (t.errors ? t.errors.length : 0), 0);
+}
 
-  await new Promise((resolve) => {
-    function recursiveRunTest(i = 0) {
-      if (i === savedTest.length) resolve();
-      else runTest(savedTest[i]).then(() => recursiveRunTest(i + 1));
+function logPhase(tests, section, logSuccess = false, verbose = 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}(...)`);
+    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    "));
+    console.log("");
+    if (failed) {
+      log.warn(`  ${errors.length} validation error(s)`);
+      errors.forEach((err) => console.log(`    → ${validationMessages(err)}`));
+      console.log("");
     }
-    recursiveRunTest();
+    console.log(DIVIDER);
   });
+}
 
-  return sum;
-};
-function logResults(tests, section, logSuccess = false) {
-  let failed = 0;
-  tests.forEach(({ errors, results, namespace, title, response_type }) => {
+function serializePhase(tests) {
+  return tests.map((test) => {
+    const { title, namespace, args, results, errors, evaluations } = test;
     const { serviceId, moduleName, methodName } = namespace;
-    const LOG_TYPE = errors.length ? "error" : "success";
-    const LABEL = LOG_TYPE === "error" ? "FAILED" : "PASSED";
-
-    if (LOG_TYPE === "error" || logSuccess) {
-      log(title, "info", section + ":");
-      log(`${serviceId}.${moduleName}.${methodName}(...)`, LOG_TYPE, `${LABEL}`);
-      console.log(`${response_type}:`, results);
-      errors.length && log(`${errors.length} errors`, "warning", "validations");
-      errors.forEach((err) => console.log(`-> ${validationMessages(err)}`));
-      console.log(PARTITION);
-      if (!failed && errors.length) failed = 1;
+    const hasFailed = errors && errors.length > 0;
+    const entry = {
+      title,
+      serviceId,
+      moduleName,
+      methodName,
+      args: args.map((a) => ({ name: a.name, input: a.input })),
+      status: hasFailed ? "failed" : "passed",
+      response: results,
+    };
+    if (hasFailed) {
+      entry.failedEvaluations = (evaluations || [])
+        .filter((e) => e.save && e.errors && e.errors.length)
+        .map((e) => ({
+          namespace: e.namespace,
+          expected_type: e.expected_type,
+          validations: e.validations,
+          received: e.value,
+        }));
     }
+    return entry;
   });
-  return failed;
 }
+
 async function getTests(connectedServices) {
-  return await new Promise(async (resolve) => {
-    const results = [];
-
-    return (async function recursiveGetTests(i = 0) {
-      if (i < connectedServices.length) {
-        const { connectionData } = connectedServices[i].system;
-        try {
-          results.push(await Client.createService(connectionData).Plugin.getTests());
-        } catch (error) {
-          console.log(`Failed to retrieve test from:${connectionData.serviceUrl}:\n`);
-        }
-
-        await recursiveGetTests(i + 1);
-      } else resolve(results);
-    })();
-  });
+  const results = [];
+  for (const { system } of connectedServices) {
+    const { connectionData } = system;
+    try {
+      results.push(await Client.createService(connectionData).Plugin.getTests());
+    } catch (error) {
+      log.warn(`Failed to retrieve tests from ${connectionData.serviceUrl}`);
+    }
+  }
+  return results;
+}
+
+async function resolveServices(api, project_code, manifestPath) {
+  const manifestFile = manifestPath || path.join(process.cwd(), "systemview.manifest.json");
+
+  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`);
+      } else {
+        return services;
+      }
+    } catch (err) {
+      log.warn(`Failed to read manifest: ${err.message}`);
+    }
+  }
+
+  return await getConnectedServices(api, project_code);
 }
+
 async function getConnectedServices(api, project_code) {
   try {
     const { SystemView } = await Client.loadService(api);
-    try {
-      return await SystemView.getServices(project_code);
-    } catch (error) {}
+    return await SystemView.getServices(project_code);
   } catch (error) {
-    console.log("Failed to connect to systemview", error);
+    log.error("Failed to connect to SystemView: " + error.message);
+    return [];
   }
 }

package/cli/utils/cli.js

@@ -1,48 +1,54 @@
-const meow = require("meow");
-const meowHelp = require("cli-meow-help");
+const HELP_TEXT = `
+  SystemView — Documentation and testing suite for SystemLynx
 
-const flags = {
-  clear: {
-    type: `boolean`,
-    default: false,
-    alias: `c`,
-    desc: `Clear the console`,
-  },
-  noClear: {
-    type: `boolean`,
-    default: false,
-    desc: `Don't clear the console`,
-  },
-  debug: {
-    type: `boolean`,
-    default: false,
-    alias: `d`,
-    desc: `Print debug info`,
-  },
-  version: {
-    type: `boolean`,
-    alias: `v`,
-    desc: `Print CLI version`,
-  },
-};
+  Usage:
+    systemview [command] [args] [flags]
+
+  Commands:
+    start [port]                           Launch SystemView UI (default port 3000)
+    test <projectCode> [namespace]         Run saved tests for a project
+    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
+    open [projectCode] [namespace]         Open the browser UI
+    shutdown [port]                        Stop a running SystemView instance
 
-const commands = {
-  help: { desc: `Print help info` },
-  test: { desc: `Run saved test` },
-  start: { desc: `Launch SystemView UI` },
+  Flags:
+    --json                                 Output results as JSON (for agents/CI)
+    --verbose                              Print all phases including Before/After on pass
+    --manifest <path>                      Path to manifest file (default: ./systemview.manifest.json)
+
+  Examples:
+    systemview start
+    systemview test buAPI
+    systemview test buAPI Users.signUp --json
+    systemview connect ProfilesService http://localhost:4100/bu/api/profiles
+    systemview probe ProfilesService.Users.getUser '{"userId":"123"}'
+`;
+
+const rawArgs = process.argv.slice(2);
+
+const flags = {
+  json: rawArgs.includes("--json"),
+  verbose: rawArgs.includes("--verbose") || rawArgs.includes("-v"),
+  debug: rawArgs.includes("--debug") || rawArgs.includes("-d"),
+  manifest: (() => {
+    const i = rawArgs.indexOf("--manifest");
+    return i !== -1 ? rawArgs[i + 1] : null;
+  })(),
 };
 
-const helpText = meowHelp({
-  name: `SystemView`,
-  flags,
-  commands,
+const input = rawArgs.filter((a, i) => {
+  if (a.startsWith("-")) return false;
+  if (i > 0 && rawArgs[i - 1] === "--manifest") return false;
+  return true;
 });
 
-const options = {
-  inferType: true,
-  description: false,
-  hardRejection: false,
+module.exports = {
+  input,
   flags,
+  showHelp() {
+    console.log(HELP_TEXT);
+    process.exit(0);
+  },
 };
-
-module.exports = meow(helpText, options);

package/cli/utils/init.js

@@ -1,17 +1,10 @@
-const welcome = require("cli-welcome");
-const pkg = require("../../package.json");
-const unhandled = require("cli-handle-unhandled");
-
-module.exports = ({ clear = true }) => {
-  unhandled();
-  welcome({
-    title: `SystemView`,
-    tagLine: `by Odion Edwards`,
-    description: pkg.description,
-    version: pkg.version,
-    bgColor: "#36BB09",
-    color: "#000000",
-    bold: true,
-    clear,
+module.exports = function init() {
+  process.on("uncaughtException", (err) => {
+    console.error(err);
+    process.exit(1);
+  });
+  process.on("unhandledRejection", (err) => {
+    console.error(err);
+    process.exit(1);
   });
 };

package/cli/utils/log.js

@@ -1,5 +1 @@
-const alert = require("cli-alerts");
-
-module.exports = (msg, type = "info", name = "SystemView") => {
-  alert({ type, name, msg });
-};
+module.exports = require("../logger");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "systemview",
   "description": "A documentation and testing suite for SystemLynx",
-  "version": "1.16.10",
+  "version": "1.17.0",
   "license": "UNLICENSED",
   "bin": {
     "systemview": "cli/index.js"
@@ -14,16 +14,10 @@
     "@testing-library/react": "^11.1.0",
     "@testing-library/user-event": "^12.1.10",
     "chalk": "^4.1.2",
-    "cli-alerts": "^1.2.2",
-    "cli-handle-error": "^4.4.0",
-    "cli-handle-unhandled": "^1.1.1",
-    "cli-meow-help": "^3.1.0",
-    "cli-welcome": "^2.2.2",
     "express": "^4.18.2",
-    "meow": "^9.0.0",
     "moment": "^2.29.1",
-    "systemlynx": "^1.18.12",
-    "systemlynx-client": "^1.18.12",
+    "systemlynx": "^1.19.12",
+    "systemlynx-client": "^1.19.14",
     "web-vitals": "^0.2.4"
   },
   "scripts": {