testeranto 0.189.0 → 0.198.0

package/dist/module/src/lib/BaseThen.js

@@ -0,0 +1,60 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { butThenProxy } from "./pmProxy.js";
+export class BaseThen {
+    constructor(name, thenCB) {
+        this.artifacts = [];
+        this.name = name;
+        this.thenCB = thenCB;
+        this.error = false;
+        this.artifacts = [];
+    }
+    addArtifact(path) {
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
+    }
+    toObj() {
+        const obj = {
+            name: this.name,
+            error: this.error,
+            artifacts: this.artifacts,
+        };
+        return obj;
+    }
+    async test(store, testResourceConfiguration, tLog, pm, filepath) {
+        // Ensure addArtifact is properly bound to 'this'
+        const addArtifact = this.addArtifact.bind(this);
+        const proxiedPm = butThenProxy(pm, filepath, addArtifact);
+        return this.butThen(store, async (s) => {
+            try {
+                if (typeof this.thenCB === "function") {
+                    // Add debug logging to see what's being passed to thenCB
+                    // Check if the thenCB is spreading the arguments incorrectly
+                    // Wrap the proxy to see what's happening when writeFileSync is called
+                    const wrappedPm = new Proxy(proxiedPm, {
+                        get: (target, prop, receiver) => {
+                            if (prop === "writeFileSync") {
+                                return (...args) => {
+                                    console.log(`[DEBUG] writeFileSync called with args:`, args);
+                                    return target[prop](...args);
+                                };
+                            }
+                            return target[prop];
+                        },
+                    });
+                    const result = await this.thenCB(s, wrappedPm);
+                    return result;
+                }
+                else {
+                    return this.thenCB;
+                }
+            }
+            catch (e) {
+                console.error(e.stack);
+            }
+        }, testResourceConfiguration, proxiedPm).catch((e) => {
+            this.error = e.stack;
+            // throw e;
+        });
+    }
+}

package/dist/module/src/lib/BaseWhen.js

@@ -0,0 +1,41 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { andWhenProxy } from "./pmProxy.js";
+export class BaseWhen {
+    addArtifact(path) {
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
+    }
+    constructor(name, whenCB) {
+        this.artifacts = [];
+        this.name = name;
+        this.whenCB = whenCB;
+    }
+    toObj() {
+        const obj = {
+            name: this.name,
+            error: this.error
+                ? `${this.error.name}: ${this.error.message}\n${this.error.stack}`
+                : null,
+            artifacts: this.artifacts || [],
+        };
+        console.log(`[TOOBJ] Serializing ${this.constructor.name} with artifacts:`, obj.artifacts);
+        return obj;
+    }
+    async test(store, testResourceConfiguration, tLog, pm, filepath) {
+        try {
+            // tLog(" When:", this.name);
+            // Ensure addArtifact is properly bound to 'this'
+            const addArtifact = this.addArtifact.bind(this);
+            const proxiedPm = andWhenProxy(pm, filepath, addArtifact);
+            // (proxiedPm as any).currentStep = this;
+            const result = await this.andWhen(store, this.whenCB, testResourceConfiguration, proxiedPm);
+            return result;
+        }
+        catch (e) {
+            console.error("[ERROR] When step failed:", this.name.toString(), e.toString());
+            this.error = e;
+            throw e;
+        }
+    }
+}

package/dist/module/src/lib/Tiposkripto.js

