systemview 1.5.2 → 1.6.3

package/cli/appIsRunning.js

@@ -0,0 +1,25 @@
+const http = require("http");
+
+module.exports = async function appIsRunning(appUrls) {
+  let allAppsRunning = true;
+  const pingApps = appUrls.map(
+    (url) =>
+      new Promise((resolve, reject) => {
+        http.get(url, resolve).on("error", reject);
+      })
+  );
+  try {
+    const responses = await Promise.all(pingApps);
+    responses.forEach((res, index) => {
+      if (res.statusCode !== 200) {
+        allAppsRunning = false;
+        console.log(`App ${index + 1} is not running`);
+      }
+    });
+  } catch (err) {
+    console.error("Error pinging apps:", err.message);
+    allAppsRunning = false;
+  }
+
+  return allAppsRunning;
+};

package/cli/index.js

@@ -10,58 +10,26 @@
 const init = require("./utils/init");
 const cli = require("./utils/cli");
 const log = require("./utils/log");
-const { spawn } = require("child_process");
-const path = require("path");
 
-const parentDirectory = path.resolve(__dirname, "..");
+const launchApp = require("./launchApp");
+const startLineReader = require("./startLineReader");
+const runTests = require("./runTests");
 
 const input = cli.input;
 const flags = cli.flags;
 const { clear, debug } = flags;
 
-function startApp() {
-  // Start React app
-  const arg = parseInt();
-  const port = isNaN(arg) ? 3000 : arg;
-  const env = Object.create(process.env);
-  env.PORT = port;
-  log(`Launching SystemView UI @http://localhost:${port}/`);
-  const AppProcess = spawn("node", ["server"], {
-    stdio: ["inherit"],
-    shell: true,
-    env,
-    cwd: parentDirectory,
-  });
-
-  AppProcess.on("close", (code) => {
-    console.log(`React app exited with code ${code}`);
-  });
-}
-
-function startApi() {
-  log(`Launching SystemView API @http://localhost:${3300}/systemview/api`);
-
-  const AppProcess = spawn("node", ["api"], {
-    stdio: ["inherit"],
-    shell: true,
-    cwd: parentDirectory,
-  });
-
-  AppProcess.on("close", (code) => {
-    console.log(`React app exited with code ${code}`);
-  });
-}
 (async () => {
   init({ clear });
   if (input.includes(`help`)) {
     cli.showHelp(0);
-  }
-  if (input[0] === "start") {
-    startApi();
-    startApp();
   } else if (input.includes("test")) {
-    // Run tests
+    if (await launchApp()) await runTests(input[1]);
+  } else {
+    const shutdown = await launchApp();
+    if (typeof shutdown === "function") startLineReader(shutdown);
   }
 
+  cli.input = [];
   debug && log(flags);
 })();

package/cli/launchApp.js

@@ -0,0 +1,48 @@
+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));
+
+function logConnection(api, app) {
+  log("connected!", "success");
+  console.log(`SystemView API running @${api}`);
+  console.log(`SystemView UI running @${app}`);
+}
+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])) {
+    log("SystemView is running from another terminal", "info", "info");
+    logConnection(api, app);
+    return true;
+  } 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;
+    }
+  }
+};

package/cli/runTests.js

