feat: add ability to use functions as autoScreenshotStorybookGlobals

Author: KuznetsovRoman

package-lock.json

@@ -44,20 +44,20 @@
     "devDependencies": {
         "@gemini-testing/commander": "^2.15.3",
         "@types/fs-extra": "^11.0.4",
-        "@types/jest": "^27.5.2",
+        "@types/jest": "^29.5.14",
         "@types/lodash": "^4.14.172",
         "@types/node": "^12.20.19",
         "@types/npm-which": "^3.0.3",
         "@typescript-eslint/eslint-plugin": "^4.29.3",
         "@typescript-eslint/parser": "^4.29.3",
         "eslint": "^7.32.0",
         "eslint-config-gemini-testing": "^3.0.0",
-        "jest": "^27.5.1",
+        "jest": "^29.7.0",
         "jest-extended": "^0.11.5",
         "prettier": "^3.4.2",
         "rimraf": "^3.0.2",
         "testplane": "^0.1.0-rc.0",
-        "ts-jest": "^27.1.5",
+        "ts-jest": "^29.2.5",
         "typescript": "^4.3.5"
     },
     "dependencies": {

package.json

@@ -59,11 +59,11 @@ describe("storybook/story-test-runner/extend-stories", () => {
 
         const extendedStories = extendStoriesFromStoryFile(stories, { requireFn });
 
-        expect(extendedStories).toStrictEqual([
+        expect(extendedStories).toEqual([
             {
                 name: "foo",
                 absolutePath: "not/existing.js",
-                extraTests: customTests,
+                extraTests: {},
                 skip: false,
                 browserIds: ["chrome"],
                 assertViewOpts: {

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

@@ -1,4 +1,5 @@
 import TypedModule from "module";
+import { extractInheritedValue, inheritValue } from "./inheritable-values";
 import type { TestplaneMetaConfig, TestplaneStoryConfig } from "../../types";
 import type { StorybookStory, StorybookStoryExtraProperties, StorybookStoryExtended } from "./types";
 
@@ -55,19 +56,17 @@ export function extendStoriesFromStoryFile(
             extraTests: storyFile[storyName].testplane || null,
         });
 
-        story.assertViewOpts = Object.assign(
-            {},
+        story.assertViewOpts = extractInheritedValue(
+            inheritValue(storyTestplaneDefaultConfigs.assertViewOpts, storyTestlaneConfigs.assertViewOpts),
             storyExtendedBaseConfig.assertViewOpts,
-            storyTestplaneDefaultConfigs.assertViewOpts,
-            storyTestlaneConfigs.assertViewOpts,
         );
 
-        story.autoScreenshotStorybookGlobals = Object.assign(
-            {},
-            storyExtendedBaseConfig.autoScreenshotStorybookGlobals,
-            storyTestplaneDefaultConfigs.autoScreenshotStorybookGlobals,
-            storyTestlaneConfigs.autoScreenshotStorybookGlobals,
-        );
+        story.autoScreenshotStorybookGlobals =
+            inheritValue(
+                storyExtendedBaseConfig.autoScreenshotStorybookGlobals,
+                storyTestplaneDefaultConfigs.autoScreenshotStorybookGlobals,
+                storyTestlaneConfigs.autoScreenshotStorybookGlobals,
+            ) || {};
     }
 
     return withStoryFileExtendedStories;

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

@@ -5,6 +5,7 @@ import type { StoryLoadResult } from "./open-story/testplane-open-story";
 import type { TestplaneOpts } from "../story-to-test";
 import type { TestFunctionExtendedCtx } from "../../types";
 import type { StorybookStoryExtended, StorybookStory } from "./types";
+import { extractInheritedValue } from "./inheritable-values";
 
 export function getAbsoluteFilePath(): string {
     return __filename;
@@ -22,11 +23,10 @@ function createTestplaneTests(
     { autoScreenshots, autoscreenshotSelector, autoScreenshotStorybookGlobals }: TestplaneOpts,
 ): void {
     nestedDescribe(story, () => {
-        const rawAutoScreenshotGlobalSets = {
-            ...autoScreenshotStorybookGlobals,
-            ...story.autoScreenshotStorybookGlobals,
-        };
-
+        const rawAutoScreenshotGlobalSets = extractInheritedValue(
+            story.autoScreenshotStorybookGlobals,
+            autoScreenshotStorybookGlobals,
+        );
         const screenshotGlobalSetNames = Object.keys(rawAutoScreenshotGlobalSets);
 
         const autoScreenshotGlobalSets = screenshotGlobalSetNames.length

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

@@ -0,0 +1,86 @@
+import { extractInheritedValue, inheritValue } from "./inheritable-values";
+
+type TestingObject = { foo: number; bar: number; baz: number };
+type DeepObject = { foo: number; bar: { baz: number[] } };
+type InheritedFn<T> = (base: T) => T;
+
+describe("storybook/story-test-runner/inheritable-values", () => {
+    describe("inheritValue", () => {
+        it("should return overlayed value with objects", () => {
+            const firstObject = { foo: 4 } as TestingObject;
+            const secondObject = { bar: 6 } as TestingObject;
+            const thirdObject = { baz: 8 } as TestingObject;
+            const fourthObject = { bar: 10 } as TestingObject;
+
+            const inheritedValue = inheritValue(firstObject, secondObject, thirdObject, fourthObject);
+
+            expect(inheritedValue).toEqual({ foo: 4, bar: 10, baz: 8 });
+        });
+
+        it("should return overlayed value with mixed objects and functions", () => {
+            const baseObject = { foo: 4 } as TestingObject;
+            const extendObjectFn: InheritedFn<TestingObject> = baseObj => ({ ...baseObj, bar: 8 });
+
+            const inheritedValueFn = inheritValue(baseObject, extendObjectFn);
+            const inheritedValue = (inheritedValueFn as InheritedFn<TestingObject>)({} as TestingObject);
+
+            expect(inheritedValue).toEqual({ foo: 4, bar: 8 });
+        });
+
+        it("should not mutate objects", () => {
+            const firstObject = { foo: 4 } as TestingObject;
+            const secondObject = { bar: 6 } as TestingObject;
+            const thirdObject = { bar: 8 } as TestingObject;
+
+            inheritValue(firstObject, secondObject, thirdObject);
+
+            expect(firstObject).toEqual({ foo: 4 });
+            expect(secondObject).toEqual({ bar: 6 });
+            expect(thirdObject).toEqual({ bar: 8 });
+        });
+
+        it("should not mutate objects deeply even if they are mutated directly by functions", () => {
+            const baseObject = { bar: { baz: [1, 2, 3] } } as DeepObject;
+            const mutateFn: InheritedFn<DeepObject> = baseObj => {
+                baseObj.foo = 4;
+                baseObj.bar.baz[1] = 100500;
+
+                return baseObj;
+            };
+
+            const inheritedValueFn = inheritValue(baseObject, mutateFn);
+            const inheritedValue = (inheritedValueFn as InheritedFn<DeepObject>)({} as DeepObject);
+
+            expect(inheritedValue).toEqual({ foo: 4, bar: { baz: [1, 100500, 3] } });
+            expect(baseObject).toEqual({ bar: { baz: [1, 2, 3] } });
+        });
+    });
+
+    describe("extractInheritedValue", () => {
+        it("should extract inherited value", () => {
+            const baseValue = { foo: 4 } as TestingObject;
+            const overlayedValue = { bar: 6 } as TestingObject;
+
+            const inheritedValue = inheritValue(baseValue, overlayedValue);
+            const resultValue = extractInheritedValue(inheritedValue, { foo: 8, baz: 10 } as TestingObject);
+
+            expect(resultValue).toEqual({ foo: 4, bar: 6, baz: 10 });
+        });
+
+        it("should extract inherited function", () => {
+            const initialValue = { foo: 100, baz: 10 } as TestingObject;
+            const baseValue = { foo: 4 } as TestingObject;
+            const mutateFn: InheritedFn<TestingObject> = baseObj => {
+                baseObj.foo *= 2;
+                baseObj.baz *= 2;
+
+                return baseObj;
+            };
+
+            const inheritedValue = inheritValue(baseValue, mutateFn);
+            const resultValue = extractInheritedValue(inheritedValue, initialValue);
+
+            expect(resultValue).toEqual({ foo: 8, baz: 20 });
+        });
+    });
+});

src/storybook/story-test-runner/inheritable-values.test.ts

@@ -0,0 +1,46 @@
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Inheritable<T extends Record<any, any>> = T | ((baseValue: T) => T);
+
+// Acts like "Object.assign", but:
+// - Does not mutate arguments
+// - Supports functions (previousValue) => nextValue
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function inheritValue<T extends Record<any, any>>(
+    ...values: Array<undefined | Inheritable<T>>
+): undefined | Inheritable<T> {
+    let resultValue = values[0];
+
+    for (let i = 1; i < values.length; i++) {
+        const prevValue = resultValue;
+        const curValue = values[i];
+
+        if (!curValue) {
+            continue;
+        }
+
+        if (!resultValue) {
+            resultValue = curValue;
+        }
+
+        if (typeof prevValue !== "function" && typeof curValue !== "function") {
+            resultValue = Object.assign({}, prevValue, curValue);
+        } else if (typeof prevValue === "function" && typeof curValue === "function") {
+            resultValue = (baseValue: T) => curValue(prevValue(structuredClone(baseValue)));
+        } else if (typeof prevValue === "function" && typeof curValue !== "function") {
+            resultValue = (baseValue: T) => Object.assign({}, prevValue(structuredClone(baseValue)), curValue);
+        } else if (typeof prevValue !== "function" && typeof curValue === "function") {
+            resultValue = (baseValue: T) => curValue(structuredClone(Object.assign({}, baseValue, prevValue)));
+        }
+    }
+
+    return resultValue;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function extractInheritedValue<T extends Record<any, any>>(value: undefined | Inheritable<T>, baseValue: T): T {
+    if (!value) {
+        return baseValue;
+    }
+
+    return typeof value === "function" ? value(baseValue) : structuredClone(Object.assign({}, baseValue, value));
+}

src/storybook/story-test-runner/inheritable-values.ts

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

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

@@ -1,4 +1,6 @@
 import type { AssertViewOpts } from "testplane";
+import type { AutoScreenshotStorybookGlobals } from "./storybook/story-test-runner/types";
+import type { Inheritable } from "./storybook/story-test-runner/inheritable-values";
 
 export type TestFunctionExtendedCtx = TestFunctionCtx & { expect: ExpectWebdriverIO.Expect };
 
@@ -15,11 +17,11 @@ type Combined<N, B = void> = B extends void ? N : N & B;
 
 type TestplaneStoryFileConfig = {
     skip?: boolean;
-    assertViewOpts?: AssertViewOpts;
+    assertViewOpts?: Inheritable<AssertViewOpts>;
     browserIds?: Array<string | RegExp>;
     autoScreenshots?: boolean;
     autoscreenshotSelector?: string;
-    autoScreenshotStorybookGlobals?: Record<string, Record<string, unknown>>;
+    autoScreenshotStorybookGlobals?: Inheritable<AutoScreenshotStorybookGlobals>;
 };
 
 export type TestplaneMetaConfig<T = void> = Combined<