@@ -0,0 +1,146 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { defaultTestResourceRequirement, DefaultAdapter, } from "./index.js";
+import { BaseGiven } from "./BaseGiven";
+import { BaseWhen } from "./BaseWhen.js";
+import { BaseThen } from "./BaseThen.js";
+import { BaseSuite } from "./BaseSuite";
+export default class Tiposkripto {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testAdapter = {}, uberCatcher = (cb) => cb()) {
+        this.artifacts = [];
+        const fullAdapter = DefaultAdapter(testAdapter);
+        // Create classy implementations
+        const classySuites = Object.entries(testImplementation.suites).reduce((a, [key], index) => {
+            a[key] = (somestring, givens) => {
+                return new (class extends BaseSuite {
+                    afterAll(store, artifactory, pm) {
+                        return fullAdapter.afterAll(store, pm);
+                    }
+                    assertThat(t) {
+                        return fullAdapter.assertThis(t);
+                    }
+                    async setup(s, artifactory, tr, pm) {
+                        var _a, _b;
+                        return ((_b = (_a = fullAdapter.beforeAll) === null || _a === void 0 ? void 0 : _a.call(fullAdapter, s, tr, pm)) !== null && _b !== void 0 ? _b : s);
+                    }
+                })(somestring, index, givens);
+            };
+            return a;
+        }, {});
+        const classyGivens = Object.entries(testImplementation.givens).reduce((a, [key, g]) => {
+            a[key] = (name, features, whens, thens, gcb, initialValues) => {
+                return new (class extends BaseGiven {
+                    constructor() {
+                        super(...arguments);
+                        this.uberCatcher = uberCatcher;
+                    }
+                    async givenThat(subject, testResource, artifactory, initializer, initialValues, pm) {
+                        return fullAdapter.beforeEach(subject, initializer, testResource, initialValues, pm);
+                    }
+                    afterEach(store, key, artifactory, pm) {
+                        return Promise.resolve(fullAdapter.afterEach(store, key, pm));
+                    }
+                })(name, features, whens, thens, testImplementation.givens[key], initialValues);
+            };
+            return a;
+        }, {});
+        const classyWhens = Object.entries(testImplementation.whens).reduce((a, [key, whEn]) => {
+            a[key] = (...payload) => {
+                return new (class extends BaseWhen {
+                    async andWhen(store, whenCB, testResource, pm) {
+                        return await fullAdapter.andWhen(store, whenCB, testResource, pm);
+                    }
+                })(`${key}: ${payload && payload.toString()}`, whEn(...payload));
+            };
+            return a;
+        }, {});
+        const classyThens = Object.entries(testImplementation.thens).reduce((a, [key, thEn]) => {
+            a[key] = (...args) => {
+                return new (class extends BaseThen {
+                    async butThen(store, thenCB, testResource, pm) {
+                        return await fullAdapter.butThen(store, thenCB, testResource, pm);
+                    }
+                })(`${key}: ${args && args.toString()}`, thEn(...args));
+            };
+            return a;
+        }, {});
+        // Set up the overrides
+        this.suitesOverrides = classySuites;
+        this.givenOverides = classyGivens;
+        this.whenOverides = classyWhens;
+        this.thenOverides = classyThens;
+        this.testResourceRequirement = testResourceRequirement;
+        this.testSpecification = testSpecification;
+        // Generate specs
+        this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then());
+        // Create test jobs
+        this.testJobs = this.specs.map((suite) => {
+            const suiteRunner = (suite) => async (puppetMaster, tLog) => {
+                try {
+                    const x = await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
+                        this.artifacts.push(p);
+                    })(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value), tLog, puppetMaster);
+                    return x;
+                }
+                catch (e) {
+                    console.error(e.stack);
+                    throw e;
+                }
+            };
+            const runner = suiteRunner(suite);
+            return {
+                test: suite,
+                toObj: () => {
+                    return suite.toObj();
+                },
+                runner,
+                receiveTestResourceConfig: async function (puppetMaster) {
+                    const tLog = async (...l) => {
+                        //
+                    };
+                    try {
+                        const suiteDone = await runner(puppetMaster, tLog);
+                        const fails = suiteDone.fails;
+                        await puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2), "test");
+                        return {
+                            failed: fails > 0,
+                            fails,
+                            artifacts: this.artifacts || [],
+                            features: suiteDone.features(),
+                        };
+                    }
+                    catch (e) {
+                        console.error(e.stack);
+                        return {
+                            failed: true,
+                            fails: -1,
+                            artifacts: this.artifacts || [],
+                            features: [],
+                        };
+                    }
+                },
+            };
+        });
+    }
+    Specs() {
+        return this.specs;
+    }
+    Suites() {
+        return this.suitesOverrides;
+    }
+    Given() {
+        return this.givenOverides;
+    }
+    When() {
+        return this.whenOverides;
+    }
+    Then() {
+        return this.thenOverides;
+    }
+    // Add a method to access test jobs which can be used by receiveTestResourceConfig
+    getTestJobs() {
+        return this.testJobs;
+    }
+}

