@autometa/test-builder 0.0.0 → 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,20 @@
+# @autometa/test-builder
+
+## 0.1.0
+
+### Minor Changes
+
+- 554b77e: Releasing packages
+
+### Patch Changes
+
+- Updated dependencies [554b77e]
+  - @autometa/bind-decorator@0.5.0
+  - @autometa/dto-builder@0.10.0
+  - @autometa/app@0.1.0
+  - @autometa/asserters@0.1.0
+  - @autometa/errors@0.1.0
+  - @autometa/gherkin@0.4.0
+  - @autometa/phrases@0.1.0
+  - @autometa/scopes@0.2.0
+  - @autometa/types@0.4.0

package/dist/esm/index.js

@@ -1,5 +1,638 @@
-// src/index.ts
-var src_default = {};
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+var __accessCheck = (obj, member, msg) => {
+  if (!member.has(obj))
+    throw TypeError("Cannot " + msg);
+};
+var __privateAdd = (obj, member, value) => {
+  if (member.has(obj))
+    throw TypeError("Cannot add the same private member more than once");
+  member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+};
+var __privateMethod = (obj, member, method) => {
+  __accessCheck(obj, member, "access private method");
+  return method;
+};
+
+// src/bridges/bridge.ts
+var GherkinCodeBridge = class {
+};
+var FeatureBridge = class extends GherkinCodeBridge {
+  constructor() {
+    super(...arguments);
+    this.scenarios = [];
+    this.rules = [];
+    this.steps = [];
+  }
+};
+var BackgroundBridge = class extends GherkinCodeBridge {
+  constructor() {
+    super(...arguments);
+    this.steps = [];
+  }
+};
+var RuleBridge = class extends GherkinCodeBridge {
+  constructor() {
+    super(...arguments);
+    this.scenarios = [];
+    this.steps = [];
+  }
+};
+var ScenarioBridge = class extends GherkinCodeBridge {
+  constructor() {
+    super(...arguments);
+    this.steps = [];
+    this.report = {};
+  }
+};
+var ExampleBridge = class extends GherkinCodeBridge {
+  constructor() {
+    super(...arguments);
+    this.steps = [];
+    this.report = {};
+  }
+};
+var ScenarioOutlineBridge = class extends GherkinCodeBridge {
+  constructor() {
+    super(...arguments);
+    this.examples = [];
+    this.steps = [];
+  }
+};
+var ExamplesBridge = class extends GherkinCodeBridge {
+  constructor() {
+    super(...arguments);
+    this.scenarios = [];
+    this.steps = [];
+  }
+};
+var StepBridge = class extends GherkinCodeBridge {
+};
+
+// src/bridges/bridge-search.ts
+import { AutomationError } from "@autometa/errors";
+function find(bridge, testName) {
+  if (bridge instanceof FeatureBridge) {
+    return findByFeature(bridge, testName);
+  }
+  if (bridge instanceof RuleBridge) {
+    return findByRule(bridge, testName);
+  }
+  if (bridge instanceof ScenarioOutlineBridge) {
+    return findScenarioOutlineOrChild(bridge, testName);
+  }
+  throw new AutomationError(`Could not find test matching ${testName}`);
+}
+function findByFeature(feature, testName) {
+  const title = feature.data.scope.title(feature.data.gherkin);
+  const byScenario = findTestTypes(feature.scenarios, testName, title);
+  if (byScenario) {
+    return byScenario;
+  }
+  const byRule = findRuleTypes(feature.rules, testName, title);
+  if (byRule) {
+    return byRule;
+  }
+}
+function findByRule(rule, testName) {
+  const title = rule.data.scope.title(rule.data.gherkin);
+  const byScenario = findTestTypes(rule.scenarios, testName, title);
+  if (byScenario) {
+    return byScenario;
+  }
+  const byRule = findRuleOrChild(rule, testName, title);
+  if (byRule) {
+    return byRule;
+  }
+}
+function findTestTypes(scenarios, testName, from) {
+  for (const scenario of scenarios) {
+    if (scenario instanceof ScenarioOutlineBridge) {
+      const found = findScenarioOutlineOrChild(scenario, testName, from);
+      if (found) {
+        return found;
+      }
+    }
+    if (scenario instanceof ExamplesBridge) {
+      const found = findExamplesOrChild(scenario, testName, from);
+      if (found) {
+        return found;
+      }
+    }
+    if (scenario instanceof ScenarioBridge) {
+      const found = findScenario(scenario, testName, from);
+      if (found) {
+        return found;
+      }
+    }
+  }
+}
+function findRuleTypes(rules, testName, from) {
+  for (const rule of rules) {
+    const found = findRuleOrChild(rule, testName, from);
+    if (found) {
+      return found;
+    }
+  }
+}
+function findRuleOrChild(rule, testName, from) {
+  const {
+    data: { scope: scope2, gherkin }
+  } = rule;
+  const title = scope2.title(gherkin);
+  if (testName === title) {
+    return rule;
+  }
+  if (from) {
+    const fullTitle = `${from} ${title}`;
+    if (fullTitle === testName) {
+      return rule;
+    }
+  }
+  const newFrom = appendPath(from, title);
+  return findTestTypes(rule.scenarios, testName, newFrom);
+}
+function findScenarioOutlineOrChild(outline, testName, from) {
+  const {
+    data: { scope: scope2, gherkin }
+  } = outline;
+  const title = scope2.title(gherkin);
+  if (testName === title) {
+    return outline;
+  }
+  if (from) {
+    const fullTitle = `${from} ${title}`;
+    if (fullTitle === testName) {
+      return outline;
+    }
+  }
+  for (const example of outline.examples) {
+    const newFrom = appendPath(from, title);
+    const found = findExamplesOrChild(example, testName, newFrom);
+    if (found) {
+      return found;
+    }
+  }
+}
+function appendPath(from, title) {
+  return from ? `${from} ${title}` : title;
+}
+function findExamplesOrChild(example, testName, from) {
+  const {
+    data: { scope: scope2, gherkin }
+  } = example;
+  const title = scope2.title(gherkin);
+  if (testName === title) {
+    return example;
+  }
+  if (from) {
+    const fullTitle = `${from} ${title}`;
+    if (fullTitle === testName) {
+      return example;
+    }
+  }
+  for (const scenario of example.scenarios) {
+    const newFrom = appendPath(from, title);
+    const found = findScenario(scenario, testName, newFrom);
+    if (found) {
+      return found;
+    }
+  }
+}
+function findScenario(scenario, testName, from) {
+  const {
+    data: { scope: scope2, gherkin }
+  } = scenario;
+  const title = scope2.title(gherkin);
+  if (testName === title) {
+    return scenario;
+  }
+  if (from) {
+    const fullTitle = `${from} ${title}`;
+    if (fullTitle === testName) {
+      return scenario;
+    }
+  }
+}
+
+// src/bridges/bridge-query.ts
+import {
+  Background
+} from "@autometa/gherkin";
+function failed(bridge) {
+  const accumulator = [];
+  if (bridge instanceof ScenarioOutlineBridge) {
+    return failedOutline(bridge);
+  }
+  for (const scenario of bridge.scenarios) {
+    if (scenario instanceof ScenarioOutlineBridge) {
+      accumulator.push(...failedOutline(scenario));
+    } else if (!scenario.report.passed) {
+      accumulator.push(scenario);
+    }
+  }
+  if (bridge instanceof FeatureBridge) {
+    accumulator.push(...failedRule(bridge));
+  }
+  return accumulator;
+}
+function failedOutline(bridge) {
+  const accumulator = [];
+  for (const example of bridge.examples) {
+    for (const scenario of example.scenarios) {
+      if (!scenario.report.passed) {
+        accumulator.push(scenario);
+      }
+    }
+  }
+  return accumulator;
+}
+function failedRule(bridge) {
+  const accumulator = [];
+  for (const rule of bridge.rules) {
+    for (const scenario of rule.scenarios) {
+      if (scenario instanceof ScenarioOutlineBridge) {
+        accumulator.push(...failedOutline(scenario));
+      } else if (!scenario.report.passed) {
+        accumulator.push(scenario);
+      }
+    }
+  }
+  return accumulator;
+}
+function gherkinToTestNames(node, path = "", accumulator = []) {
+  if (!("name" in node) || node instanceof Background) {
+    return;
+  }
+  const title = `${node.keyword}: ${node.name}`;
+  const fullPath = path ? `${path} ${title}` : title;
+  accumulator.push(fullPath);
+  if (!node.children) {
+    return;
+  }
+  for (const child of node.children) {
+    if (!("name" in child) || child instanceof Background) {
+      continue;
+    }
+    gherkinToTestNames(child, fullPath, accumulator);
+  }
+  return accumulator;
+}
+var Query = {
+  find: {
+    failed
+  },
+  testNames: gherkinToTestNames
+};
+
+// src/gherkin-walker.ts
+import {
+  Background as Background2,
+  Examples,
+  Feature,
+  Rule,
+  Scenario,
+  ScenarioOutline,
+  Step
+} from "@autometa/gherkin";
+import { AutomationError as AutomationError2 } from "@autometa/errors";
+import { Example } from "@autometa/gherkin";
+var _walkNode, walkNode_fn, _walkChildren, walkChildren_fn;
+var GherkinWalker = class {
+  static walk(walkFunction, childNode, accumulator, parentNode) {
+    if (accumulator === void 0) {
+      throw new AutomationError2(
+        `An accumulator must be defined to continue the walker from ${childNode.constructor.name}${JSON.stringify(childNode)}`
+      );
+    }
+    __privateMethod(this, _walkNode, walkNode_fn).call(this, childNode, accumulator, walkFunction, parentNode);
+    return accumulator;
+  }
+};
+_walkNode = new WeakSet();
+walkNode_fn = function(child, accumulator, walkFunction, lastNode) {
+  if (child instanceof Feature && walkFunction.onFeature) {
+    const acc = walkFunction.onFeature(child, accumulator, lastNode);
+    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
+  }
+  if (child instanceof Rule && walkFunction.onRule) {
+    const acc = walkFunction.onRule(child, accumulator, lastNode);
+    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
+  }
+  if (child instanceof Examples) {
+    const acc = walkFunction.onExamples?.(child, accumulator, lastNode);
+    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
+  }
+  if (child instanceof Example) {
+    const acc = walkFunction.onExample?.(child, accumulator, lastNode);
+    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
+  }
+  if (child instanceof Scenario) {
+    const acc = walkFunction.onScenario?.(child, accumulator, lastNode);
+    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
+  }
+  if (child instanceof ScenarioOutline) {
+    const acc = walkFunction.onScenarioOutline?.(
+      child,
+      accumulator,
+      lastNode
+    );
+    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
+  }
+  if (child instanceof Background2) {
+    const acc = walkFunction?.onBackground?.(child, accumulator, lastNode);
+    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
+  }
+  if (child instanceof Step) {
+    const acc = walkFunction.onStep?.(child, accumulator, lastNode);
+    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
+  }
+};
+_walkChildren = new WeakSet();
+walkChildren_fn = function(child, accumulator, walkFunction) {
+  for (const node of child.children) {
+    this.walk(walkFunction, node, accumulator, child);
+  }
+};
+__privateAdd(GherkinWalker, _walkNode);
+__privateAdd(GherkinWalker, _walkChildren);
+
+// src/scope-search.ts
+import { AutomationError as AutomationError3 } from "@autometa/errors";
+import {
+  RuleScope,
+  ScenarioScope,
+  ScenarioOutlineScope,
+  BackgroundScope
+} from "@autometa/scopes";
+import { Empty_Function } from "@autometa/scopes";
+function scope(value) {
+  return {
+    findRule: (name) => {
+      const found = value.closedScopes.find((child) => {
+        return child instanceof RuleScope && child.name === name;
+      });
+      if (!found) {
+        const rule = new RuleScope(
+          name,
+          Empty_Function,
+          void 0,
+          value.hooks,
+          value.steps
+        );
+        value.attach(rule);
+        return rule;
+      }
+      return found;
+    },
+    findScenario: (name) => {
+      const found = value.closedScopes.find((child) => {
+        return child instanceof ScenarioScope && child.name === name && !(child instanceof ScenarioOutlineScope);
+      });
+      if (!found) {
+        const scenario = new ScenarioScope(
+          name,
+          Empty_Function,
+          void 0,
+          value.hooks,
+          value.steps
+        );
+        value.attach(scenario);
+        return scenario;
+      }
+      return found;
+    },
+    findBackground: ({ name }) => {
+      const found = value.closedScopes.find((child) => {
+        return child instanceof BackgroundScope;
+      });
+      if (found && found.name !== name) {
+        throw new AutomationError3(
+          `Could not find background matching ${name} but found ${found?.name}`
+        );
+      }
+      if (found) {
+        return found;
+      }
+      const bgScope = new BackgroundScope(
+        name,
+        Empty_Function,
+        value.hooks,
+        value.steps
+      );
+      value.attach(bgScope);
+      return bgScope;
+    },
+    findScenarioOutline: (name) => {
+      const found = value.closedScopes.find((child) => {
+        return child instanceof ScenarioOutlineScope && child.name === name;
+      });
+      if (!found) {
+        const scenarioOutline = new ScenarioOutlineScope(
+          name,
+          Empty_Function,
+          void 0,
+          value.hooks,
+          value.steps
+        );
+        value.attach(scenarioOutline);
+        return scenarioOutline;
+      }
+      return found;
+    },
+    findExample(name) {
+      const found = value.closedScopes.find((child) => {
+        if (!(child instanceof ScenarioScope)) {
+          return false;
+        }
+        return child.name === name;
+      });
+      if (!found) {
+        const scenario = new ScenarioScope(
+          name,
+          Empty_Function,
+          void 0,
+          value.hooks,
+          value.steps
+        );
+        value.attach(scenario);
+        return scenario;
+      }
+      return found;
+    },
+    findStep: (keywordType, keyword, name) => {
+      return value.steps.find(keywordType, keyword, name);
+    }
+  };
+}
+
+// src/test-builder.ts
+import { Bind } from "@autometa/bind-decorator";
+import {
+  scenarioExampleTitle
+} from "@autometa/gherkin";
+import { raise } from "@autometa/errors";
+var TestBuilder = class {
+  constructor(feature) {
+    this.feature = feature;
+  }
+  onFeatureExecuted(featureScope) {
+    const bridge = new FeatureBridge();
+    GherkinWalker.walk(
+      {
+        onFeature: (feature, accumulator) => {
+          accumulator.data = { gherkin: feature, scope: featureScope };
+          return accumulator;
+        },
+        onRule: (rule, accumulator) => {
+          const ruleScope = scope(featureScope).findRule(
+            rule.name
+          );
+          const bridge2 = new RuleBridge();
+          bridge2.data = { gherkin: rule, scope: ruleScope };
+          accumulator.rules.push(bridge2);
+          return bridge2;
+        },
+        onScenario: (gherkin, accumulator) => {
+          const scenarioScope = scope(accumulator.data.scope).findScenario(
+            gherkin.name
+          );
+          const bridge2 = new ScenarioBridge();
+          bridge2.data = { gherkin, scope: scenarioScope };
+          accumulator.scenarios.push(bridge2);
+          return bridge2;
+        },
+        onScenarioOutline: (gherkin, accumulator) => {
+          const outlineScope = scope(
+            accumulator.data.scope
+          ).findScenarioOutline(gherkin.name);
+          const bridge2 = new ScenarioOutlineBridge();
+          bridge2.data = { gherkin, scope: outlineScope };
+          accumulator.scenarios.push(bridge2);
+          return bridge2;
+        },
+        onExamples: (gherkin, accumulator) => {
+          const outlineScope = accumulator.data.scope;
+          const bridge2 = new ExamplesBridge();
+          bridge2.data = { gherkin, scope: outlineScope };
+          accumulator.examples.push(bridge2);
+          return bridge2;
+        },
+        onExample(gherkin, accumulator) {
+          if (gherkin.table === void 0) {
+            raise(
+              `Example ${gherkin.name} has no Example Table data. A Row of data is required.`
+            );
+          }
+          const titleSegments = Object.keys(gherkin.table);
+          const values = Object.values(gherkin.table);
+          const title = scenarioExampleTitle(
+            titleSegments,
+            gherkin.name,
+            values
+          );
+          const exampleScope = scope(accumulator.data.scope).findExample(title);
+          const bridge2 = new ExampleBridge();
+          bridge2.data = { gherkin, scope: exampleScope };
+          const acc = accumulator;
+          acc.scenarios.push(bridge2);
+          return bridge2;
+        },
+        onBackground(gherkin, accumulator) {
+          const backgroundScope = scope(accumulator.data.scope).findBackground({
+            name: gherkin.name
+          });
+          const bridge2 = new BackgroundBridge();
+          bridge2.data = { gherkin, scope: backgroundScope };
+          const acc = accumulator;
+          acc.background = bridge2;
+          return bridge2;
+        },
+        onStep: (step, accumulator) => {
+          const {
+            data: { scope: parentScope, gherkin }
+          } = accumulator;
+          const { keyword, keywordType, text } = step;
+          const cache = parentScope.steps;
+          const existing = getStep(
+            accumulator,
+            gherkin,
+            cache,
+            keywordType,
+            keyword,
+            text
+          );
+          const bridge2 = new StepBridge();
+          const acc = accumulator;
+          if (existing) {
+            bridge2.data = {
+              gherkin: step,
+              scope: existing.step,
+              args: existing.args
+            };
+          } else {
+            raise(`No step definition matching ${step.keyword} ${step.text}`);
+          }
+          acc.steps.push(bridge2);
+          return accumulator;
+        }
+      },
+      this.feature,
+      bridge
+    );
+    return bridge;
+  }
+};
+__decorateClass([
+  Bind
+], TestBuilder.prototype, "onFeatureExecuted", 1);
+function getStep(accumulator, gherkin, cache, keywordType, keyword, text) {
+  try {
+    if (accumulator instanceof ExampleBridge) {
+      const scenario = gherkin;
+      if (scenario.table) {
+        return cache.findByExample(keywordType, keyword, text, scenario.table);
+      }
+    }
+    return cache.find(keywordType, keyword, text);
+  } catch (e) {
+    const cause = e;
+    const { title } = gherkin;
+    raise(
+      `'${title}' could not find a step definition`,
+      { cause }
+    );
+  }
+}
 export {
-  src_default as default
+  BackgroundBridge,
+  ExampleBridge,
+  ExamplesBridge,
+  FeatureBridge,
+  GherkinCodeBridge,
+  GherkinWalker,
+  Query,
+  RuleBridge,
+  ScenarioBridge,
+  ScenarioOutlineBridge,
+  StepBridge,
+  TestBuilder,
+  find,
+  findExamplesOrChild,
+  findRuleOrChild,
+  findRuleTypes,
+  findScenario,
+  findScenarioOutlineOrChild,
+  findTestTypes,
+  scope
 };
+//# sourceMappingURL=index.js.map