systemview 1.5.2 → 1.6.3

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}`,
+};