systemview 1.11.8 → 1.12.8

package/cli/index.js

@@ -24,6 +24,7 @@ const DEFAULT_PORT = 3000;
 
 async function startApp() {
   const port = isNaN(input[1]) ? DEFAULT_PORT : input[1];
+
   try {
     await launchApp(port);
   } catch (error) {
@@ -33,13 +34,17 @@ async function startApp() {
 }
 
 async function startTest() {
-  const api = `http://localhost:${DEFAULT_PORT}/systemview/api`;
+  const url = `http://localhost:${DEFAULT_PORT}`;
   input.shift();
   try {
     const lineReader = await launchApp(DEFAULT_PORT);
     setTimeout(async () => {
-      await runTests(api, ...input);
-      if (lineReader) lineReader.prompt();
+      await runTests(url, ...input);
+      if (lineReader) {
+        lineReader.prompt();
+      } else {
+        process.exit(0);
+      }
     }, 0);
   } catch (error) {
     console.error("Error executing tests:", error.message);
@@ -47,15 +52,16 @@ async function startTest() {
 }
 
 async function open() {
-  const port = isNaN(input[1]) ? DEFAULT_PORT : input[1];
+  const project_code = input[1];
+  const namespace = input[2];
   const ui = `http://localhost:${DEFAULT_PORT}`;
   const api = `${ui}/systemview/api`;
   if (await appIsRunning(api)) {
-    openBrowser(ui);
+    openBrowser(ui, project_code, namespace);
     process.exit(0);
   } else {
-    await launchApp(port);
-    openBrowser(ui);
+    await launchApp(DEFAULT_PORT);
+    openBrowser(ui, project_code, namespace);
   }
 }
 async function quitApp() {
@@ -93,7 +99,7 @@ async function quitApp() {
     cli.showHelp(0);
   } else if (input.includes("test")) {
     startTest();
-  } else if (["exit", "q", "shutdown"].includes(input[0])) {
+  } else if (["exit", "q", "shutdown", "stop"].includes(input[0])) {
     quitApp();
   } else if (input[0] === "start") {
     startApp();

package/cli/launchApp.js

@@ -9,7 +9,7 @@ module.exports = async function launchApp(port) {
   function logConnection() {
     log("connected!", "success");
     console.log(`SystemView UI running @${ui}`);
-    console.log(`SystemView API running @${api}`);
+    console.log(`SystemView API running @${api}\n`);
   }
 
   if (await appIsRunning(api)) {

package/cli/openBrowser.js

@@ -1,14 +1,16 @@
 const { exec } = require("child_process");
 
-module.exports = function openBrowser(url) {
+module.exports = function openBrowser(url, project_code, namespace) {
   if (!url || typeof url !== "string" || url.trim() === "") {
     console.error("Invalid URL provided");
     return;
   }
 
   const browserCommand = process.platform === "win32" ? "start" : "open";
-
-  exec(`${browserCommand} ${url}`, (error, stdout, stderr) => {
+  const code = project_code ? "/" + project_code : "";
+  const nsp = code && namespace ? "/" + namespace.replace(/\./g, "/") : "";
+  console.log(`opening... ${url}${code}${nsp}`);
+  exec(`${browserCommand} ${url}${code}${nsp}`, (error, stdout, stderr) => {
     if (error) {
       console.error(`Failed to open browser: ${error.message}`);
     } else if (stderr) {

package/cli/runTests.js

@@ -6,17 +6,14 @@ const validationMessages = require("../testing-utilities/validtionMessages");
 const { runFullTest } = new FullTestController();
 
 const PARTITION =
-  "-------------------------------------------------------------------------";
+  "-----------------------------------------------------------------------------";
 
-module.exports = async function runTests(
-  api,
-  project_code,
-  namespace,
-  printAll,
-  trackTime
-) {
+module.exports = async function runTests(url, project_code, namespace) {
+  const api = `${url}/systemview/api`;
   if (!project_code) {
-    return log("project_code or service_url are required", "warning", "warning");
+    log("project_code and/or service_url are required", "warning", "warning");
+    console.log(`Example -> systemview test myAPI Users`);
+    return;
   }
   // get connected services from the systemview api
   const connectedServices = await getConnectedServices(api, project_code);
@@ -34,7 +31,6 @@ module.exports = async function runTests(
   }
 
   const testsReceived = await getTests(connectedServices);
-
   const testToRun = !namespace
     ? testsReceived
     : testsReceived
@@ -46,61 +42,71 @@ module.exports = async function runTests(
         .filter((testList) => testList.length);
 
   if (testToRun.length) {
-    const executeTest = async (savedTests) => {
-      const tests = initializeSavedTests(savedTests, connectedServices);
-      await runAllTests(tests, trackTime);
-    };
-
+    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);
-          executeTest(testToRun[i]).then(() => recursiveExecuteTest(i + 1));
+
+          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);
+          }
         }
       }
       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
+      );
+    }
   } else {
     log(`No tests found matching ${project_code} ${namespace}`, "warning", "warning");
   }
 };
 
-const Logger = function (trackTime) {
-  this.start = (test) => {
-    // if (trackTime) {
-    //   console.log
-    // }
-  };
-
-  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 runAllTests = async (savedTest, trackTime) => {
+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];
-    await runFullTest(fullTest, new Logger(trackTime));
     const { namespace } = Main[0];
-    const { moduleName, methodName } = namespace;
+    const { moduleName, methodName, serviceId } = namespace;
 
-    log(`Testing: ${moduleName}.${methodName}(...)`, "info", namespace.serviceId);
     console.log(PARTITION);
+    log(
+      `testing -> ${serviceId}.${moduleName}.${methodName}(...)`,
+      "info",
+      namespace.serviceId
+    );
+    console.log(
+      `systemview ui -> @${url}/${project_code}/${serviceId}/${moduleName}/${methodName}`
+    );
     console.log(PARTITION);
-    logTestSection(Before, "Before");
-    logTestSection(Main, "Main", true);
-    logTestSection(Events, "Events");
-    logTestSection(After, "After");
+
+    await runFullTest(fullTest);
+    if (
+      logResults(Before, "Before") +
+      logResults(Main, "Main", true) +
+      logResults(Events, "Events") +
+      logResults(After, "After")
+    ) {
+      sum.failed++;
+    } else {
+      sum.passed++;
+    }
   };
 
   await new Promise((resolve) => {
@@ -110,21 +116,27 @@ const runAllTests = async (savedTest, trackTime) => {
     }
     recursiveRunTest();
   });
-};
 
-function logTestSection(tests, section, logSuccess = false) {
-  tests.forEach(({ errors, results, namespace, title, response_type }, i) => {
+  return sum;
+};
+function logResults(tests, section, logSuccess = false) {
+  let failed = 0;
+  tests.forEach(({ errors, results, namespace, title, response_type }) => {
     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;
     }
   });
+  return failed;
 }
 async function getTests(connectedServices) {
   return await new Promise(async (resolve) => {
@@ -136,7 +148,7 @@ async function getTests(connectedServices) {
         try {
           results.push(await Client.createService(connectionData).Plugin.getTests());
         } catch (error) {
-          console.log(`Failed to retrieve test from:${connectionData.serviceUrl}`);
+          console.log(`Failed to retrieve test from:${connectionData.serviceUrl}:\n`);
         }
 
         await recursiveGetTests(i + 1);

package/cli/startLineReader.js

@@ -3,8 +3,7 @@ const cli = require("./utils/cli");
 const openBrowser = require("./openBrowser");
 const readline = require("readline");
 
-module.exports = function startLineReader(ui) {
-  const api = `${ui}/systemview/api`;
+module.exports = function startLineReader(url) {
   const lineReader = readline.createInterface({
     input: process.stdin,
     output: process.stdout,
@@ -12,18 +11,18 @@ module.exports = function startLineReader(ui) {
   const handleInput = (input = "") => {
     const args = input.split(" ").map((s) => s.trim());
     const command = args.shift();
-    if (["exit", "q", "shutdown"].includes(command)) {
+    if (["exit", "q", "shutdown", "stop"].includes(command)) {
       process.exit(0);
     } else if (command === "test") {
       try {
-        runTests(api, ...args);
+        runTests(url, ...args);
       } catch (error) {
         console.error("Error executing tests:", error.message);
       }
     } else if (command === "help") {
       cli.showHelp(0);
     } else if (command === "open") {
-      openBrowser(ui);
+      openBrowser(url, ...args);
     }
     lineReader.prompt();
   };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "systemview",
   "description": "A documentation and testing suite for SystemLynx",
-  "version": "1.11.8",
+  "version": "1.12.8",
   "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.10.6",
+    "systemlynx": "^1.11.8",
     "web-vitals": "^0.2.4"
   },
   "scripts": {

package/testing-utilities/FullTestController.js

@@ -3,13 +3,13 @@ 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));
+  this.runFullTest = async ([Before, Main, Events, After] = FullTest || []) => {
+    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));
+        else tests[i].runTest().then(() => recursiveRunTest(tests, i + 1));
       }
       recursiveRunTest([...Before, ...Main, ...After]);
     });

package/testing-utilities/Test.class.js

@@ -11,6 +11,7 @@ module.exports = function Test({
   savedEvaluations = [],
   index,
   editMode = true,
+  logger,
 }) {
   this.index = index;
   this.connection = {};
@@ -49,8 +50,7 @@ module.exports = function Test({
 
   this.validate = validateResults.bind(this);
 
-  this.runTest = async (_logger) => {
-    const logger = _logger || new TestLogger(this);
+  this.runTest = async () => {
     const { serviceId, moduleName, methodName } = this.namespace;
     const args = this.args.map((arg) => arg.value());
 
@@ -62,25 +62,25 @@ module.exports = function Test({
         this.test_end = moment().toJSON();
         this.response_type = "event";
         this.shouldValidate && this.validate();
-        logger.end(this);
+        if (logger) logger.end(this);
         Module.$clearEvent(args[0], "eventTest");
       };
-      logger.start(args);
+      if (logger) logger.start(args);
       Module.on(args[0], eventTest);
     } else {
       try {
-        logger.start(args);
+        if (logger) 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);
+        if (logger) logger.end(this);
       } catch (error) {
         this.test_end = moment().toJSON();
         this.results = error;
         this.response_type = "error";
         this.shouldValidate && this.validate();
-        logger.end(this);
+        if (logger) logger.end(this);
       }
     }
     return this;
@@ -137,27 +137,3 @@ module.exports = function Test({
     );
   };
 };
-
-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
-    );
-  };
-}

package/testing-utilities/validtionMessages.js

@@ -9,37 +9,36 @@ module.exports = function validationMessage({ name, namespace, expected, receive
   return errorMessages[name](namespace, expected, received);
 };
 const errorMessages = {
-  typeError: (namespace, expected, received) => {
-    const a = isVowel(expected) ? "an" : "a";
-    return `Expected ${namespace} to be ${a} ${expected}, received ${received}`;
-  },
-
+  typeError: (namespace, expected, received) =>
+    `Expected ${namespace} to be ${an(expected)} ${expected}, but received ${an(
+      received
+    )} ${received}`,
   lengthEquals: (namespace, expected, received) =>
-    `Expected ${namespace} to have a length of ${expected}, received ${received}`,
+    `Expected ${namespace} to have a length of ${expected}, but received ${received}`,
   maxLength: (namespace, expected, received) =>
-    `Expected ${namespace} to have a maximum length of ${expected}, received ${received}`,
+    `Expected ${namespace} to have a maximum length of ${expected}, but received ${received}`,
   minLength: (namespace, expected, received) =>
-    `Expected ${namespace} to have a minimum length of ${expected}, received ${received}`,
+    `Expected ${namespace} to have a minimum length of ${expected}, but received ${received}`,
   includes: (namespace, expected, received) =>
-    `Expected ${namespace} to include the following value: ${expected}, received ${received}`,
+    `Expected ${namespace} to include the following value: ${expected}, but received ${received}`,
   isLike: (namespace, expected, received) =>
-    `Expected ${namespace} to be like the following expression: ${expected}, received ${received}`,
+    `Expected ${namespace} to be like the following expression: ${expected}, but received ${received}`,
   isOneOf: (namespace, expected, received) =>
-    `Expected ${namespace} to be one of the following values: ${expected}, received ${received}`,
+    `Expected ${namespace} to be one of the following values: ${expected}, but received ${received}`,
   strEquals: (namespace, expected, received) =>
-    `Expected ${namespace} to equal "${expected}"`,
+    `Expected ${namespace} to equal "${expected}" but received "${received}"`,
   numEquals: (namespace, expected, received) =>
-    `Expected ${namespace} to equal ${expected}, received ${received}`,
+    `Expected ${namespace} to equal ${expected}, but received ${received}`,
   max: (namespace, expected, received) =>
-    `Expected ${namespace} to be less than ${expected}, received ${received}`,
+    `Expected ${namespace} to be less than ${expected}, but received ${received}`,
   min: (namespace, expected, received) =>
-    `Expected ${namespace} to be greater than ${expected}, received ${received}`,
+    `Expected ${namespace} to be greater than ${expected}, but received ${received}`,
   boolEquals: (namespace, expected, received) =>
-    `Expected ${namespace} to be ${expected.toString()}`,
+    `Expected ${namespace} to be ${expected}, but received ${received}`,
   dateEquals: (namespace, expected, received) =>
-    `Expected ${namespace} to be ${moment(expected).format()}`,
+    `Expected ${namespace} to be ${expected}, but received ${received}`,
   minDate: (namespace, expected, received) =>
-    `Expected ${namespace} to be a date/time later than ${expected}, received ${received}`,
+    `Expected ${namespace} to be a date/time later than ${expected}, but received ${received}`,
   maxDate: (namespace, expected, received) =>
-    `Expected ${namespace} to be a date/time earlier than ${expected}, received ${received}`,
+    `Expected ${namespace} to be a date/time earlier than ${expected}, but received ${received}`,
 };