systemview 1.6.2 → 1.6.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "systemview",
   "description": "A documentation and testing suite for SystemLynx",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "license": "UNLICENSED",
   "bin": {
     "systemview": "cli/index.js"
@@ -83,6 +83,7 @@
     "cli/",
     "api/",
     "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
+    );
+  };
+}

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,148 @@
+const moment = require("moment");
+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,
+};

package/testing-utilities/validators.js

@@ -0,0 +1,228 @@
+const moment = require("moment");
+const {
+  arr,
+  obj,
+  parseIndex,
+  replaceLastIndex,
+  switchArrayIndices,
+  getType,
+} = require("./test-helpers");
+
+function evaluate(value, namespace, savedEval = {}, shouldSave) {
+  const type = getType(value);
+  const validations = savedEval.validations || [];
+  const expected_type = savedEval.expected_type || type;
+  const save = shouldSave || !!savedEval.save;
+  const indexed = savedEval.indexed;
+  const errors = getErrors({ type, value, validations, expected_type });
+  return {
+    namespace,
+    expected_type,
+    validations,
+    save,
+    indexed,
+    type,
+    value,
+    errors,
+  };
+}
+
+function validateResults() {
+  const { results, response_type, savedEvaluations, editMode } = this;
+  const savedEvalClone = [...savedEvaluations];
+  const shouldSave = !savedEvaluations.length;
+  const evaluations = [];
+  const errors = [];
+
+  function getSavedIndices(data, nsp) {
+    const randomIndex = () => {
+      // get all matching indices and rename them
+      // so they can be found later during getSavedEval
+      const index = arr(data).randomIndex();
+      const new_nsp = replaceLastIndex(nsp, index);
+      savedEvalClone.forEach((e) => {
+        if (!e.indexed) e.namespace = switchArrayIndices(e.namespace, new_nsp);
+      });
+      return index;
+    };
+    const savedIndices = savedEvalClone
+      .filter(({ namespace }) => {
+        return replaceLastIndex(namespace) === nsp;
+      })
+      .map((e) => {
+        if (e.indexed) {
+          return parseIndex(e.namespace);
+        } else {
+          return randomIndex();
+        }
+      });
+    return savedIndices.length ? savedIndices : [randomIndex()];
+  }
+  const getSavedEval = (nsp) => {
+    const i = savedEvalClone.findIndex(({ namespace }) => {
+      return replaceLastIndex(namespace) === replaceLastIndex(nsp);
+    });
+    return i > -1 ? savedEvalClone.splice(i, 1)[0] : {};
+  };
+  const addEvaluation = (evaluation) => {
+    evaluation.errors.forEach(
+      (e) => evaluation.save && errors.push({ ...e, namespace: evaluation.namespace })
+    );
+    evaluations.push(evaluation);
+  };
+
+  //evaluate based on the result only in edit mode
+  if (editMode)
+    (function recursiveEval(data, namespace) {
+      const evaluation = evaluate(data, namespace, getSavedEval(namespace), shouldSave);
+      addEvaluation(evaluation);
+      if (evaluation.type === "object") {
+        Object.getOwnPropertyNames(data).forEach((prop) => {
+          recursiveEval(data[prop], `${namespace}.${prop}`);
+        });
+      } else if (evaluation.type === "array") {
+        const indices = getSavedIndices(data, `${namespace}[0]`);
+        indices.forEach((index) => recursiveEval(data[index], `${namespace}[${index}]`));
+      }
+    })(results, response_type);
+
+  //evaluate based on the saved evaluations
+  const objParser = new obj({ [response_type]: results });
+  savedEvalClone.forEach(({ namespace, ...e }) => {
+    const value = objParser.valueAtNsp(namespace);
+    if (e.save) addEvaluation(evaluate(value, namespace, e));
+  });
+
+  Object.assign(this, {
+    evaluations: evaluations.sort((e1, e2) => e1.namespace.localeCompare(e2.namespace)),
+    errors,
+  });
+}
+
+function getErrors({ type, value, validations, expected_type }) {
+  if (type !== expected_type && expected_type !== "mixed")
+    return [{ name: "typeError", expected: expected_type, received: type }];
+
+  switch (type) {
+    case "number":
+      return validateNumber(value, validations);
+    case "date":
+      return validateDate(value, validations);
+    case "string":
+      return validateString(value, validations);
+    case "array":
+      return validateArray(value, validations);
+    case "boolean":
+      return validateBoolean(value, validations);
+    case "null":
+    case "undefined":
+    default:
+      return [];
+  }
+}
+
+const defaultValue = (data_type) => {
+  switch (data_type) {
+    case "string":
+      return "";
+    case "number":
+      return 0;
+    case "date":
+      return moment().toJSON();
+    case "boolean":
+      return false;
+    case "array":
+      return [];
+    case "object":
+      return {};
+    case "null":
+      return null;
+    case "target":
+      return "";
+    case "undefined":
+    default:
+      return undefined;
+  }
+};
+
+const validateLength = (item, validations) =>
+  validations.reduce((errors, { name, value }) => {
+    if (name === "lengthEquals" && item.length !== value)
+      return errors.concat({ name, expected: value, received: item.length });
+    if (name === "maxLength" && item.length > value)
+      return errors.concat({ name, expected: value, received: item.length });
+    if (name === "minLength" && item.length < value)
+      return errors.concat({ name, expected: value, received: item.length });
+    return errors;
+  }, []);
+
+const validateArray = (arr, validations) =>
+  validations.reduce((errors, { name, value }) => {
+    if (name === "includes" && !arr.includes(value))
+      return errors.concat({ name, expected: value, received: arr });
+    return errors;
+  }, validateLength(arr, validations));
+
+const validateString = (str, validations) =>
+  validations.reduce((errors, { name, value }) => {
+    if (name === "strEquals" && str !== value)
+      return errors.concat({ name, expected: value, received: str });
+    //str.match() returns null when there is no match
+    if ((name === "isLike") & !str.match(new RegExp(value, "gi")))
+      return errors.concat({ name, expected: value, received: str });
+    if (
+      name === "isOneOf" &&
+      typeof value === "string" &&
+      !value
+        .split(",")
+        .map((v) => v.trim())
+        .includes(str)
+    )
+      return errors.concat({ name, expected: value, received: str });
+    return errors;
+  }, validateLength(str, validations));
+
+const validateNumber = (num, validations) =>
+  validations.reduce((errors, { name, value }) => {
+    if (name === "numEquals" && num !== value)
+      return errors.concat({ name, expected: value, received: num });
+    if (name === "max" && num > value)
+      return errors.concat({ name, expected: value, received: num });
+    if (name === "min" && num < value)
+      return errors.concat({ name, expected: value, received: num });
+    if (
+      name === "isOneOf" &&
+      typeof value === "string" &&
+      !value
+        .split(",")
+        .map((v) => parseInt(v))
+        .includes(num)
+    )
+      return errors.concat({ name, expected: value, received: num });
+    return errors;
+  }, []);
+
+const validateBoolean = (bool, validations) =>
+  validations.reduce((errors, { name, value }) => {
+    if (name === "boolEquals" && bool !== value)
+      return errors.concat({ name, expected: value, received: bool });
+    return errors;
+  }, []);
+
+const validateDate = (datetime, validations) =>
+  validations.reduce((errors, { name, value }) => {
+    if (name === "dateEquals" && !moment(datetime).isSame(value))
+      return errors.concat({ name, expected: value, received: datetime });
+    if (name === "maxDate" && moment(datetime).isAfter(value))
+      return errors.concat({ name, expected: value, received: datetime });
+    if (name === "minDate" && moment(datetime).isBefore(value))
+      return errors.concat({ name, expected: value, received: datetime });
+    return errors;
+  }, []);
+
+module.exports = {
+  evaluate,
+  validateResults,
+  getErrors,
+  defaultValue,
+};

