@autometa/test-builder 0.4.2 → 1.0.0-rc.0

package/dist/esm/index.js

@@ -1,700 +0,0 @@
-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
-import {
-  GherkinNode
-} from "@autometa/gherkin";
-var GherkinCodeBridge = class {
-};
-var GlobalBridge = class extends GherkinCodeBridge {
-  constructor(scope2) {
-    super();
-    const nullNode = class extends GherkinNode {
-      constructor() {
-        super(...arguments);
-        this.keyword = "none";
-      }
-    };
-    this.data = {
-      scope: scope2,
-      gherkin: new nullNode()
-    };
-  }
-};
-var FeatureBridge = class extends GherkinCodeBridge {
-  constructor() {
-    super(...arguments);
-    this.scenarios = [];
-    this.rules = [];
-    this.steps = [];
-  }
-  accumulateTags() {
-    const scenarioTags = this.scenarios.map((scenario) => scenario.accumulateTags()).flat();
-    const ruleTags = this.rules.map((rule) => rule.accumulateTags()).flat();
-    const allTags = [...this.data.gherkin.tags, ...scenarioTags, ...ruleTags];
-    return [...new Set(allTags)];
-  }
-};
-var BackgroundBridge = class extends GherkinCodeBridge {
-  constructor() {
-    super(...arguments);
-    this.steps = [];
-  }
-};
-var RuleBridge = class extends GherkinCodeBridge {
-  constructor() {
-    super(...arguments);
-    this.scenarios = [];
-    this.steps = [];
-  }
-  accumulateTags() {
-    const scenarioTags = this.scenarios.map((scenario) => scenario.accumulateTags()).flat();
-    const allTags = [...this.data.gherkin.tags, ...scenarioTags];
-    return [...new Set(allTags)];
-  }
-};
-var ScenarioBridge = class extends GherkinCodeBridge {
-  constructor() {
-    super(...arguments);
-    this.steps = [];
-    this.report = {};
-  }
-  get title() {
-    return this.data.scope.title(this.data.gherkin);
-  }
-  get tags() {
-    return [...this.data.gherkin.tags];
-  }
-  accumulateTags() {
-    return this.tags;
-  }
-};
-var ExampleBridge = class extends GherkinCodeBridge {
-  constructor() {
-    super(...arguments);
-    this.steps = [];
-    this.report = {};
-  }
-  get title() {
-    return this.data.scope.title(this.data.gherkin);
-  }
-  get tags() {
-    return [...this.data.gherkin.tags];
-  }
-  accumulateTags() {
-    return this.tags;
-  }
-};
-var ScenarioOutlineBridge = class extends GherkinCodeBridge {
-  constructor() {
-    super(...arguments);
-    this.examples = [];
-    this.steps = [];
-  }
-  get title() {
-    return this.data.scope.title(this.data.gherkin);
-  }
-  get tags() {
-    return [...this.data.gherkin.tags];
-  }
-  accumulateTags() {
-    const exampleTags = this.examples.map((example) => example.tags).flat();
-    const allTags = [...this.data.gherkin.tags, ...exampleTags];
-    return [...new Set(allTags)];
-  }
-};
-var ExamplesBridge = class extends GherkinCodeBridge {
-  constructor() {
-    super(...arguments);
-    this.scenarios = [];
-    this.steps = [];
-  }
-  get title() {
-    return this.data.scope.title(this.data.gherkin);
-  }
-  get tags() {
-    return [...this.data.gherkin.tags];
-  }
-  accumulateTags() {
-    const scenarioTags = this.scenarios.map((scenario) => scenario.accumulateTags()).flat();
-    const allTags = [...this.data.gherkin.tags, ...scenarioTags];
-    return [...new Set(allTags)];
-  }
-};
-var StepBridge = class extends GherkinCodeBridge {
-  get args() {
-    return this.data.args;
-  }
-  get expressionText() {
-    return this.data.scope.expression.source;
-  }
-};
-
-// 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: { gherkin }
-  } = example;
-  const title = `${gherkin.keyword}: ${gherkin.name}`;
-  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 as Background2 } 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.error !== void 0) {
-      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.error) {
-        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.error) {
-        accumulator.push(scenario);
-      }
-    }
-  }
-  return accumulator;
-}
-function gherkinToTestNames(node, path = "", accumulator = []) {
-  if (!("name" in node) || node instanceof Background2) {
-    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 Background2) {
-      continue;
-    }
-    gherkinToTestNames(child, fullPath, accumulator);
-  }
-  return accumulator;
-}
-var Query = {
-  find: {
-    failed
-  },
-  testNames: gherkinToTestNames
-};
-
-// src/gherkin-walker.ts
-import {
-  Background as Background3,
-  Examples as Examples2,
-  Feature as Feature2,
-  Rule as Rule2,
-  Scenario as Scenario2,
-  ScenarioOutline as ScenarioOutline2,
-  Step as Step2
-} from "@autometa/gherkin";
-import { AutomationError as AutomationError2 } from "@autometa/errors";
-import { Example as Example2 } 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 Feature2 && walkFunction.onFeature) {
-    const acc = walkFunction.onFeature(child, accumulator, lastNode);
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
-  }
-  if (child instanceof Rule2 && walkFunction.onRule) {
-    const acc = walkFunction.onRule(child, accumulator, lastNode);
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
-  }
-  if (child instanceof Examples2) {
-    const acc = walkFunction.onExamples?.(child, accumulator, lastNode);
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
-  }
-  if (child instanceof Example2) {
-    const acc = walkFunction.onExample?.(child, accumulator, lastNode);
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
-  }
-  if (child instanceof Scenario2) {
-    const acc = walkFunction.onScenario?.(child, accumulator, lastNode);
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
-  }
-  if (child instanceof ScenarioOutline2) {
-    const acc = walkFunction.onScenarioOutline?.(
-      child,
-      accumulator,
-      lastNode
-    );
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
-  }
-  if (child instanceof Background3) {
-    const acc = walkFunction?.onBackground?.(child, accumulator, lastNode);
-    return __privateMethod(this, _walkChildren, walkChildren_fn).call(this, child, acc, walkFunction);
-  }
-  if (child instanceof Step2) {
-    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 { 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 title = gherkin.name;
-          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 {
-  BackgroundBridge,
-  ExampleBridge,
-  ExamplesBridge,
-  FeatureBridge,
-  GherkinCodeBridge,
-  GherkinWalker,
-  GlobalBridge,
-  Query,
-  RuleBridge,
-  ScenarioBridge,
-  ScenarioOutlineBridge,
-  StepBridge,
-  TestBuilder,
-  find,
-  findExamplesOrChild,
-  findRuleOrChild,
-  findRuleTypes,
-  findScenario,
-  findScenarioOutlineOrChild,
-  findTestTypes,
-  scope
-};
-//# sourceMappingURL=index.js.map