Propagate preprocessor config to all event handlers

Currently, if one event handler needed implicitIntegrationFolder, they
wouldn't necessarily be able to, as a lacking configuration might
already have been cached by memoization.

Author: badeball

lib/add-cucumber-preprocessor-plugin.ts

@@ -1,9 +1,11 @@
 import fs from "node:fs";
+import path from "node:path";
 import { inspect } from "node:util";
 
 import { generateMessages } from "@cucumber/gherkin";
 import { IdGenerator, SourceMediaType } from "@cucumber/messages";
 import parse from "@cucumber/tag-expressions";
+import { commonAncestorPath as ancestor } from "common-ancestor-path";
 import { getSpecs } from "find-cypress-specs";
 import { v4 as uuid } from "uuid";
 
@@ -20,10 +22,9 @@ import {
   TASK_TEST_STEP_FINISHED,
   TASK_TEST_STEP_STARTED,
 } from "./cypress-task-definitions";
-import { assertNever } from "./helpers/assertions";
+import { assertNever, ensure } from "./helpers/assertions";
 import debug from "./helpers/debug";
 import { getTags } from "./helpers/environment";
-import { memoize } from "./helpers/memoize";
 import { notNull } from "./helpers/type-guards";
 import {
   afterRunHandler,
@@ -43,9 +44,7 @@ import {
   testStepFinishedHandler,
   testStepStartedHandler,
 } from "./plugin-event-handlers";
-import { resolve as origResolve } from "./preprocessor-configuration";
-
-const resolve = memoize(origResolve);
+import { resolve } from "./preprocessor-configuration";
 
 export type AddOptions = {
   omitBeforeRunHandler?: boolean;
@@ -86,56 +85,93 @@ export async function addCucumberPreprocessorPlugin(
 ) {
   config.env[INTERNAL_SUITE_PROPERTIES] = { isEventHandlersAttached: true };
 
-  const preprocessor = await resolve(config, config.env, "/");
+  const specs = getSpecs(config, "foobar" as any, true);
+
+  const implicitIntegrationFolder = ensure(
+    ancestor(...specs.map(path.dirname).map(path.normalize)),
+    "Expected to find a common ancestor path",
+  );
+
+  const preprocessor = await resolve(
+    config,
+    config.env,
+    implicitIntegrationFolder,
+  );
 
   if (!options.omitBeforeRunHandler) {
-    on("before:run", () => beforeRunHandler(config));
+    on("before:run", () => beforeRunHandler(config, preprocessor));
   }
 
   if (!options.omitAfterRunHandler) {
-    on("after:run", (results) => afterRunHandler(config, results));
+    on("after:run", (results) =>
+      afterRunHandler(config, preprocessor, results),
+    );
   }
 
   if (!options.omitBeforeSpecHandler) {
-    on("before:spec", (spec) => beforeSpecHandler(config, spec));
+    on("before:spec", (spec) => beforeSpecHandler(config, preprocessor, spec));
   }
 
   if (!options.omitAfterSpecHandler) {
     on("after:spec", (spec, results) =>
-      afterSpecHandler(config, spec, results),
+      afterSpecHandler(config, preprocessor, spec, results),
     );
   }
 
   if (!options.omitAfterScreenshotHandler) {
     on("after:screenshot", (details) =>
-      afterScreenshotHandler(config, details),
+      afterScreenshotHandler(config, preprocessor, details),
     );
   }
 
   on("task", {
-    [TASK_SPEC_ENVELOPES]: specEnvelopesHandler.bind(null, config),
-    [TASK_TEST_CASE_STARTED]: testCaseStartedHandler.bind(null, config),
-    [TASK_TEST_STEP_STARTED]: testStepStartedHandler.bind(null, config),
+    [TASK_SPEC_ENVELOPES]: specEnvelopesHandler.bind(
+      null,
+      config,
+      preprocessor,
+    ),
+    [TASK_TEST_CASE_STARTED]: testCaseStartedHandler.bind(
+      null,
+      config,
+      preprocessor,
+    ),
+    [TASK_TEST_STEP_STARTED]: testStepStartedHandler.bind(
+      null,
+      config,
+      preprocessor,
+    ),
     [TASK_TEST_STEP_FINISHED]: testStepFinishedHandler.bind(
       null,
       config,
+      preprocessor,
       options,
     ),
-    [TASK_TEST_RUN_HOOK_STARTED]: testRunHookStartedHandler.bind(null, config),
+    [TASK_TEST_RUN_HOOK_STARTED]: testRunHookStartedHandler.bind(
+      null,
+      config,
+      preprocessor,
+    ),
     [TASK_TEST_RUN_HOOK_FINISHED]: testRunHookFinishedHandler.bind(
       null,
       config,
+      preprocessor,
+    ),
+    [TASK_TEST_CASE_FINISHED]: testCaseFinishedHandler.bind(
+      null,
+      config,
+      preprocessor,
     ),
-    [TASK_TEST_CASE_FINISHED]: testCaseFinishedHandler.bind(null, config),
     [TASK_CREATE_STRING_ATTACHMENT]: createStringAttachmentHandler.bind(
       null,
       config,
+      preprocessor,
     ),
     [TASK_FRONTEND_TRACKING_ERROR]: frontendTrackingErrorHandler.bind(
       null,
       config,
+      preprocessor,
     ),
-    [TASK_SUGGESTION]: suggestion.bind(null, config),
+    [TASK_SUGGESTION]: suggestion.bind(null, config, preprocessor),
   });
 
   const tags = getTags(config.env);
@@ -145,48 +181,46 @@ export async function addCucumberPreprocessorPlugin(
 
     const node = parse(tags);
 
-    const testFiles = getSpecs(config, "foobar" as any, true).filter(
-      (testFile) => {
-        if (!testFile.endsWith(".feature")) {
-          switch (preprocessor.filterSpecsMixedMode) {
-            case "hide":
-              return false;
-            case "show":
-              return true;
-            case "empty-set":
-              return node.evaluate([]);
-            default:
-              assertNever(preprocessor.filterSpecsMixedMode);
-          }
+    const testFiles = specs.filter((testFile) => {
+      if (!testFile.endsWith(".feature")) {
+        switch (preprocessor.filterSpecsMixedMode) {
+          case "hide":
+            return false;
+          case "show":
+            return true;
+          case "empty-set":
+            return node.evaluate([]);
+          default:
+            assertNever(preprocessor.filterSpecsMixedMode);
         }
-
-        const content = fs.readFileSync(testFile).toString("utf-8");
-
-        const options = {
-          includeSource: false,
-          includeGherkinDocument: false,
-          includePickles: true,
-          newId: IdGenerator.incrementing(),
-        };
-
-        const envelopes = generateMessages(
-          content,
-          testFile,
-          SourceMediaType.TEXT_X_CUCUMBER_GHERKIN_PLAIN,
-          options,
-        );
-
-        const pickles = envelopes
-          .map((envelope) => envelope.pickle)
-          .filter(notNull);
-
-        return pickles.some((pickle) =>
-          node.evaluate(
-            pickle.tags?.map((tag) => tag.name).filter(notNull) ?? [],
-          ),
-        );
-      },
-    );
+      }
+
+      const content = fs.readFileSync(testFile).toString("utf-8");
+
+      const options = {
+        includeSource: false,
+        includeGherkinDocument: false,
+        includePickles: true,
+        newId: IdGenerator.incrementing(),
+      };
+
+      const envelopes = generateMessages(
+        content,
+        testFile,
+        SourceMediaType.TEXT_X_CUCUMBER_GHERKIN_PLAIN,
+        options,
+      );
+
+      const pickles = envelopes
+        .map((envelope) => envelope.pickle)
+        .filter(notNull);
+
+      return pickles.some((pickle) =>
+        node.evaluate(
+          pickle.tags?.map((tag) => tag.name).filter(notNull) ?? [],
+        ),
+      );
+    });
 
     debug(`Resolved specs ${inspect(testFiles)}`);