systemview 1.6.2 → 1.7.3

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
+    );
+  };
+}

package/testing-utilities/TestController.class.js

@@ -0,0 +1,134 @@
+const Test = require("./Test.class");
+const { Argument, TargetValue } = require("./Argument.class");
+const { getType } = require("./test-helpers");
+
+module.exports = function TestController({
+  TestSection,
+  setState,
+  section,
+  FullTest,
+  connectedServices,
+}) {
+  this.runTest = async (testIndex) => {
+    const test = TestSection[testIndex];
+    //run only one test
+    await test.runTest();
+    setState([...TestSection]);
+  };
+
+  this.updateNamespace = (index, namespace) => {
+    TestSection[index].namespace = namespace;
+    TestSection[index].getConnection(connectedServices);
+    setState([...TestSection]);
+  };
+  this.addTest = (namespace, args, title) => {
+    TestSection.push(new Test({ namespace, args, title, editMode: true }));
+    setState([...TestSection]);
+    if (namespace) this.updateNamespace(TestSection.length - 1, namespace);
+  };
+  this.deleteTest = (index) => {
+    TestSection.splice(index, 1);
+    setState([...TestSection]);
+  };
+  this.addArg = (index) => {
+    const name = "arg" + (TestSection[0].args.length + 1);
+    TestSection[index].args.push(new Argument(name, FullTest));
+    setState([...TestSection]);
+  };
+  this.deleteArg = (index, arg_index) => {
+    TestSection[index].args.splice(arg_index, 1);
+    setState([...TestSection]);
+  };
+  this.editArg = (index, arg_index, arg) => {
+    arg.data_type = getType(arg.input);
+    TestSection[index].args[arg_index] = arg;
+    setState([...TestSection]);
+  };
+  this.resetResults = (index) => {
+    TestSection[index].clearResults();
+    setState([...TestSection]);
+  };
+
+  this.addTargetValue = (
+    testIndex,
+    arg_index,
+    target_namespace,
+    source_map,
+    source_index
+  ) => {
+    //check to see if target value already exists first
+    const arg = TestSection[testIndex].args[arg_index];
+    arg.addTargetValue(target_namespace, source_map, source_index);
+    setState([...TestSection]);
+  };
+  this.setTargetValue = (
+    testIndex,
+    arg_index,
+    target_index,
+    target_namespace,
+    source_map,
+    source_index
+  ) => {
+    const arg = TestSection[testIndex].args[arg_index];
+
+    arg.targetValues[target_index] = new TargetValue(
+      target_namespace.trim(),
+      source_map,
+      source_index
+    );
+    setState([...TestSection]);
+  };
+
+  this.parseTargetValues = (testIndex, arg_index, input, source_map) => {
+    const arg = TestSection[testIndex].args[arg_index];
+    arg.parseTargetValues(input, source_map).checkTargetNamespaces();
+    setState([...TestSection]);
+  };
+  this.checkTargetValues = (testIndex, arg_index) => {
+    const arg = TestSection[testIndex].args[arg_index];
+    arg.checkTargetNamespaces();
+    setState([...TestSection]);
+  };
+  this.updateTitle = (testIndex, title) => {
+    TestSection[testIndex].title = title;
+    setState([...TestSection]);
+  };
+  this.updateEvaluations = (testIndex, evaluations) => {
+    TestSection[testIndex].evaluations = evaluations;
+    setState([...TestSection]);
+  };
+  this.updateTests = () => {
+    setState([...TestSection]);
+  };
+  this.updateValidationStatus = (testIndex) => {
+    if (section !== 1) {
+      TestSection[testIndex].shouldValidate = !TestSection[testIndex].shouldValidate;
+      if (TestSection[testIndex].shouldValidate) TestSection[testIndex].validate();
+      else TestSection[testIndex].evaluations = [];
+      setState([...TestSection]);
+    }
+  };
+  this.getTargetSuggestions = (testIndex) => {
+    //get target value suggestion (namespaces) for previous test including sub test
+    const suggestions = [];
+    const test_names = ["beforeTest", "mainTest", "afterTest"];
+    //exclude all test sections following current section
+    const targetTests = FullTest.slice(0, section + 1);
+
+    targetTests.forEach((test_section, sIndex) => {
+      //also exclude current test and the tests that follow by the suggestions
+      const count = sIndex === section ? testIndex : test_section.length;
+      for (let i = 0; i < count; i++) {
+        suggestions.push(
+          `${test_names[sIndex]}.${"Action" + (i + 1) + "."}${
+            test_section[i].response_type || "results"
+          }`
+        );
+      }
+    });
+
+    return suggestions;
+  };
+
+  return this;
+};

