feat: add ability to override testplane storyfile configs

Author: KuznetsovRoman

src/storybook/story-test-runner/extend-stories.test.ts

@@ -2,28 +2,88 @@ import { extendStoriesFromStoryFile } from "./extend-stories";
 import { StorybookStory } from "./types";
 
 describe("storybook/story-test-runner/extend-stories", () => {
-    it("should log warning failed storyfile import", async () => {
+    const mkRequireStub_ = (
+        impl?: Parameters<typeof jest["fn"]>[0],
+    ): jest.MockedFunction<typeof globalThis["require"]> => {
+        return jest.fn(impl) as unknown as jest.MockedFunction<typeof globalThis["require"]>;
+    };
+
+    it("should log warning failed storyfile import", () => {
         jest.spyOn(console, "warn").mockImplementation(jest.fn);
+        const requireFn = mkRequireStub_(() => {
+            throw new Error("some error message");
+        });
         const stories = [{ name: "foo", absolutePath: "not/existing.ts" }] as StorybookStory[];
 
-        extendStoriesFromStoryFile(stories);
+        extendStoriesFromStoryFile(stories, { requireFn });
 
         const expectedMsg = [
             '"testplane" section is ignored in storyfile "not/existing.ts", because the file could not be read:',
-            "Error: Cannot find module 'not/existing.ts' from 'src/storybook/story-test-runner/extend-stories.ts' ",
+            "Error: some error message ",
             "There could be other story files. ",
             "Set 'TESTPLANE_STORYBOOK_DISABLE_STORY_REQUIRE_WARNING' environment variable to hide this warning",
         ].join("\n");
         expect(console.warn).toBeCalledWith(expectedMsg);
     });
 
-    it("should fallback, when could not read story file", async () => {
+    it("should fallback, when could not read story file", () => {
+        const requireFn = mkRequireStub_(() => {
+            throw new Error("file does not exist");
+        });
         const stories = [{ name: "foo", absolutePath: "not/existing.js" }] as StorybookStory[];
 
-        const extendedStories = extendStoriesFromStoryFile(stories);
+        const extendedStories = extendStoriesFromStoryFile(stories, { requireFn });
 
         expect(extendedStories[0].skip).toBe(false);
         expect(extendedStories[0].assertViewOpts).toEqual({});
         expect(extendedStories[0].browserIds).toBe(null);
     });
+
+    it("should overlay story configs / file confifs / default configs", () => {
+        const customTests = {};
+        const defaultExport = {
+            testplane: { browserIds: ["firefox"] },
+            testplaneConfig: {
+                skip: true,
+                browserIds: ["chrome"],
+                assertViewOpts: { tolerance: 10, ignoreDiffPixelCount: 10 },
+                autoScreenshotStorybookGlobals: { dark: { theme: "dark" } },
+            },
+        };
+        const fooExport = {
+            testplane: customTests,
+            testplaneConfig: { skip: false, autoScreenshots: false, assertViewOpts: { ignoreElements: ["foobar"] } },
+        };
+        const requireFn = mkRequireStub_().mockReturnValue({ default: defaultExport, foo: fooExport });
+        const stories = [{ name: "foo", absolutePath: "not/existing.js" }] as StorybookStory[];
+
+        const extendedStories = extendStoriesFromStoryFile(stories, { requireFn });
+
+        expect(extendedStories).toStrictEqual([
+            {
+                name: "foo",
+                absolutePath: "not/existing.js",
+                extraTests: customTests,
+                skip: false,
+                browserIds: ["chrome"],
+                assertViewOpts: {
+                    ignoreElements: ["foobar"],
+                    tolerance: 10,
+                    ignoreDiffPixelCount: 10,
+                },
+                autoScreenshots: false,
+                autoscreenshotSelector: null,
+                autoScreenshotStorybookGlobals: { dark: { theme: "dark" } },
+            },
+        ]);
+    });
+
+    it("should fallback reading story configs from deprecated testplane property", () => {
+        const stories = [{ name: "foo", absolutePath: "not/existing.js" }] as StorybookStory[];
+        const requireFn = mkRequireStub_().mockReturnValue({ default: { testplane: { skip: true } }, foo: {} });
+
+        const extendedStories = extendStoriesFromStoryFile(stories, { requireFn });
+
+        expect(extendedStories).toMatchObject([{ name: "foo", skip: true }]);
+    });
 });

src/storybook/story-test-runner/extend-stories.ts

@@ -1,6 +1,6 @@
 import TypedModule from "module";
 import type { TestplaneMetaConfig, TestplaneStoryConfig } from "../../types";
-import type { StorybookStory, StorybookStoryExtended } from "./types";
+import type { StorybookStory, StorybookStoryExtraProperties, StorybookStoryExtended } from "./types";
 
 const Module = TypedModule as any; // eslint-disable-line @typescript-eslint/no-explicit-any
 
@@ -12,45 +12,62 @@ type StoryFile = { default: TestplaneMetaConfig } & Record<string, TestplaneStor
 
 let loggedStoryFileRequireError = Boolean(process.env.TESTPLANE_STORYBOOK_DISABLE_STORY_REQUIRE_WARNING);
 
-export function extendStoriesFromStoryFile(stories: StorybookStory[]): StorybookStoryExtended[] {
+export function extendStoriesFromStoryFile(
+    stories: StorybookStory[],
+    { requireFn = require } = {},
+): StorybookStoryExtended[] {
     const storiesMap = getStoriesMap(stories);
     const storyPath = stories[0].absolutePath;
-    const storyFile = getStoryFile(storyPath);
+    const storyFile = getStoryFile(storyPath, { requireFn });
     const withStoryFileExtendedStories = stories as StorybookStoryExtended[];
 
-    if (!storyFile) {
-        return withStoryFileExtendedStories.map(story => {
-            story.skip = false;
-            story.assertViewOpts = {};
-            story.browserIds = null;
-            story.autoScreenshotStorybookGlobals = {};
+    const storyExtendedBaseConfig = {
+        skip: false,
+        browserIds: null,
+        assertViewOpts: {},
+        autoScreenshots: null,
+        autoscreenshotSelector: null,
+        autoScreenshotStorybookGlobals: {},
+        extraTests: null,
+    } satisfies StorybookStoryExtraProperties;
 
-            return story;
-        });
+    if (!storyFile) {
+        return withStoryFileExtendedStories.map(story => Object.assign(story, storyExtendedBaseConfig));
     }
 
-    for (const storyName in storyFile) {
+    const storyTestplaneDefaultConfigs = storyFile.default?.testplaneConfig || storyFile.default?.testplane || {};
+
+    for (const storyName of Object.keys(storyFile)) {
         if (storyName === "default") {
-            withStoryFileExtendedStories.forEach(story => {
-                const testplaneStoryOpts = storyFile[storyName].testplane || {};
+            continue;
+        }
 
-                story.skip = testplaneStoryOpts.skip || false;
-                story.assertViewOpts = testplaneStoryOpts.assertViewOpts || {};
-                story.browserIds = testplaneStoryOpts.browserIds || null;
-                story.autoscreenshotSelector = testplaneStoryOpts.autoscreenshotSelector || null;
-                story.autoScreenshotStorybookGlobals = testplaneStoryOpts.autoScreenshotStorybookGlobals || {};
-            });
+        const storyMapKey = getStoryNameId(storyName);
 
+        if (!storiesMap.has(storyMapKey)) {
             continue;
         }
 
-        const storyMapKey = getStoryNameId(storyName);
+        const storyTestlaneConfigs = storyFile[storyName].testplaneConfig || {};
+        const story = storiesMap.get(storyMapKey) as StorybookStoryExtended;
 
-        if (storiesMap.has(storyMapKey) && storyFile[storyName].testplane) {
-            const story = storiesMap.get(storyMapKey) as StorybookStoryExtended;
+        Object.assign(story, storyExtendedBaseConfig, storyTestplaneDefaultConfigs, storyTestlaneConfigs, {
+            extraTests: storyFile[storyName].testplane || null,
+        });
 
-            story.extraTests = storyFile[storyName].testplane;
-        }
+        story.assertViewOpts = Object.assign(
+            {},
+            storyExtendedBaseConfig.assertViewOpts,
+            storyTestplaneDefaultConfigs.assertViewOpts,
+            storyTestlaneConfigs.assertViewOpts,
+        );
+
+        story.autoScreenshotStorybookGlobals = Object.assign(
+            {},
+            storyExtendedBaseConfig.autoScreenshotStorybookGlobals,
+            storyTestplaneDefaultConfigs.autoScreenshotStorybookGlobals,
+            storyTestlaneConfigs.autoScreenshotStorybookGlobals,
+        );
     }
 
     return withStoryFileExtendedStories;
@@ -74,13 +91,13 @@ function getStoryNameId(storyName: string): string {
     return storyName.replace(nonAsciiWordRegExp, "").toLowerCase();
 }
 
-function getStoryFile(storyPath: string): StoryFile | null {
+function getStoryFile(storyPath: string, { requireFn = require } = {}): StoryFile | null {
     const unmockFn = mockLoaders({ except: storyPath });
 
     let storyFile;
 
     try {
-        storyFile = require(storyPath); // eslint-disable-line @typescript-eslint/no-var-requires
+        storyFile = requireFn(storyPath);
     } catch (error) {
         if (!loggedStoryFileRequireError) {
             loggedStoryFileRequireError = true;

src/storybook/story-test-runner/index.ts

@@ -10,6 +10,7 @@ export function getAbsoluteFilePath(): string {
     return __filename;
 }
 
+// Those stories must be from a single story file
 export function run(stories: StorybookStory[], opts: TestplaneOpts): void {
     const withStoryFileDataStories = extendStoriesFromStoryFile(stories);
 
@@ -32,7 +33,7 @@ function createTestplaneTests(
             ? screenshotGlobalSetNames.map(name => ({ name, globals: rawAutoScreenshotGlobalSets[name] }))
             : [{ name: "", globals: {} }];
 
-        if (autoScreenshots) {
+        if (story.autoScreenshots ?? autoScreenshots) {
             for (const { name, globals } of autoScreenshotGlobalSets) {
                 extendedIt(
                     story,

src/storybook/story-test-runner/types.ts

@@ -2,15 +2,18 @@ import type { AssertViewOpts } from "testplane";
 import type { TestplaneTestFunction } from "../../types";
 import type { StorybookStoryExtended as StorybookStory } from "../get-stories";
 
-export interface StorybookStoryExtended extends StorybookStory {
+export interface StorybookStoryExtraProperties {
     skip: boolean;
     assertViewOpts: AssertViewOpts;
     browserIds: Array<string | RegExp> | null;
-    extraTests?: Record<string, TestplaneTestFunction>;
+    extraTests: Record<string, TestplaneTestFunction> | null;
+    autoScreenshots: boolean | null;
     autoscreenshotSelector: string | null;
     autoScreenshotStorybookGlobals: Record<string, Record<string, unknown>>;
 }
 
+export interface StorybookStoryExtended extends StorybookStory, StorybookStoryExtraProperties {}
+
 export type ExecutionContextExtended = WebdriverIO.Browser["executionContext"] & {
     "@testplane/storybook-assertView-opts": AssertViewOpts;
 };

src/types.ts

@@ -11,23 +11,34 @@ interface StorybookMetaConfig {
     component?: unknown;
 }
 
-interface CustomField<K> {
-    testplane?: K;
-}
-
 type Combined<N, B = void> = B extends void ? N : N & B;
 
+type TestplaneStoryFileConfig = {
+    skip?: boolean;
+    assertViewOpts?: AssertViewOpts;
+    browserIds?: Array<string | RegExp>;
+    autoScreenshots?: boolean;
+    autoscreenshotSelector?: string;
+    autoScreenshotStorybookGlobals?: Record<string, Record<string, unknown>>;
+};
+
 export type TestplaneMetaConfig<T = void> = Combined<
-    CustomField<{
-        skip?: boolean;
-        assertViewOpts?: AssertViewOpts;
-        browserIds?: Array<string | RegExp>;
-        autoscreenshotSelector?: string;
-        autoScreenshotStorybookGlobals?: Record<string, Record<string, unknown>>;
-    }>,
+    {
+        /**
+         * @deprecated Use "testplaneConfig" instead of "testplane"
+         */
+        testplane?: TestplaneStoryFileConfig;
+        testplaneConfig?: TestplaneStoryFileConfig;
+    },
     T
 >;
 
-export type TestplaneStoryConfig<T = void> = Combined<CustomField<Record<string, TestplaneTestFunction>>, T>;
+export type TestplaneStoryConfig<T = void> = Combined<
+    {
+        testplane?: Record<string, TestplaneTestFunction>;
+        testplaneConfig?: TestplaneStoryFileConfig;
+    },
+    T
+>;
 
 export type WithTestplane<T = void> = T extends StorybookMetaConfig ? TestplaneMetaConfig<T> : TestplaneStoryConfig<T>;