package/dist/module/src/lib/{core.test/MockCore.js → Tiposkripto.test/MockTiposkripto.js}

@@ -1,10 +1,10 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import TesterantoCore from "../core";
+import Tiposkripto from "../Tiposkripto";
 /**
- * Concrete implementation of Testeranto for testing purposes
+ * Concrete implementation of Tiposkripto for testing purposes
  */
-export class MockCore extends TesterantoCore {
+export class MockTiposkripto extends Tiposkripto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: [] }, testAdapter, uberCatcher = (cb) => cb()) {
         // Validate required implementation methods
         const requiredMethods = ["suites", "givens", "whens", "thens"];
@@ -13,8 +13,6 @@ export class MockCore extends TesterantoCore {
                 throw new Error(`Missing required implementation method: ${method}`);
             }
         });
-        // this.testResourceRequirement = testResourceRequirement;
-        // this.testAdapter = testAdapter;
         super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, uberCatcher);
         this.specs = [];
         this.testJobs = [];
@@ -25,7 +23,6 @@ export class MockCore extends TesterantoCore {
             failed: false,
             fails: 0,
             artifacts: [],
-            // logPromise: Promise.resolve(),
             features: [],
         };
     }

package/dist/module/src/lib/{core.test/core.test.adapter.js → Tiposkripto.test/Tiposkripto.adapter.js}