package/testing-utilities/test-helpers.js

@@ -0,0 +1,149 @@
+const moment = require("moment");
+moment.suppressDeprecationWarnings = true;
+const rnb = (min, max) => Math.floor(Math.random() * (max - min + 1) + min);
+
+const isTargetNamespace = (str) =>
+  /^(?:before|main|after)Test\.Action\d+\.(?:error|results)(?:\.(?![0-9])[a-zA-Z0-9$_]+(?:\[\d\])*)*$/.test(
+    str
+  );
+const targetValueFnRegex =
+  /tv\((?:before|main|after)Test\.Action\d+\.(?:error|results)(?:\.(?![0-9])[a-zA-Z0-9$_]+(?:\[\d\])*)*\)/g;
+const isTargetValueFn = (str) =>
+  /^tv\((?:before|main|after)Test\.Action\d+\.(?:error|results)(?:\.(?![0-9])[a-zA-Z0-9$_]+(?:\[\d\])*)*\)$/.test(
+    str
+  );
+const isEqualArrays = (a, b) => a.join(".") === b.join("."); //specifically for arrays of strings
+const isValidNamespace = (str) => /^(?![0-9])[a-zA-Z0-9$_]+$/.test(str); //_id
+const startsWithNameAndArray = (str) => /^\w+(\[\d+\])+/.test(str); //users[0]
+const isNameAndArray = (str) => /^\w+(\[\d+\])+$/.test(str); //users[0]
+const endsWithArrayIndex = (str) => /\w+(\[\d+\])+$/.test(str); //users[0].docs[3]...
+const getLastArrayNamespace = (str) => (str.match(/(\w+(\[\d+\])+)$/) || [str])[0];
+
+const parseIndex = (nsp) => parseInt((nsp.match(/\[(\d+)\]$/) || [null, "0"])[1]);
+const replaceFirstIndex = (nsp, insert = "0") => nsp.replace(/(\[\d+\])/, `[${insert}]`);
+const replaceLastIndex = (nsp, insert = "0") => nsp.replace(/(\[\d+\])$/, `[${insert}]`);
+
+const replaceAllIndices = (nsp, insert = "0") => nsp.replace(/(\[\d+\])/g, `[${insert}]`);
+
+const getArrayNamespaces = (str) =>
+  str
+    .split(/(\w+(\[\d+\])+)/)
+    .filter(isNameAndArray)
+    .reduce((sum, nsp) => {
+      //split by indexes in case of nested arrays
+      const indices = nsp.split(/(\[\d+\])/).filter((n) => n);
+      const [name] = indices.splice(0, 1);
+      return sum.concat(
+        indices.map((index, i) => {
+          return name + indices.slice(0, i + 1).join("");
+        }, [])
+      );
+    }, []);
+const switchArrayIndices = (nsp, replace) => {
+  // normalize nsp and replace nsp
+  const n = replaceAllIndices(nsp);
+  const r = replaceAllIndices(replace);
+  // match the normalized namespaces
+  if (n.substr(0, r.length) === r) {
+    // create new namespace by concatenating
+    const n = nsp.split(".");
+    const r = replace.split(".");
+    n.splice(...[0, r.length, ...r]);
+    return n.join(".");
+  } else return nsp;
+};
+
+//separate prop names from other prop names and indices (ie. 'test.results[0][0]'...);
+const mapNamespace = (nsp) =>
+  nsp
+    .replace(/(?:\.|\[|\])/g, " ")
+    .split(" ")
+    .reduce((sum, str) => sum.concat(str.trim() || []), []);
+
+const obj = function ObjectParser(obj) {
+  const parser = this || {};
+  parser.parse = (map) =>
+    map.reduce(([placeholder], key) => [placeholder?.[key], placeholder, key], [obj]);
+
+  parser.valueAt = (map) => parser.parse(map)[0];
+
+  parser.valueAtNsp = (nsp) => parser.valueAt(mapNamespace(nsp));
+
+  parser.parseNsp = (nsp) => parser.parse(mapNamespace(nsp));
+  //using JSON to create a deep copy in order to lose refs to original
+  parser.clone = () => JSON.parse(JSON.stringify(obj));
+
+  parser.isEmpty = () => Object.getOwnPropertyNames(obj).length === 0;
+
+  return parser;
+};
+
+const arr = function ArrayParser(arr) {
+  const parser = this || {};
+
+  parser.randomIndex = () => rnb(0, arr.length - 1);
+
+  parser.randomItem = () => arr[parser.randomIndex()];
+  return parser;
+};
+
+const isFn = /^\w+\(([^,)]*(,[^,)]*)*)\)$/;
+const parseArgs = (str) => str.split(",").map((value) => value.trim());
+const isFunction = (str) => isFn.test(str);
+const isDateFunction = (str) => /^[dD]ate\(([^,)]*(,[^,)]*)*)\)$/.test(str);
+
+const strFn = (str) => {
+  if (isDateFunction(str)) {
+    const [fullStr, args] = str.match(isFn);
+    return moment(args).toJSON();
+  }
+
+  return str;
+};
+function getType(value) {
+  switch (true) {
+    case typeof value === "object":
+      if (!value) return "null";
+      else if (Array.isArray(value)) return "array";
+      else return "object";
+    case typeof value === "string":
+      if (moment(value).isValid()) return "date";
+      else return "string";
+    case typeof value === "number":
+      return "number";
+    case typeof value === "boolean":
+      return "boolean";
+    case typeof value === "undefined":
+      return "undefined";
+    default:
+      return "?";
+  }
+}
+const isObjectLike = (value) =>
+  ["object", "array", "string"].indexOf(getType(value)) > -1;
+module.exports = {
+  rnb,
+  isObjectLike,
+  isTargetNamespace,
+  targetValueFnRegex,
+  isTargetValueFn,
+  isEqualArrays,
+  isValidNamespace,
+  startsWithNameAndArray,
+  isNameAndArray,
+  endsWithArrayIndex,
+  getLastArrayNamespace,
+  parseIndex,
+  replaceFirstIndex,
+  replaceLastIndex,
+  replaceAllIndices,
+  getArrayNamespaces,
+  switchArrayIndices,
+  mapNamespace,
+  obj,
+  arr,
+  isFunction,
+  isDateFunction,
+  strFn,
+  getType,
+};