@@ -0,0 +1,99 @@
+const { Client } = require("systemlynx");
+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) {
+  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);
+  //get all the test for each service or the targeted services
+  if (!connectedServices.length) {
+    return log("No connected services found!", "warning");
+  } else {
+    connectedServices.forEach(({ serviceId, system }) => {
+      log(`connected @${system.connectionData.serviceUrl}`, "success", serviceId);
+    });
+  }
+
+  const Tests = await getTests(connectedServices);
+  //transform the test from the saved format to the testing format
+
+  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));
+      }
+      recursiveExecuteTest();
+    })
+  )();
+};
+const Logger = function (trackTime) {
+  this.start = (test) => {
+    if (trackTime) {
+    }
+  };
+
+  this.end = ({ errors }) => {
+    errors.forEach((err) => {
+      const msg = validationMessages(err);
+      log(msg, "error", err.namespace);
+    });
+  };
+};
+const { runFullTest } = new FullTestController();
+const runAllTests = async (savedTest) => {
+  const runTest = async ({ Before, Main, Events, After }) => {
+    const fullTest = [Before, Main, Events, After];
+    const [B, M, E, A] = await runFullTest(fullTest, new Logger());
+    const { title, namespace } = Main[0];
+    return { Before: B, Main: M, Events: E, After: A, title, namespace };
+  };
+
+  await new Promise((resolve) => {
+    function recursiveRunTest(i = 0) {
+      if (i === savedTest.length) resolve();
+      else runTest(savedTest[i]).then(() => recursiveRunTest(i + 1));
+    }
+    recursiveRunTest();
+  });
+};
+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[1].system;
+        try {
+          results.push(await Client.createService(connectionData).Plugin.getTests());
+        } catch (error) {
+          console.log(`Failed to retrieve test from:${connectionData.serviceUrl}`);
+        }
+
+        await recursiveGetTests(i + 1);
+      } else resolve(results);
+    })();
+  });
+}
+async function getConnectedServices(project_code) {
+  try {
+    const { SystemView } = await Client.loadService(
+      "http://localhost:3300/systemview/api"
+    );
+    try {
+      return SystemView.getServices(project_code);
+    } catch (error) {}
+  } catch (error) {
+    console.log("Failed to connect to systemview");
+  }
+}

package/cli/startLineReader.js

@@ -0,0 +1,27 @@
+const runTests = require("./runTests");
+const cli = require("./utils/cli");
+
+const readline = require("readline");
+
+module.exports = function startLineReader(shutdown) {
+  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();
+    } else if (command === "test") {
+      runTests(argument);
+    } else if (command === "help") {
+      cli.showHelp(0);
+    }
+    lineReader.prompt();
+  };
+
+  lineReader.prompt();
+  lineReader.on("line", handleInput);
+  lineReader.on("close", shutdown);
+};

package/cli/utils/log.js

@@ -1,11 +1,5 @@
 const alert = require("cli-alerts");
 