package/testing-utilities/validtionMessages.js

@@ -0,0 +1,45 @@
+const moment = require("moment/moment");
+
+const vowels = ["a", "e", "i", "o", "u"];
+const isVowel = (str) => vowels.includes((str + "").toLowerCase());
+const an = (word) =>
+  word + "" === "undefined" ? "" : isVowel((word + "")[0]) ? "an" : "a";
+
+module.exports = function validationMessage({ name, namespace, expected, received }) {
+  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}`;
+  },
+
+  lengthEquals: (namespace, expected, received) =>
+    `Expected ${namespace} to have a length of ${expected}, received ${received}`,
+  maxLength: (namespace, expected, received) =>
+    `Expected ${namespace} to have a maximum length of ${expected}, received ${received}`,
+  minLength: (namespace, expected, received) =>
+    `Expected ${namespace} to have a minimum length of ${expected}, received ${received}`,
+  includes: (namespace, expected, received) =>
+    `Expected ${namespace} to include the following value: ${expected}, received ${received}`,
+  isLike: (namespace, expected, received) =>
+    `Expected ${namespace} to be like the following expression: ${expected}, received ${received}`,
+  isOneOf: (namespace, expected, received) =>
+    `Expected ${namespace} to be one of the following values: ${expected}, received ${received}`,
+  strEquals: (namespace, expected, received) =>
+    `Expected ${namespace} to equal "${expected}"`,
+  numEquals: (namespace, expected, received) =>
+    `Expected ${namespace} to equal ${expected}, received ${received}`,
+  max: (namespace, expected, received) =>
+    `Expected ${namespace} to be less than ${expected}, received ${received}`,
+  min: (namespace, expected, received) =>
+    `Expected ${namespace} to be greater than ${expected}, received ${received}`,
+  boolEquals: (namespace, expected, received) =>
+    `Expected ${namespace} to be ${expected.toString()}`,
+  dateEquals: (namespace, expected, received) =>
+    `Expected ${namespace} to be ${moment(expected).format()}`,
+  minDate: (namespace, expected, received) =>
+    `Expected ${namespace} to be a date/time later than ${expected}, received ${received}`,
+  maxDate: (namespace, expected, received) =>
+    `Expected ${namespace} to be a date/time earlier than ${expected}, received ${received}`,
+};