package/testing-utilities/transformTests.js

@@ -0,0 +1,56 @@
+const { Argument } = require("./Argument.class");
+const Test = require("./Test.class");
+
+function initializeSavedTests(savedTests, connectedServices) {
+  return savedTests.map((ft) => {
+    // context matters
+    const newTests = [];
+    const { title, namespace } = ft;
+
+    const Before = ft.Before.map((test) =>
+      resetTestClass(test, newTests, connectedServices, false)
+    );
+    const Main = ft.Main.map((test) =>
+      resetTestClass(test, newTests, connectedServices, false)
+    );
+    const Events = ft.Events.map((test) =>
+      resetTestClass(test, newTests, connectedServices, false)
+    );
+    const After = ft.After.map((test) =>
+      resetTestClass(test, newTests, connectedServices, false)
+    );
+    newTests.push(Before);
+    newTests.push(Main);
+    newTests.push(Events);
+    newTests.push(After);
+    return { Before, Main, Events, After, title, namespace };
+  });
+}
+
+const resetTestClass = (test, FullTest, connectedServices, editMode) => {
+  return new Test({
+    ...test,
+    args: test.args.map(
+      (arg) =>
+        new Argument(arg.name, FullTest, arg.input_type, arg.input, arg.targetValues)
+    ),
+    editMode,
+  }).getConnection(connectedServices);
+};
+
+const resetFullTest = (FullTest, connectedServices, editMode) => {
+  //context matters
+  const newTests = [[], [], [], []];
+  return FullTest.map((section, i) => {
+    return section.map((test) => {
+      const newTest = resetTestClass(test, newTests, connectedServices, editMode);
+      newTests[i].push(newTest);
+      return newTest;
+    });
+  });
+};
+module.exports = {
+  initializeSavedTests,
+  resetTestClass,
+  resetFullTest,
+};