systemview 1.6.3 → 1.7.4

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.3",
+  "version": "1.7.4",
   "license": "UNLICENSED",
   "bin": {
     "systemview": "cli/index.js"
@@ -30,7 +30,7 @@
     "react-syntax-highlighter": "^15.5.0",
     "readline": "^1.3.0",
     "remark-gfm": "^3.0.1",
-    "systemlynx": "^1.8.3",
+    "systemlynx": "^1.9.4",
     "web-vitals": "^0.2.4"
   },
   "scripts": {

package/testing-utilities/FullTestController.js

@@ -4,7 +4,7 @@ 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());
+    Events.forEach((test) => test.runTest(Logger));
 
     await new Promise((resolve) => {
       function recursiveRunTest(tests, i = 0) {

package/testing-utilities/test-helpers.js

@@ -1,4 +1,5 @@
 const moment = require("moment");
+moment.suppressDeprecationWarnings = true;
 const rnb = (min, max) => Math.floor(Math.random() * (max - min + 1) + min);
 
 const isTargetNamespace = (str) =>