-module.exports = (info) => {
-  alert({
-    type: `info`,
-    name: `SystemView`,
-    msg: ``,
-  });
-
-  console.log(info);
+module.exports = (msg, type = "info", name = "SystemView") => {
+  alert({ type, name, msg });
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "systemview",
   "description": "A documentation and testing suite for SystemLynx",
-  "version": "1.5.2",
+  "version": "1.6.3",
   "license": "UNLICENSED",
   "bin": {
     "systemview": "cli/index.js"
@@ -28,6 +28,7 @@
     "react-router-dom": "^5.2.0",
     "react-scripts": "^4.0.0",
     "react-syntax-highlighter": "^15.5.0",
+    "readline": "^1.3.0",
     "remark-gfm": "^3.0.1",
     "systemlynx": "^1.8.3",
     "web-vitals": "^0.2.4"
@@ -81,8 +82,8 @@
   "files": [
     "cli/",
     "api/",
-    "plugin/",
     "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());
+
+    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 };
+  };
+};

package/testing-utilities/Test.class.js

@@ -0,0 +1,162 @@
+const { validateResults } = require("./validators");
+const { Client } = require("systemlynx");
+const moment = require("moment");
+const { getArrayNamespaces, getLastArrayNamespace, obj } = require("./test-helpers");
+
+module.exports = function Test({
+  namespace,
+  args,
+  title,
+  shouldValidate = false,
+  savedEvaluations = [],
+  index,
+  editMode = true,
+}) {
+  this.index = index;
+  this.connection = {};
+  this.title = title;
+  this.args = args || [];
+  this.editMode = editMode;
+  this.shouldValidate = shouldValidate || !!savedEvaluations.length;
+  this.namespace = namespace || {
+    serviceId: "",
+    moduleName: "",
+    methodName: "",
+  };
+  this.clearResults = () => {
+    this.results = null;
+    this.response_type = "";
+    this.test_start = null;
+    this.test_end = null;
+    this.evaluations = [];
+    this.savedEvaluations = obj(savedEvaluations).clone();
+    this.errors = [];
+    return this;
+  };
+
+  this.clearResults();
+
+  this.getErrors = () => {
+    this.errors = this.evaluations
+      .filter(({ save }) => save)
+      .reduce(
+        (sum, { errors, namespace }) =>
+          sum.concat(errors.map((e) => ({ ...e, namespace }))),
+        []
+      );
+    return this.errors;
+  };
+
+  this.validate = validateResults.bind(this);
+
+  this.runTest = async (_logger) => {
+    const logger = _logger || new TestLogger(this);
+    const { serviceId, moduleName, methodName } = this.namespace;
+    const args = this.args.map((arg) => arg.value());
+
+    this.test_start = moment().toJSON();
+    const Module = this.connection[serviceId][moduleName];
+    if (methodName === "on") {
+      const eventTest = (e) => {
+        this.results = e;
+        this.test_end = moment().toJSON();
+        this.response_type = "event";
+        this.shouldValidate && this.validate();
+        logger.end(this);
+        Module.$clearEvent(args[0], "eventTest");
+      };
+      logger.start(args);
+      Module.on(args[0], eventTest);
+    } else {
+      try {
+        logger.start(args);
+        this.results = await Module[methodName](...args);
+        this.test_end = moment().toJSON();
+        this.response_type = "results";
+        this.shouldValidate && this.validate();
+        logger.end(this);
+      } catch (error) {
+        this.test_end = moment().toJSON();
+        this.results = error;
+        this.response_type = "error";
+        this.shouldValidate && this.validate();
+        logger.end(this);
+      }
+    }
+    return this;
+  };
+
+  this.getConnection = (connectedServices) => {
+    const { serviceId } = this.namespace;
+
+    if (connectedServices.length > 0) {
+      const service = connectedServices.find(
+        (service) => service.serviceId === serviceId
+      );
+      if (!service) {
+        console.warn("connection data not found");
+        return this;
+      }
+      const { connectionData } = service.system;
+
+      this.connection[serviceId] = Client.createService(connectionData);
+    }
+
+    return this;
+  };
+
+  this.addEvaluation = (evaluation) => {
+    const savedEval = this.savedEvaluations.find(
+      ({ namespace }) => namespace === evaluation.namespace
+    );
+    if (savedEval) Object.assign(savedEval, evaluation);
+    else this.savedEvaluations.push(evaluation);
+  };
+  this.removeEvaluation = (namespace) => {
+    const index = this.savedEvaluations.findIndex((e) => e.namespace === namespace);
+    if (index > -1) return this.savedEvaluations.splice(index, 1)[0];
+    else return {};
+  };
+
+  this.addSavedIndices = (arrayNamespace, newArrayNamespace) => {
+    //break namespace into multiple array namespaces
+    const nspList = getArrayNamespaces(arrayNamespace);
+    this.evaluations.forEach((e) => {
+      if (nspList.includes(getLastArrayNamespace(e.namespace))) {
+        e.namespace = e.namespace.replace(arrayNamespace, newArrayNamespace);
+        e.indexed = true;
+        e.expected_type = undefined;
+        this.addEvaluation(e);
+      }
+    });
+  };
+  this.removeSavedIndices = (namespace) => {
+    this.savedEvaluations = this.savedEvaluations.filter(
+      (e) => !e.namespace.includes(namespace) //|| !e.indexed
+    );
+  };
+};
+
+function TestLogger(test) {
+  this.start = (args) => {
+    const { serviceId, moduleName, methodName } = test.namespace;
+
+    console.log(
+      `[${moment(this.test_start).format(
+        "L LTS"
+      )}]> [invoking]:${serviceId}.${moduleName}.${methodName}()`
+    );
+    console.log.apply({}, ["args:"].concat(args));
+  };
+  this.end = () => {
+    const { serviceId, moduleName, methodName } = test.namespace;
+    const { results, response_type } = test;
+    console.log(
+      `[${moment(this.test_end).format(
+        "L LTS"
+      )}]> [${response_type}]:${serviceId}.${moduleName}.${methodName}()`,
+      `${response_type}:`,
+      results
+    );
+  };
+}