init

node_modules/cypress-cucumber-preprocessor/lib/resolveStepDefinition.js

@@ -0,0 +1,228 @@
+const DataTable = require("cucumber/lib/models/data_table").default;
+const {
+  defineParameterType,
+} = require("cucumber/lib/support_code_library_builder/define_helpers");
+const {
+  CucumberExpression,
+  RegularExpression,
+  ParameterTypeRegistry,
+} = require("cucumber-expressions");
+
+const { HookRegistry } = require("./hookRegistry");
+
+class StepDefinitionRegistry {
+  constructor() {
+    this.definitions = {};
+    this.runtime = {};
+    this.options = {
+      parameterTypeRegistry: new ParameterTypeRegistry(),
+    };
+
+    this.definitions = [];
+    this.runtime = (...args) => {
+      let matcher;
+      let config;
+      let implementation;
+      if (args.length > 2) {
+        [matcher, config, implementation] = args;
+      } else {
+        [matcher, implementation] = args;
+      }
+      let expression;
+      if (matcher instanceof RegExp) {
+        expression = new RegularExpression(
+          matcher,
+          this.options.parameterTypeRegistry
+        );
+      } else {
+        expression = new CucumberExpression(
+          matcher,
+          this.options.parameterTypeRegistry
+        );
+      }
+
+      this.definitions.push({
+        implementation,
+        expression,
+        config,
+        featureName: window.currentFeatureName || "___GLOBAL_EXECUTION___",
+      });
+    };
+
+    this.resolve = (type, text, runningFeatureName) =>
+      this.definitions.filter(
+        ({ expression, featureName }) =>
+          expression.match(text) &&
+          (runningFeatureName === featureName ||
+            featureName === "___GLOBAL_EXECUTION___")
+      )[0];
+  }
+}
+
+const stepDefinitionRegistry = new StepDefinitionRegistry();
+const beforeHookRegistry = new HookRegistry();
+const afterHookRegistry = new HookRegistry();
+
+function resolveStepDefinition(step, featureName) {
+  const stepDefinition = stepDefinitionRegistry.resolve(
+    step.keyword.toLowerCase().trim(),
+    step.text,
+    featureName
+  );
+  return stepDefinition || {};
+}
+
+function storeTemplateRowsOnArgumentIfNotPresent(argument) {
+  return !argument.templateRows
+    ? { ...argument, templateRows: argument.rows }
+    : argument;
+}
+
+function applyExampleData(argument, exampleRowData, replaceParameterTags) {
+  const argumentWithTemplateRows = storeTemplateRowsOnArgumentIfNotPresent(
+    argument
+  );
+
+  const scenarioDataTableRows = argumentWithTemplateRows.templateRows.map(
+    (tr) => {
+      if (!(tr && tr.type === "TableRow")) {
+        return tr;
+      }
+      const cells = {
+        cells: tr.cells.map((c) => {
+          const value = {
+            value: replaceParameterTags(exampleRowData, c.value),
+          };
+          return { ...c, ...value };
+        }),
+      };
+      return { ...tr, ...cells };
+    }
+  );
+  return { ...argumentWithTemplateRows, rows: scenarioDataTableRows };
+}
+
+function resolveStepArgument(argument, exampleRowData, replaceParameterTags) {
+  if (!argument) {
+    return argument;
+  }
+  if (argument.type === "DataTable") {
+    if (!exampleRowData) {
+      return new DataTable(argument);
+    }
+    const argumentWithAppliedExampleData = applyExampleData(
+      argument,
+      exampleRowData,
+      replaceParameterTags
+    );
+
+    return new DataTable(argumentWithAppliedExampleData);
+  }
+  if (argument.type === "DocString") {
+    if (exampleRowData) {
+      return replaceParameterTags(exampleRowData, argument.content);
+    }
+    return argument.content;
+  }
+
+  return argument;
+}
+
+function resolveAndRunHooks(hookRegistry, scenarioTags, featureName) {
+  return window.Cypress.Promise.each(
+    hookRegistry.resolve(scenarioTags, featureName),
+    ({ implementation }) => implementation.call(this)
+  );
+}
+
+function parseHookArgs(args) {
+  if (args.length === 2) {
+    if (typeof args[0] !== "object" || typeof args[0].tags !== "string") {
+      throw new Error(
+        "Hook definitions with two arguments should have an object containing tags (string) as the first argument."
+      );
+    }
+    if (typeof args[1] !== "function") {
+      throw new Error(
+        "Hook definitions with two arguments must have a function as the second argument."
+      );
+    }
+    return {
+      tags: args[0].tags,
+      implementation: args[1],
+    };
+  }
+  if (typeof args[0] !== "function") {
+    throw new Error(
+      "Hook definitions with one argument must have a function as the first argument."
+    );
+  }
+  return {
+    implementation: args[0],
+  };
+}
+
+module.exports = {
+  resolveStepDefinition(step, featureName) {
+    return resolveStepDefinition(step, featureName);
+  },
+  resolveAndRunBeforeHooks(scenarioTags, featureName) {
+    return resolveAndRunHooks(beforeHookRegistry, scenarioTags, featureName);
+  },
+  resolveAndRunAfterHooks(scenarioTags, featureName) {
+    return resolveAndRunHooks(afterHookRegistry, scenarioTags, featureName);
+  },
+  // eslint-disable-next-line func-names
+  resolveAndRunStepDefinition(
+    step,
+    replaceParameterTags,
+    exampleRowData,
+    featureName
+  ) {
+    const { expression, implementation } = resolveStepDefinition(
+      step,
+      featureName
+    );
+    const stepText = step.text;
+    if (expression && implementation) {
+      const argument = resolveStepArgument(
+        step.argument,
+        exampleRowData,
+        replaceParameterTags
+      );
+      return implementation.call(
+        this,
+        ...expression.match(stepText).map((match) => match.getValue()),
+        argument
+      );
+    }
+    throw new Error(`Step implementation missing for: ${stepText}`);
+  },
+  Given: (...args) => {
+    stepDefinitionRegistry.runtime(...args);
+  },
+  When: (...args) => {
+    stepDefinitionRegistry.runtime(...args);
+  },
+  Then: (...args) => {
+    stepDefinitionRegistry.runtime(...args);
+  },
+  And: (...args) => {
+    stepDefinitionRegistry.runtime(...args);
+  },
+  But: (...args) => {
+    stepDefinitionRegistry.runtime(...args);
+  },
+  Before: (...args) => {
+    const { tags, implementation } = parseHookArgs(args);
+    beforeHookRegistry.runtime(tags, implementation);
+  },
+  After: (...args) => {
+    const { tags, implementation } = parseHookArgs(args);
+    afterHookRegistry.runtime(tags, implementation);
+  },
+  defineStep: (expression, implementation) => {
+    stepDefinitionRegistry.runtime(expression, implementation);
+  },
+  defineParameterType: defineParameterType(stepDefinitionRegistry),
+};