Update @cucumber/compatibility-kit to v23.0.0

Author: badeball

compatibility/cck_spec.ts

@@ -45,6 +45,8 @@ const ignorableKeys = [
   // errors
   "message",
   "stackTrace",
+  // suggestions
+  "snippets",
 ];
 
 function isObject(object: any): object is object {
@@ -99,6 +101,7 @@ describe("Cucumber Compatibility Kit", () => {
       case "hooks-conditional": // Expections during hooks are difficult to mimick due to no try-catch
       case "global-hooks-beforeall-error": // See above
       case "global-hooks-afterall-error": // See above
+      case "hooks-undefined": // See above
       case "multiple-features": // The "correct" message order is difficult to mimick
       case "multiple-features-reversed": // Cypress has no `reversed` option
         it.skip(`passes the cck suite for '${suiteName}'`);
@@ -278,7 +281,7 @@ describe("Cucumber Compatibility Kit", () => {
         (await fs.readFile(ndjsonFile)).toString(),
       ).map(normalizeMessage);
 
-      if (suiteName === "pending") {
+      if (suiteName === "pending" || suiteName === "retry-pending") {
         /**
          * We can't control Cypress exit code without failing a test, thus is cucumber-js behavior
          * difficult to mimic.

compatibility/step_definitions/ambiguous.ts

@@ -1,9 +1,9 @@
 import { Given } from "@badeball/cypress-cucumber-preprocessor";
 
-Given(/a (.*?) with (.*?)/, function () {
+Given(/^a (.*?) with (.*?)$/, function () {
   // first one
 });
 
-Given(/a step with (.*)/, function () {
+Given(/^a step with (.*)$/, function () {
   // second one
 });

compatibility/step_definitions/examples-tables-undefined.ts

@@ -0,0 +1,13 @@
+import { Given, Then, When } from "@badeball/cypress-cucumber-preprocessor";
+
+Given("there are {int} cucumbers", function (initialCount) {
+  this.count = initialCount;
+});
+
+When("I eat {int} cucumbers", function (eatCount: number) {
+  this.count -= eatCount;
+});
+
+Then("I should have {int} cucumbers", function (expectedCount: number) {
+  expect(this.count).to.equal(expectedCount);
+});

compatibility/step_definitions/retry-ambiguous.ts

@@ -0,0 +1,9 @@
+import { Given } from "@badeball/cypress-cucumber-preprocessor";
+
+Given("an ambiguous step", function () {
+  // first one
+});
+
+Given("an ambiguous step", function () {
+  // second one
+});

compatibility/step_definitions/retry-pending.ts

@@ -0,0 +1,5 @@
+import { Given } from "@badeball/cypress-cucumber-preprocessor";
+
+Given("a pending step", function () {
+  return "pending";
+});

compatibility/step_definitions/retry-undefined.ts

@@ -0,0 +1 @@
+// There are intentionally no steps defined for this sample

compatibility/step_definitions/retry.ts

@@ -23,15 +23,3 @@ Given("a step that passes the third time", function () {
 Given("a step that always fails", function () {
   throw new Error("Exception in step");
 });
-
-Given("an ambiguous step", function () {
-  // first one
-});
-
-Given("an ambiguous step", function () {
-  // second one
-});
-
-Given("a pending step", function () {
-  return "pending";
-});

lib/add-cucumber-preprocessor-plugin.ts

@@ -12,6 +12,7 @@ import {
   TASK_CREATE_STRING_ATTACHMENT,
   TASK_FRONTEND_TRACKING_ERROR,
   TASK_SPEC_ENVELOPES,
+  TASK_SUGGESTION,
   TASK_TEST_CASE_FINISHED,
   TASK_TEST_CASE_STARTED,
   TASK_TEST_RUN_HOOK_FINISHED,
@@ -34,6 +35,7 @@ import {
   frontendTrackingErrorHandler,
   OnAfterStep,
   specEnvelopesHandler,
+  suggestion,
   testCaseFinishedHandler,
   testCaseStartedHandler,
   testRunHookFinishedHandler,
@@ -133,6 +135,7 @@ export async function addCucumberPreprocessorPlugin(
       null,
       config,
     ),
+    [TASK_SUGGESTION]: suggestion.bind(null, config),
   });
 
   const tags = getTags(config.env);

lib/browser-runtime.ts

@@ -1,7 +1,6 @@
 import {
   CucumberExpressionGenerator,
   Group,
-  ParameterTypeRegistry,
   RegularExpression,
 } from "@cucumber/cucumber-expressions";
 import * as messages from "@cucumber/messages";
@@ -18,6 +17,7 @@ import {
 import {
   ITaskFrontendTrackingError,
   ITaskSpecEnvelopes,
+  ITaskSuggestion,
   ITaskTestCaseFinished,
   ITaskTestCaseStarted,
   ITaskTestRunHookFinished,
@@ -26,6 +26,7 @@ import {
   ITaskTestStepStarted,
   TASK_FRONTEND_TRACKING_ERROR,
   TASK_SPEC_ENVELOPES,
+  TASK_SUGGESTION,
   TASK_TEST_CASE_FINISHED,
   TASK_TEST_CASE_STARTED,
   TASK_TEST_RUN_HOOK_FINISHED,
@@ -273,6 +274,12 @@ function taskFrontEndTrackingError(error: CypressCucumberAssertionError) {
   );
 }
 
+function taskSuggestion(suggestion: messages.Suggestion) {
+  return cy.task(TASK_SUGGESTION, suggestion satisfies ITaskSuggestion, {
+    log: false,
+  });
+}
+
 function emitSkippedPickle(
   context: CompositionContext,
   pickle: messages.Pickle,
@@ -862,60 +869,94 @@ function createPickle(context: CompositionContext, pickle: messages.Pickle) {
 
             return beforeHooksChain()
               .then((beforeStepHookResults) => {
-                try {
-                  return runStepWithLogGroup({
-                    keyword: ensure(
-                      "keyword" in scenarioStep && scenarioStep.keyword,
-                      "Expected to find a keyword in the scenario step",
-                    ),
-                    argument,
-                    text,
-                    fn: () => {
-                      try {
-                        return registry.runStepDefinition(
-                          this,
-                          text,
-                          dryRun,
-                          argument,
-                        );
-                      } catch (e) {
-                        if (
-                          e instanceof MissingDefinitionError ||
-                          e instanceof MultipleDefinitionsError
-                        ) {
-                          (this.test as any)._retries = (
-                            this.test as any
-                          )._currentRetry;
+                return runStepWithLogGroup({
+                  keyword: ensure(
+                    "keyword" in scenarioStep && scenarioStep.keyword,
+                    "Expected to find a keyword in the scenario step",
+                  ),
+                  argument,
+                  text,
+                  fn: () => {
+                    try {
+                      return registry.runStepDefinition(
+                        this,
+                        text,
+                        dryRun,
+                        argument,
+                      );
+                    } catch (e) {
+                      if (
+                        e instanceof MissingDefinitionError ||
+                        e instanceof MultipleDefinitionsError
+                      ) {
+                        (this.test as any)._retries = (
+                          this.test as any
+                        )._currentRetry;
+                      }
+
+                      if (e instanceof MissingDefinitionError) {
+                        let parameterType: "dataTable" | "docString" | null =
+                          null;
+
+                        if (pickleStep.argument?.dataTable) {
+                          parameterType = "dataTable";
+                        } else if (pickleStep.argument?.docString) {
+                          parameterType = "docString";
                         }
+
+                        const snippets = new CucumberExpressionGenerator(
+                          () =>
+                            context.registry.parameterTypeRegistry
+                              .parameterTypes,
+                        )
+                          .generateExpressions(pickleStep.text)
+                          .map((expression) =>
+                            generateSnippet(
+                              expression,
+                              ensure(
+                                pickleStep.type,
+                                "Expected pickleStep to have a type",
+                              ),
+                              parameterType,
+                            ),
+                          );
+
+                        return taskSuggestion({
+                          id: context.newId(),
+                          pickleStepId: pickleStep.id,
+                          snippets: snippets.map((code) => {
+                            return {
+                              language: "javascript",
+                              code,
+                            };
+                          }),
+                        }).then(() => {
+                          throw new Error(
+                            createMissingStepDefinitionMessage(
+                              context,
+                              pickleStep,
+                              snippets,
+                            ),
+                          );
+                        });
+                      } else {
                         throw e;
                       }
-                    },
-                  })
-                    .then(convertReturnValueToTestStepResultStatus)
-                    .then((status) => {
-                      const testStepResult = {
-                        status,
-                        duration: duration(start, createTimestamp()),
-                      };
-
-                      return {
-                        beforeStepHookResults,
-                        testStepResult,
-                      };
-                    });
-                } catch (e) {
-                  if (e instanceof MissingDefinitionError) {
-                    throw new Error(
-                      createMissingStepDefinitionMessage(
-                        context,
-                        pickleStep,
-                        context.registry.parameterTypeRegistry,
-                      ),
-                    );
-                  } else {
-                    throw e;
-                  }
-                }
+                    }
+                  },
+                })
+                  .then(convertReturnValueToTestStepResultStatus)
+                  .then((status) => {
+                    const testStepResult = {
+                      status,
+                      duration: duration(start, createTimestamp()),
+                    };
+
+                    return {
+                      beforeStepHookResults,
+                      testStepResult,
+                    };
+                  });
               })
               .then(({ beforeStepHookResults, testStepResult }) => {
                 return afterStepHooksChain().then((afterStepHookResults) => {
@@ -1574,7 +1615,7 @@ function strictIsTextTerminal(): boolean {
 function createMissingStepDefinitionMessage(
   context: CompositionContext,
   pickleStep: messages.PickleStep,
-  parameterTypeRegistry: ParameterTypeRegistry,
+  snippets: string[],
 ) {
   const noStepDefinitionPathsTemplate = `
     Step implementation missing for "<text>".
@@ -1629,28 +1670,6 @@ function createMissingStepDefinitionMessage(
   const prettyPrintList = (items: string[]) =>
     items.map((item) => "  - " + maybeEscape(item)).join("\n");
 
-  let parameter: "dataTable" | "docString" | null = null;
-
-  if (pickleStep.argument?.dataTable) {
-    parameter = "dataTable";
-  } else if (pickleStep.argument?.docString) {
-    parameter = "docString";
-  }
-
-  const snippets = new CucumberExpressionGenerator(
-    () => parameterTypeRegistry.parameterTypes,
-  )
-    .generateExpressions(pickleStep.text)
-    .map((expression) =>
-      generateSnippet(
-        expression,
-        ensure(pickleStep.type, "Expected pickleStep to have a type"),
-        parameter,
-      ),
-    )
-    .map((snippet) => indent(snippet, { count: 2 }))
-    .join("\n\n");
-
   return stripIndent(template)
     .replaceAll("<text>", pickleStep.text)
     .replaceAll(
@@ -1665,7 +1684,10 @@ function createMissingStepDefinitionMessage(
       "<step-definition-paths>",
       prettyPrintList(stepDefinitionHints.stepDefinitionPaths),
     )
-    .replaceAll("<snippets>", snippets);
+    .replaceAll(
+      "<snippets>",
+      snippets.map((snippet) => indent(snippet, { count: 2 })).join("\n\n"),
+    );
 }
 
 function mapArgumentGroup(group: Group): messages.Group {

lib/cypress-task-definitions.ts

@@ -45,6 +45,10 @@ export const TASK_FRONTEND_TRACKING_ERROR =
 
 export type ITaskFrontendTrackingError = string;
 
+export const TASK_SUGGESTION = "cypress-cucumber-preprocessor:suggestion";
+
+export type ITaskSuggestion = messages.Suggestion;
+
 export interface ITaskCreateStringAttachment {
   data: string;
   fileName?: string;