systemview 1.4.2 → 1.6.2

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("npm", ["start"], {
-    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.4.2",
+  "version": "1.6.2",
   "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,7 +82,6 @@
   "files": [
     "cli/",
     "api/",
-    "plugin/",
     "build/",
     "server.js"
   ]

package/plugin/SystemViewModule.js

@@ -1,97 +0,0 @@
-const fs = require("fs");
-const getAllTests = require("./getAllTest");
-
-module.exports = (specs, projectCode, serviceId, helperMethods = {}) => {
-  specs = specs.substr(-1) === "/" ? specs.substr(0, specs.length - 1) : specs;
-
-  return function SystemViewPlugin() {
-    const { SystemView } = this.useService("SystemView");
-    Object.assign(this, helperMethods);
-
-    this.saveDoc = ({ documentation, namespace }) => {
-      const fileName = `${specs}/docs/${getName(namespace)}.md`;
-      ensureDir(`${specs}/docs/`);
-      if (documentation) {
-        fs.writeFileSync(fileName, documentation, "utf8");
-      } else {
-        deleteFile(fileName);
-      }
-      SystemView.updateSpecList(this.getSpecList(), projectCode, serviceId);
-      return { documentation, namespace };
-    };
-
-    this.getDoc = (namespace) => {
-      const fileName = `${specs}/docs/${getName(namespace)}.md`;
-      const documentation = getFile(fileName) || "";
-      return { namespace, documentation };
-    };
-
-    this.getTests = (namespace = {}) => {
-      const { moduleName, methodName } = namespace;
-      if (methodName) {
-        const fileName = `${specs}/tests/${moduleName}.${methodName}.json`;
-        const tests = JSON.parse(getFile(fileName) || "[]");
-        return tests;
-      } else if (moduleName) {
-        return getAllTests(`${specs}/tests/`, moduleName);
-      } else {
-        return getAllTests(`${specs}/tests/`);
-      }
-    };
-    this.saveTest = (test, index) => {
-      const fileName = `${specs}/tests/${getName(test.namespace)}.json`;
-      const tests = JSON.parse(getFile(fileName) || "[]");
-      if (typeof index === "number") {
-        tests[index] = test;
-      } else {
-        tests.push(test);
-      }
-      fs.writeFileSync(fileName, JSON.stringify(tests), "utf8");
-      SystemView.updateSpecList(this.getSpecList(), projectCode, serviceId);
-      return index || tests.length - 1;
-    };
-    this.deleteTest = (namespace, index) => {
-      const fileName = `${specs}/tests/${getName(namespace)}.json`;
-      const tests = JSON.parse(getFile(fileName) || "[]");
-      tests.splice(index, 1);
-      console.log(tests.length);
-      if (tests.length) {
-        fs.writeFileSync(fileName, JSON.stringify(tests), "utf8");
-      } else {
-        deleteFile(fileName);
-        SystemView.updateSpecList(this.getSpecList(), projectCode, serviceId);
-      }
-    };
-    this.getSpecList = () => ({
-      docs: fs.readdirSync(`${specs}/docs/`),
-      tests: fs.readdirSync(`${specs}/tests/`),
-    });
-  };
-
-  function deleteFile(fileName) {
-    try {
-      console.log(fileName);
-      fs.unlinkSync(fileName);
-    } catch (err) {
-      // console.error(err);
-    }
-  }
-  function getFile(fileName) {
-    try {
-      return fs.readFileSync(fileName, "utf8");
-    } catch (error) {
-      // console.log(error);
-    }
-  }
-  function ensureDir(dir) {
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-  }
-
-  function getName({ serviceId, moduleName, methodName }) {
-    if (methodName) return `${moduleName}.${methodName}`;
-    else if (moduleName) return moduleName;
-    else if (serviceId) return serviceId;
-  }
-};

package/plugin/getAllTest.js

@@ -1,21 +0,0 @@
-const fs = require("fs");
-const path = require("path");
-
-module.exports = function getFilesByNamespace(folder, namespace) {
-  const files = fs.readdirSync(folder); // read the contents of the current directory
-  const namespacePattern = namespace
-    ? new RegExp(`^${namespace}\\..+\\.json$`)
-    : /\.json$/;
-
-  return files
-    .filter((file) => namespacePattern.test(file))
-    .reduce((sum, file) => {
-      const filePath = path.join(folder, file);
-      const fileContents = fs.readFileSync(filePath, "utf-8");
-      const parsedData = JSON.parse(fileContents);
-
-      return sum.concat(parsedData);
-    }, []);
-};
-
-// no namespace passed, return all files

package/plugin/index.js

@@ -1,40 +0,0 @@
-const SystemViewModule = require("./SystemViewModule");
-const fs = require("fs");
-
-function ensureDir(dir) {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-}
-
-const getSpecList = (specs) => {
-  ensureDir(`${specs}/docs/`);
-  ensureDir(`${specs}/tests/`);
-  return {
-    docs: fs.readdirSync(`${specs}/docs/`),
-    tests: fs.readdirSync(`${specs}/tests/`),
-  };
-};
-module.exports = function ({
-  connection = "http://localhost:3300/systemview/api",
-  specs = "./specs",
-  projectCode,
-  serviceId,
-  helperMethods,
-}) {
-  return function (App) {
-    App.loadService("SystemView", connection)
-      .module("Plugin", SystemViewModule(specs, projectCode, serviceId, helperMethods))
-      .on("ready", async function connectSystemView(system) {
-        try {
-          const { SystemView } = this.useService("SystemView");
-          const specList = getSpecList(specs);
-          console.log("reconnection");
-          await SystemView.connect({ system, projectCode, serviceId, specList });
-          // SystemView.on("reconnect", connectSystemView.bind(this, system));
-        } catch (error) {
-          console.log("SystemView connection failed---->", error);
-        }
-      });
-  };
-};