@@ -1,5 +1,8 @@
-import { MockCore } from "./MockCore";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { MockTiposkripto } from "./MockTiposkripto";
 export const testAdapter = {
+    beforeAll: async (input, testResource, pm) => input,
     beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
         var _a;
         try {
@@ -7,8 +10,8 @@ export const testAdapter = {
             if (!result) {
                 throw new Error("Initializer returned undefined");
             }
-            if (!(result instanceof MockCore)) {
-                throw new Error(`Initializer returned ${(_a = result === null || result === void 0 ? void 0 : result.constructor) === null || _a === void 0 ? void 0 : _a.name}, expected MockCore`);
+            if (!(result instanceof MockTiposkripto)) {
+                throw new Error(`Initializer returned ${(_a = result === null || result === void 0 ? void 0 : result.constructor) === null || _a === void 0 ? void 0 : _a.name}, expected MockTiposkripto`);
             }
             return result;
         }
@@ -17,14 +20,13 @@ export const testAdapter = {
             throw e;
         }
     },
-    andWhen: async (store, whenCB, testResource, pm) => {
-        return whenCB(store, pm);
+    andWhen: async (store, whenCB, testResource, utils) => {
+        return whenCB(store, utils);
     },
     butThen: async (store, thenCB, testResource, pm) => {
         return thenCB(store, pm);
     },
     afterEach: (store) => store,
-    afterAll: (store, pm) => { },
-    assertThis: (result) => !!result,
-    beforeAll: async (input, testResource, pm) => input,
+    afterAll: () => { },
+    assertThis: (x) => !!x,
 };

package/dist/module/src/lib/{classBuilder.test/classBuilder.test.implementation.js → Tiposkripto.test/Tiposkripto.implementation.js}

@@ -1,59 +1,42 @@
-import mock from "./mock";
-import { specification } from "./classBuilder.test.specification";
-import { MockSuite } from "../BaseSuite.test/mock";
+import { MockTiposkripto } from "./MockTiposkripto";
+import { specification } from "./Tiposkripto.specification";
+import { testAdapter } from "./Tiposkripto.adapter";
 export const implementation = {
     suites: {
-        Default: "ClassBuilder test suite",
-        ExtendedSuite: "Extended ClassBuilder test suite",
+        Default: "Tiposkripto test suite",
+        ExtendedSuite: "Extended Tiposkripto test suite",
     },
     givens: {
         Default: () => {
             console.log("Creating default test builder instance");
-            const builder = new mock(implementation, // Use the current implementation
-            specification, // Use the current specification
-            {}, // Default input
-            MockSuite, class {
-            }, // givenKlasser
-            class {
-            }, // whenKlasser
-            class {
-            }, // thenKlasser
-            { ports: [] } // Default resource requirements
-            );
+            // Use a function to defer the implementation reference
+            const createBuilder = (impl) => {
+                return new MockTiposkripto({}, // input
+                specification, // Use the current specification
+                impl, // Use the passed implementation
+                { ports: [] }, // Default resource requirements
+                testAdapter, // Default adapter
+                (cb) => cb() // Default uberCatcher
+                );
+            };
+            const builder = createBuilder(implementation);
             console.log("Builder created:", builder);
             return builder;
         },
         WithCustomInput: (input) => {
-            return new mock(implementation, specification, input, class {
-            }, class {
-            }, class {
-            }, class {
-            }, class {
-            }, { ports: [] });
+            return new MockTiposkripto(input, specification, implementation, { ports: [] }, testAdapter, (cb) => cb());
         },
         WithResourceRequirements: (requirements) => {
-            return new mock(implementation, specification, {}, class {
-            }, class {
-            }, class {
-            }, class {
-            }, class {
-            }, requirements);
+            return new MockTiposkripto({}, specification, implementation, requirements, testAdapter, (cb) => cb());
         },
         WithCustomImplementation: (impl) => {
-            return new mock(impl, specification, {}, class {
-            }, class {
-            }, class {
-            }, class {
-            }, class {
-            }, { ports: [] });
+            return new MockTiposkripto({}, specification, impl, { ports: [] }, testAdapter, (cb) => cb());
         },
         WithCustomSpecification: (spec) => {
-            return new mock(implementation, spec, {}, class {
-            }, class {
-            }, class {
-            }, class {
-            }, class {
-            }, { ports: [] });
+            return new MockTiposkripto({}, spec, implementation, { ports: [] }, testAdapter, (cb) => cb());
+        },
+        WithCustomAdapter: (customAdapter) => {
+            return new MockTiposkripto({}, specification, implementation, { ports: [] }, Object.assign(Object.assign({}, testAdapter), customAdapter), (cb) => cb());
         },
     },
     whens: {
@@ -78,22 +61,25 @@ export const implementation = {
         },
     },
     thens: {
-        initializedProperly: () => (builder) => {
-            var _a, _b;
-            console.log("Checking builder initialization:", {
-                builder,
-                isMock: builder instanceof mock,
-                constructor: (_a = builder === null || builder === void 0 ? void 0 : builder.constructor) === null || _a === void 0 ? void 0 : _a.name,
-                props: Object.keys(builder)
-            });
+        "it is initialized": () => (builder, utils) => {
+            var _a;
+            utils.writeFileSync("hello.txt", "world");
             if (!builder) {
                 throw new Error("Builder is undefined");
             }
-            if (!(builder instanceof mock)) {
-                throw new Error(`Builder was not properly initialized. Expected mock instance but got ${(_b = builder === null || builder === void 0 ? void 0 : builder.constructor) === null || _b === void 0 ? void 0 : _b.name}`);
+            if (!(builder instanceof MockTiposkripto)) {
+                throw new Error(`Builder was not properly initialized. Expected MockTiposkripto instance but got ${(_a = builder === null || builder === void 0 ? void 0 : builder.constructor) === null || _a === void 0 ? void 0 : _a.name}`);
             }
             // Verify required properties exist
-            const requiredProps = ['specs', 'testJobs', 'artifacts'];
+            const requiredProps = [
+                "specs",
+                "testJobs",
+                "artifacts",
+                "suitesOverrides",
+                "givenOverides",
+                "whenOverides",
+                "thenOverides",
+            ];
             for (const prop of requiredProps) {
                 if (!(prop in builder)) {
                     throw new Error(`Missing required property: ${prop}`);
@@ -149,6 +135,12 @@ export const implementation = {
             }
             return builder;
         },
+        interfaceConfigured: () => (builder) => {
+            if (!builder.testAdapter) {
+                throw new Error("Test adapter not configured");
+            }
+            return builder;
+        },
         specsModified: (expectedCount) => (builder) => {
             if (builder.specs.length <= expectedCount) {
                 throw new Error(`Expected at least ${expectedCount} modified specs`);
@@ -167,13 +159,7 @@ export const implementation = {
         },
         testRunSuccessful: () => async (builder) => {
             try {
-                await builder.testRun({
-                    testResourceConfiguration: {
-                        name: "test",
-                        fs: "/tmp",
-                        ports: [],
-                    },
-                });
+                await builder.receiveTestResourceConfig("");
                 return builder;
             }
             catch (e) {

package/dist/module/src/lib/Tiposkripto.test/Tiposkripto.js

@@ -0,0 +1,6 @@
+import Testeranto from "../../Node";
+import { testAdapter } from "./Tiposkripto.adapter";
+import { MockTiposkripto } from "./MockTiposkripto";
+import { specification } from "./Tiposkripto.specification";
+import { implementation } from "./Tiposkripto.implementation";
+export default Testeranto(MockTiposkripto.prototype, specification, implementation, testAdapter, { ports: 1 });

package/dist/module/src/lib/{classBuilder.test/classBuilder.test.specification.js → Tiposkripto.test/Tiposkripto.specification.js}

@@ -1,9 +1,9 @@
-import { implementation } from "./classBuilder.test.implementation";
+import { implementation } from "./Tiposkripto.implementation";
 export const specification = (Suite, Given, When, Then) => {
     return [
-        Suite.Default("Basic ClassBuilder Functionality", {
+        Suite.Default("Tiposkripto Core Functionality", {
             // Basic initialization tests
-            initialization: Given.Default(["ClassBuilder should initialize with default values"], [], [Then.initializedProperly()]),
+            initialization: Given.Default(["Tiposkripto should initialize with default values"], [], [Then.initializedProperly()]),
             customInput: Given.WithCustomInput({ custom: "input" }, [], [Then.initializedProperly()]),
             resourceRequirements: Given.WithResourceRequirements({ ports: [3000, 3001] }, [], [Then.resourceRequirementsSet()]),
             // Core functionality tests
@@ -17,18 +17,22 @@ export const specification = (Suite, Given, When, Then) => {
                 Then.whensOverridesConfigured(),
                 Then.thensOverridesConfigured(),
             ]),
+            interfaceConfiguration: Given.WithCustomAdapter({
+                assertThis: (x) => !!x,
+                beforeEach: async (s, i) => i(),
+            }, [], [Then.interfaceConfigured()]),
         }),
-        Suite.ExtendedSuite("Advanced ClassBuilder Functionality", {
+        Suite.ExtendedSuite("Tiposkripto Advanced Features", {
             // Custom implementations
             customImplementation: Given.WithCustomImplementation(implementation, [], [Then.specsGenerated(), Then.jobsCreated()]),
             customSpecification: Given.WithCustomSpecification(specification, [], [Then.specsGenerated(), Then.jobsCreated()]),
             // Dynamic modification tests
-            modifySpecs: Given.Default(["Should allow modifying specs"], [When.modifySpecs((specs) => [...specs, "extra"])], [Then.specsModified(1)]),
-            modifyJobs: Given.Default(["Should allow modifying jobs"], [When.modifyJobs((jobs) => [...jobs, {}])], [Then.jobsModified(1)]),
+            specModification: Given.Default(["Should allow modifying specs"], [When.modifySpecs((specs) => [...specs, "extra"])], [Then.specsModified(1)]),
+            jobModification: Given.Default(["Should allow modifying jobs"], [When.modifyJobs((jobs) => [...jobs, {}])], [Then.jobsModified(1)]),
             // Error handling
             errorHandling: Given.Default(["Should properly handle errors"], [When.triggerError("test error")], [Then.errorThrown("test error")]),
             // Full test run
-            testRun: Given.Default(["Should complete a full test run successfully"], [], [Then.testRunSuccessful()]),
-        }, []),
+            fullTestRun: Given.Default(["Should complete a full test run successfully"], [], [Then.testRunSuccessful()]),
+        }),
     ];
 };

package/dist/module/src/lib/abstractBase.test/MockGiven.js

@@ -1,10 +1,17 @@
-import { BaseGiven } from "../abstractBase";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BaseGiven } from "../BaseGiven";
 export class MockGiven extends BaseGiven {
     constructor(name, features, whens, thens, givenCB, initialValues) {
         super(name, features, whens, thens, givenCB, initialValues);
     }
     async givenThat(subject, testResourceConfiguration, artifactory, givenCB, initialValues, pm) {
-        return givenCB();
+        // Call the givenCB which is a function that returns the store
+        const result = givenCB();
+        if (typeof result === 'function') {
+            return result();
+        }
+        return result;
     }
     uberCatcher(e) {
         console.error("MockGiven error:", e);

package/dist/module/src/lib/abstractBase.test/MockThen.js

@@ -1,9 +1,12 @@
-import { BaseThen } from "../abstractBase";
+import { BaseThen } from "../BaseThen";
 export class MockThen extends BaseThen {
     constructor(name, thenCB) {
         super(name, thenCB);
     }
     async butThen(store, thenCB, testResourceConfiguration, pm) {
-        return thenCB(store);
+        // The thenCB expects a selection, not the store directly
+        // We need to extract the selection from the store
+        const selection = { testSelection: store.testSelection };
+        return thenCB(selection);
     }
 }

package/dist/module/src/lib/abstractBase.test/MockWhen.js

@@ -1,9 +1,16 @@
-import { BaseWhen } from "../abstractBase";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BaseWhen } from "../BaseWhen";
 export class MockWhen extends BaseWhen {
     constructor(name, whenCB) {
         super(name, whenCB);
     }
     async andWhen(store, whenCB, testResource, pm) {
-        return whenCB(store);
+        // The whenCB returns a function that takes the store
+        const result = whenCB(store);
+        if (typeof result === 'function') {
+            return result(store);
+        }
+        return result;
     }
 }

package/dist/module/src/lib/abstractBase.test/adapter.js

@@ -1,9 +1,21 @@
 export const testAdapter = {
-    beforeEach: async (subject, initializer) => initializer(),
-    andWhen: async (store, whenCB) => whenCB(store),
-    butThen: async (store, thenCB) => thenCB(store),
-    afterEach: (store) => store,
-    afterAll: () => { },
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const result = await initializer();
+        // Ensure the result matches the expected type
+        if (typeof result === "function") {
+            // If it's a function, call it to get the actual store
+            return result();
+        }
+        return result;
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        return whenCB(store);
+    },
+    butThen: async (store, thenCB, testResource, pm) => {
+        return thenCB(store);
+    },
+    afterEach: async (store, key, pm) => Promise.resolve(store),
+    afterAll: async (store, pm) => { },
     assertThis: (result) => !!result,
-    beforeAll: async (input) => input,
+    beforeAll: async (input, testResource, pm) => input,
 };

package/dist/module/src/lib/abstractBase.test/implementation.js

@@ -3,18 +3,18 @@ export const implementation = {
         Default: "Abstract Base Test Suite",
     },
     givens: {
-        Default: () => ({
+        Default: () => () => ({
             testStore: { value: "initial" },
             testSelection: { selected: true },
         }),
-        WithError: () => ({
+        WithError: () => () => ({
             testStore: { value: "error" },
             testSelection: { selected: false },
         }),
     },
     whens: {
         modifyStore: (newValue) => (store) => (Object.assign(Object.assign({}, store), { testStore: { value: newValue } })),
-        throwError: () => () => {
+        throwError: () => (store) => {
             throw new Error("Test error");
         },
     },