systemview 1.6.2 → 1.7.3

package/cli/appIsRunning.js

@@ -13,11 +13,10 @@ module.exports = async function appIsRunning(appUrls) {
     responses.forEach((res, index) => {
       if (res.statusCode !== 200) {
         allAppsRunning = false;
-        console.log(`App ${index + 1} is not running`);
+        console.log(`App ${appUrls[index]} is not running`);
       }
     });
   } catch (err) {
-    console.error("Error pinging apps:", err.message);
     allAppsRunning = false;
   }
 

package/cli/index.js

@@ -6,28 +6,73 @@
  *
  * @author Odion Edwards <none>
  */
-
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
 const init = require("./utils/init");
 const cli = require("./utils/cli");
 const log = require("./utils/log");
 
 const launchApp = require("./launchApp");
-const startLineReader = require("./startLineReader");
 const runTests = require("./runTests");
+const appIsRunning = require("./appIsRunning");
+const { HttpClient } = require("systemlynx");
 
 const input = cli.input;
 const flags = cli.flags;
 const { clear, debug } = flags;
-
+const DEFAULT_PORT = 3000;
+async function launch(_port) {
+  const port = isNaN(_port) ? DEFAULT_PORT : _port;
+  try {
+    await launchApp(port);
+  } catch (error) {
+    log("Launch failed:" + error.message, "error");
+  }
+}
 (async () => {
   init({ clear });
   if (input.includes(`help`)) {
     cli.showHelp(0);
   } else if (input.includes("test")) {
-    if (await launchApp()) await runTests(input[1]);
+    const api = `http://localhost:${DEFAULT_PORT}/systemview/api`;
+    try {
+      input.shift();
+      if (await appIsRunning([api])) {
+        await runTests(api, ...input);
+        process.exit();
+      } else {
+        await launch();
+        await runTests(api, ...input);
+        process.exit();
+      }
+    } catch (error) {
+      console.error("Error executing tests:", error.message);
+    }
+  } else if (["exit", "q", "shutdown"].includes(input[0])) {
+    const port = isNaN(input[1]) ? DEFAULT_PORT : input[1];
+    const api = `http://localhost:${port}/systemview/api`;
+    if (await appIsRunning([api])) {
+      const url = `${api}/SystemView/shutdown`;
+      const method = "put";
+      log("SystemView is running from another terminal", "info", "info");
+      log("Attempting remote shutdown...", "info", "info");
+      HttpClient.request({ url, method })
+        .then(() => console.log("SystemView shutdown successful!"))
+        .catch(async (error) => {
+          if (await appIsRunning([api])) {
+            log("Remote shutdown failed!", "error", "error");
+          } else {
+            console.log("SystemView shutdown successful!");
+          }
+        });
+    } else {
+      log(`SystemView instance not found @${api}`, "warning", "warning");
+      console.log("Please include the port if default port is not being used:");
+      log("systemview shutdown 4000", "info", "example");
+    }
+  } else if (input[0] === "start") {
+    launch(input[1]);
   } else {
-    const shutdown = await launchApp();
-    if (typeof shutdown === "function") startLineReader(shutdown);
+    launch();
   }
 
   cli.input = [];

package/cli/launchApp.js

@@ -1,48 +1,22 @@
 const log = require("./utils/log");
-const { spawn } = require("child_process");
-const path = require("path");
 const appIsRunning = require("./appIsRunning");
-const parentDirectory = path.resolve(__dirname, "..");
-const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const launchSystemView = require("../api");
+const startLineReader = require("./startLineReader");
 
-function logConnection(api, app) {
+function logConnection(api) {
   log("connected!", "success");
-  console.log(`SystemView API running @${api}`);
-  console.log(`SystemView UI running @${app}`);
+  console.log(`SystemView UI running @${api}`);
+  console.log(`SystemView API running @${api}/systemview/api`);
 }
-module.exports = async function launchApp(_port) {
-  const port = isNaN(_port) ? 3000 : _port;
-  const env = Object.create(process.env);
-  const api = `http://localhost:${3300}/systemview/api`;
-  const app = `http://localhost:${port}/`;
-  env.PORT = port;
-
-  if (await appIsRunning([api, app])) {
+module.exports = async function launchApp(port) {
+  const api = `http://localhost:${port}/systemview/api`;
+  if (await appIsRunning([api])) {
     log("SystemView is running from another terminal", "info", "info");
-    logConnection(api, app);
-    return true;
+    logConnection(api);
   } else {
     log("Launching...");
-
-    const appProcess = spawn("node", ["api & node server"], {
-      stdio: ["inherit"],
-      shell: true,
-      env,
-      cwd: parentDirectory,
-    });
-
-    appProcess.on("close", (code) => {
-      console.log(`SystemView APP exited with code ${code}`);
-    });
-    const shutdown = () => {
-      if (appProcess) appProcess.kill();
-    };
-
-    await delay(2000);
-    const isRunning = await appIsRunning([api, app]);
-    if (isRunning) {
-      logConnection(api, app);
-      return shutdown;
-    }
+    await launchSystemView(port);
+    logConnection(api);
+    startLineReader(api);
   }
 };

package/cli/runTests.js

@@ -3,60 +3,115 @@ const { initializeSavedTests } = require("../testing-utilities/transformTests");
 const FullTestController = require("../testing-utilities/FullTestController");
 const log = require("./utils/log");
 const validationMessages = require("../testing-utilities/validtionMessages");
-module.exports = async function runTests(project_code) {
+const PARTITION =
+  "-------------------------------------------------------------------------";
+
+module.exports = async function runTests(
+  api,
+  project_code,
+  namespace,
+  printAll,
+  trackTime
+) {
   if (!project_code) {
     return log("project_code or service_url are required", "warning", "warning");
   }
   // get connected services from the systemview api
-  const connectedServices = await getConnectedServices(project_code);
+  const connectedServices = await getConnectedServices(api, project_code);
   //get all the test for each service or the targeted services
   if (!connectedServices.length) {
-    return log("No connected services found!", "warning");
+    log("No connected services found!", "warning");
+    console.log(
+      "You may have to refresh your systemlynx apps for project_code: " + project_code
+    );
+    return;
   } else {
     connectedServices.forEach(({ serviceId, system }) => {
-      log(`connected @${system.connectionData.serviceUrl}`, "success", serviceId);
+      log(`connected! @${system.connectionData.serviceUrl}`, "success", serviceId);
     });
   }
 
-  const Tests = await getTests(connectedServices);
-  //transform the test from the saved format to the testing format
+  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 executeTest = async (savedTests) => {
+      const tests = initializeSavedTests(savedTests, connectedServices);
+      await runAllTests(tests, trackTime);
+    };
 
-  const executeTest = async (savedTests) => {
-    const tests = initializeSavedTests(savedTests, connectedServices);
-    await runAllTests(tests);
-  };
-  (
     await new Promise((resolve) => {
       async function recursiveExecuteTest(i = 0) {
-        const { serviceId } = connectedServices[i];
-        log(`Initializing Tests...`, "info", serviceId);
-        if (i === Tests.length) resolve();
-        else executeTest(Tests[0]).then(() => recursiveExecuteTest(i + 1));
+        if (i === testToRun.length) resolve();
+        else {
+          const { serviceId } = testToRun[i][0].namespace;
+          log(`Initializing Tests...`, "info", serviceId);
+          executeTest(testToRun[i]).then(() => recursiveExecuteTest(i + 1));
+        }
       }
       recursiveExecuteTest();
-    })
-  )();
+    });
+  } else {
+    log(`No tests found matching ${project_code} ${namespace}`, "warning", "warning");
+  }
 };
+
 const Logger = function (trackTime) {
   this.start = (test) => {
-    if (trackTime) {
-    }
+    // if (trackTime) {
+    //   console.log
+    // }
   };
 
-  this.end = ({ errors }) => {
-    errors.forEach((err) => {
-      const msg = validationMessages(err);
-      log(msg, "error", err.namespace);
-    });
+  this.end = ({ errors, results, namespace, title }) => {
+    // const { moduleName, methodName, serviceId } = namespace;
+    // if (errors.length) {
+    //   log(title, "error", "failed");
+    //   console.error(results);
+    //   errors.forEach((err) => console.log(validationMessages(err)));
+    // } else {
+    //   log(title, "success", "passed");
+    //   console.log(`${serviceId}.${moduleName}.${methodName}(...)`);
+    // }
   };
 };
+const sections = ["Before", "Main", "Events", "After"];
 const { runFullTest } = new FullTestController();
-const runAllTests = async (savedTest) => {
+const runAllTests = async (savedTest, trackTime) => {
   const runTest = async ({ Before, Main, Events, After }) => {
     const fullTest = [Before, Main, Events, After];
-    const [B, M, E, A] = await runFullTest(fullTest, new Logger());
+    const results = await runFullTest(fullTest, new Logger(trackTime));
     const { title, namespace } = Main[0];
-    return { Before: B, Main: M, Events: E, After: A, title, namespace };
+    const { serviceId, moduleName, methodName } = namespace;
+    const totalError = results.reduce((sum, testSection) => {
+      return sum + testSection.reduce((sum, test) => (sum += test.errors.length), 0);
+    }, 0);
+    //console.log(PARTITION);
+    // console.log(PARTITION);
+    if (totalError) {
+      log(title + ` (${totalError} errors)`, "error", namespace.serviceId);
+      results.forEach((testSection) => {
+        testSection.forEach(({ errors, results, namespace, title }, i) => {
+          const { serviceId, moduleName, methodName } = namespace;
+          log(title, "error", sections[i]);
+          console.log(`${serviceId}${moduleName}.${methodName}(..)`);
+          console.log(results);
+          errors.forEach((err) => console.log(validationMessages(err)));
+        });
+      });
+    } else {
+      log(title, "success", namespace.serviceId);
+      console.log(`---> ${serviceId}.${moduleName}.${methodName}(..)`);
+    }
   };
 
   await new Promise((resolve) => {
@@ -73,7 +128,7 @@ async function getTests(connectedServices) {
 
     return (async function recursiveGetTests(i = 0) {
       if (i < connectedServices.length) {
-        const { connectionData } = connectedServices[1].system;
+        const { connectionData } = connectedServices[i].system;
         try {
           results.push(await Client.createService(connectionData).Plugin.getTests());
         } catch (error) {
@@ -85,13 +140,11 @@ async function getTests(connectedServices) {
     })();
   });
 }
-async function getConnectedServices(project_code) {
+async function getConnectedServices(api, project_code) {
   try {
-    const { SystemView } = await Client.loadService(
-      "http://localhost:3300/systemview/api"
-    );
+    const { SystemView } = await Client.loadService(api);
     try {
-      return SystemView.getServices(project_code);
+      return await SystemView.getServices(project_code);
     } catch (error) {}
   } catch (error) {
     console.log("Failed to connect to systemview");

package/cli/startLineReader.js

@@ -3,18 +3,22 @@ const cli = require("./utils/cli");
 
 const readline = require("readline");
 
-module.exports = function startLineReader(shutdown) {
+module.exports = function startLineReader(api) {
   const lineReader = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
   });
   const handleInput = (input = "") => {
-    const [command, argument] = input.split(" ").map((s) => s.trim());
-    if (["exit", "q"].includes(command)) {
-      shutdown();
-      lineReader.close();
+    const args = input.split(" ").map((s) => s.trim());
+    const command = args.shift();
+    if (["exit", "q", "shutdown"].includes(command)) {
+      process.exit(0);
     } else if (command === "test") {
-      runTests(argument);
+      try {
+        runTests(api, ...args);
+      } catch (error) {
+        console.error("Error executing tests:", error.message);
+      }
     } else if (command === "help") {
       cli.showHelp(0);
     }
@@ -23,5 +27,6 @@ module.exports = function startLineReader(shutdown) {
 
   lineReader.prompt();
   lineReader.on("line", handleInput);
-  lineReader.on("close", shutdown);
+  lineReader.on("close", () => process.exit(0));
+  return lineReader;
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "systemview",
   "description": "A documentation and testing suite for SystemLynx",
-  "version": "1.6.2",
+  "version": "1.7.3",
   "license": "UNLICENSED",
   "bin": {
     "systemview": "cli/index.js"
@@ -83,6 +83,7 @@
     "cli/",
     "api/",
     "build/",
+    "testing-utilities",
     "server.js"
   ]
 }

package/testing-utilities/Argument.class.js

@@ -0,0 +1,90 @@
+const {
+  isTargetValueFn,
+  isTargetNamespace,
+  targetValueFnRegex,
+  obj,
+  isEqualArrays,
+  isFunction,
+  strFn,
+} = require("./test-helpers");
+
+function TargetValue(target_namespace, source_map = [], source_index = 0) {
+  this.target_namespace = target_namespace;
+  this.source_map = source_map;
+  this.source_index = source_index;
+}
+function Argument(name, FullTest, input_type = "undefined", input, targetValues = []) {
+  this.name = name;
+  this.input = input;
+  this.input_type = input_type;
+  this.data_type = "";
+  this.targetValues = targetValues;
+
+  this.value = () => {
+    return this.targetValues.reduce((arg, { source_map, target_namespace: nsp }) => {
+      const [value, placeholder, key] = obj(arg).parse(source_map);
+
+      if (isTargetValueFn(nsp)) {
+        placeholder[key] = value
+          .trim()
+          .replace(nsp, getTargetValue(nsp.substring(3, nsp.length - 1)));
+      } else if (isTargetNamespace(nsp)) {
+        placeholder[key] = getTargetValue(nsp);
+      } else {
+        placeholder[key] = strFn(nsp);
+      }
+
+      return arg;
+      //creating a deep copy in order to lose refs to original
+    }, obj(this).clone()).input;
+  };
+
+  this.parseTargetValues = (input, source_map) => {
+    //extract one or more target replacer text from string (i.e. "tv(beforeTest.Action1.error)")
+    Array.from(input.matchAll(targetValueFnRegex)).forEach((match) => {
+      this.addTargetValue(match[0], source_map, match.index);
+    });
+    if (isTargetNamespace(input) || isFunction(input))
+      this.addTargetValue(input, source_map, 0);
+
+    return this;
+  };
+
+  this.checkTargetNamespaces = () => {
+    // check target namespaces against current input for deletion
+    //keep if the target value string still exist on this.input...
+    this.targetValues = this.targetValues.filter(
+      ({ target_namespace, source_map, source_index }) => {
+        const value = obj(this).valueAt(source_map);
+        return (
+          typeof value === "string" &&
+          value.indexOf(target_namespace, source_index) === source_index
+        );
+      }
+    );
+    return this;
+  };
+
+  this.addTargetValue = (target_namespace, source_map = [], source_index) => {
+    //check to see if target value already exists first
+    this.targetValues.findIndex(
+      (tv) =>
+        tv.target_namespace === target_namespace &&
+        isEqualArrays(tv.source_map, source_map) &&
+        tv.source_index === source_index
+    ) === -1 &&
+      this.targetValues.push(new TargetValue(target_namespace, source_map, source_index));
+    return this;
+  };
+
+  const getTargetValue = (input) => {
+    const [test, action] = input.split(".");
+    const nsp = input
+      .replace(test, { beforeTest: 0, mainTest: 1, Events: 2, afterTest: 3 }[test])
+      .replace(action, parseInt(action.replace("Action", "")) - 1)
+      .replace("error", "results");
+    return obj(FullTest).valueAtNsp(nsp);
+  };
+}
+
+module.exports = { Argument, TargetValue, default: Argument };

package/testing-utilities/FullTestController.js

@@ -0,0 +1,78 @@
+const Test = require("./Test.class");
+
+const sections = ["Before", "Main", "Events", "After"];
+
+module.exports = function FullTestController({ FullTest, connectedServices } = {}) {
+  this.runFullTest = async ([Before, Main, Events, After] = FullTest || [], Logger) => {
+    Events.forEach((test) => test.runTest(Logger));
+
+    await new Promise((resolve) => {
+      function recursiveRunTest(tests, i = 0) {
+        if (i === tests.length) resolve();
+        else tests[i].runTest(Logger).then(() => recursiveRunTest(tests, i + 1));
+      }
+      recursiveRunTest([...Before, ...Main, ...After]);
+    });
+
+    return [Before, Main, Events, After];
+  };
+
+  function validateTest({ title, evaluations, shouldValidate }, section, index) {
+    if (!title)
+      return {
+        message: `${sections[section]}: Action ${index + 1} description is required`,
+        error: true,
+      };
+    if (shouldValidate && !evaluations.filter((e) => e.save).length)
+      return {
+        message: `${sections[section]}: Action ${index + 1} validations required`,
+        error: true,
+      };
+
+    return { error: false };
+  }
+  this.saveTests = async (Tests = FullTest) => {
+    const { title, getConnection, namespace, index } = Tests[1][0];
+
+    for (let i = 0; i < Tests.length; i++) {
+      for (let x = 0; x < Tests.length; x++) {
+        const res = Tests[i][x] ? validateTest(Tests[i][x], i, x) : {};
+        if (res.error) return res;
+      }
+    }
+
+    const { connection } = getConnection(connectedServices);
+
+    const { Plugin } = connection[namespace.serviceId];
+
+    if (Plugin) {
+      const [Before, Main, Events, After] = Tests.map((testSection) =>
+        testSection.map((test) => {
+          const { args, evaluations, namespace, title } = test;
+          //resetting scope of test
+          Object.assign(test, new Test(test));
+          return {
+            args,
+            namespace,
+            title,
+            savedEvaluations: evaluations
+              .filter((e) => e.save)
+              .map(({ namespace, expected_type, validations, save, indexed }) => ({
+                namespace,
+                expected_type,
+                validations,
+                save,
+                indexed,
+              })),
+          };
+        })
+      );
+
+      const testIndex = await Plugin.saveTest(
+        { Before, Main, Events, After, title, namespace },
+        index
+      );
+      return { message: "Test Saved!", error: false, testIndex };
+    } else return { message: "Plugin Plugin not connected!", error: true };
+  };
+};