testeranto 0.189.0 → 0.198.0

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

@@ -1,65 +1,45 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.implementation = void 0;
-const mock_1 = __importDefault(require("./mock"));
-const classBuilder_test_specification_1 = require("./classBuilder.test.specification");
-const mock_2 = require("../BaseSuite.test/mock");
+const MockTiposkripto_1 = require("./MockTiposkripto");
+const Tiposkripto_specification_1 = require("./Tiposkripto.specification");
+const Tiposkripto_adapter_1 = require("./Tiposkripto.adapter");
 exports.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_1.default(exports.implementation, // Use the current implementation
-            classBuilder_test_specification_1.specification, // Use the current specification
-            {}, // Default input
-            mock_2.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_1.MockTiposkripto({}, // input
+                Tiposkripto_specification_1.specification, // Use the current specification
+                impl, // Use the passed implementation
+                { ports: [] }, // Default resource requirements
+                Tiposkripto_adapter_1.testAdapter, // Default adapter
+                (cb) => cb() // Default uberCatcher
+                );
+            };
+            const builder = createBuilder(exports.implementation);
             console.log("Builder created:", builder);
             return builder;
         },
         WithCustomInput: (input) => {
-            return new mock_1.default(exports.implementation, classBuilder_test_specification_1.specification, input, class {
-            }, class {
-            }, class {
-            }, class {
-            }, class {
-            }, { ports: [] });
+            return new MockTiposkripto_1.MockTiposkripto(input, Tiposkripto_specification_1.specification, exports.implementation, { ports: [] }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
         },
         WithResourceRequirements: (requirements) => {
-            return new mock_1.default(exports.implementation, classBuilder_test_specification_1.specification, {}, class {
-            }, class {
-            }, class {
-            }, class {
-            }, class {
-            }, requirements);
+            return new MockTiposkripto_1.MockTiposkripto({}, Tiposkripto_specification_1.specification, exports.implementation, requirements, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
         },
         WithCustomImplementation: (impl) => {
-            return new mock_1.default(impl, classBuilder_test_specification_1.specification, {}, class {
-            }, class {
-            }, class {
-            }, class {
-            }, class {
-            }, { ports: [] });
+            return new MockTiposkripto_1.MockTiposkripto({}, Tiposkripto_specification_1.specification, impl, { ports: [] }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
         },
         WithCustomSpecification: (spec) => {
-            return new mock_1.default(exports.implementation, spec, {}, class {
-            }, class {
-            }, class {
-            }, class {
-            }, class {
-            }, { ports: [] });
+            return new MockTiposkripto_1.MockTiposkripto({}, spec, exports.implementation, { ports: [] }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
+        },
+        WithCustomAdapter: (customAdapter) => {
+            return new MockTiposkripto_1.MockTiposkripto({}, Tiposkripto_specification_1.specification, exports.implementation, { ports: [] }, Object.assign(Object.assign({}, Tiposkripto_adapter_1.testAdapter), customAdapter), (cb) => cb());
         },
     },
     whens: {
@@ -84,22 +64,25 @@ exports.implementation = {
         },
     },
     thens: {
-        initializedProperly: () => (builder) => {
-            var _a, _b;
-            console.log("Checking builder initialization:", {
-                builder,
-                isMock: builder instanceof mock_1.default,
-                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_1.default)) {
-                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_1.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}`);
@@ -155,6 +138,12 @@ exports.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`);
@@ -173,13 +162,7 @@ exports.implementation = {
         },
         testRunSuccessful: () => async (builder) => {
             try {
-                await builder.testRun({
-                    testResourceConfiguration: {
-                        name: "test",
-                        fs: "/tmp",
-                        ports: [],
-                    },
-                });
+                await builder.receiveTestResourceConfig("");
                 return builder;
             }
             catch (e) {

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

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Node_1 = __importDefault(require("../../Node"));
+const Tiposkripto_adapter_1 = require("./Tiposkripto.adapter");
+const MockTiposkripto_1 = require("./MockTiposkripto");
+const Tiposkripto_specification_1 = require("./Tiposkripto.specification");
+const Tiposkripto_implementation_1 = require("./Tiposkripto.implementation");
+exports.default = (0, Node_1.default)(MockTiposkripto_1.MockTiposkripto.prototype, Tiposkripto_specification_1.specification, Tiposkripto_implementation_1.implementation, Tiposkripto_adapter_1.testAdapter, { ports: 1 });

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

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.specification = void 0;
-const classBuilder_test_implementation_1 = require("./classBuilder.test.implementation");
+const Tiposkripto_implementation_1 = require("./Tiposkripto.implementation");
 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
@@ -20,19 +20,23 @@ 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(classBuilder_test_implementation_1.implementation, [], [Then.specsGenerated(), Then.jobsCreated()]),
+            customImplementation: Given.WithCustomImplementation(Tiposkripto_implementation_1.implementation, [], [Then.specsGenerated(), Then.jobsCreated()]),
             customSpecification: Given.WithCustomSpecification(exports.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()]),
+        }),
     ];
 };
 exports.specification = specification;

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

@@ -1,13 +1,20 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockGiven = void 0;
-const abstractBase_1 = require("../abstractBase");
-class MockGiven extends abstractBase_1.BaseGiven {
+const BaseGiven_1 = require("../BaseGiven");
+class MockGiven extends BaseGiven_1.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/common/src/lib/abstractBase.test/MockThen.js

@@ -1,13 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockThen = void 0;
-const abstractBase_1 = require("../abstractBase");
-class MockThen extends abstractBase_1.BaseThen {
+const BaseThen_1 = require("../BaseThen");
+class MockThen extends BaseThen_1.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);
     }
 }
 exports.MockThen = MockThen;

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

@@ -1,13 +1,20 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockWhen = void 0;
-const abstractBase_1 = require("../abstractBase");
-class MockWhen extends abstractBase_1.BaseWhen {
+const BaseWhen_1 = require("../BaseWhen");
+class MockWhen extends BaseWhen_1.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;
     }
 }
 exports.MockWhen = MockWhen;

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

@@ -2,11 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.testAdapter = void 0;
 exports.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/common/src/lib/abstractBase.test/implementation.js

@@ -6,18 +6,18 @@ exports.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");
         },
     },

package/dist/common/src/lib/index.js

@@ -4,29 +4,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultTestResourceRequirement = exports.DefaultAdapter = exports.BaseAdapter = void 0;
 const BaseAdapter = () => ({
-    beforeAll: async (s) => s,
-    beforeEach: async function (subject, initialValues, x, testResource, pm) {
+    beforeAll: async (input, testResource, pm) => {
+        return input;
+    },
+    beforeEach: async function (subject, initializer, testResource, initialValues, pm) {
         return subject;
     },
-    afterEach: async (s) => s,
-    afterAll: (store) => undefined,
-    butThen: async (store, thenCb) => {
-        return thenCb(store);
+    afterEach: async (store, key, pm) => Promise.resolve(store),
+    afterAll: (store, pm) => undefined,
+    butThen: async (store, thenCb, testResource, pm) => {
+        return thenCb(store, pm);
     },
     andWhen: async (store, whenCB, testResource, pm) => {
-        try {
-            await whenCB(store, testResource, pm);
-        }
-        catch (error) {
-            console.error("Error in andWhen:", error);
-            throw error; // Re-throw to maintain test failure
-        }
+        return whenCB(store, pm);
     },
     assertThis: (x) => x,
 });
 exports.BaseAdapter = BaseAdapter;
 const DefaultAdapter = (p) => {
-    return Object.assign(Object.assign({}, exports.BaseAdapter), p);
+    const base = (0, exports.BaseAdapter)();
+    return Object.assign(Object.assign({}, base), p);
 };
 exports.DefaultAdapter = DefaultAdapter;
 exports.defaultTestResourceRequirement = {

package/dist/common/src/lib/mocks.test.js

@@ -1,9 +1,11 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockTestSpecification = void 0;
-const mockTestSpecification = () => {
-    return () => {
-        return new BaseSuite();
-    };
-};
-exports.mockTestSpecification = mockTestSpecification;
+// import { Ibdd_in_any, Ibdd_out_any, ITestSpecification } from "../CoreTypes";
+// import { BaseSuite } from "./BaseSuite";
+// export const mockTestSpecification = (): ITestSpecification<
+//   Ibdd_in_any,
+//   Ibdd_out_any
+// > => {
+//   return () => {
+//     return new BaseSuite();
+//   };
+// };

package/dist/common/src/lib/pmProxy.js

@@ -10,10 +10,16 @@ const baseProxy = function (pm, mappings) {
                 const method = mapping[0];
                 const arger = mapping[1];
                 if (prop === method) {
-                    return (...x) => target[prop](arger(...x));
+                    return (...x) => {
+                        // Add debug logging
+                        const modifiedArgs = arger(...x);
+                        return target[prop](...modifiedArgs);
+                    };
                 }
             }
-            return (...x) => target[prop](...x);
+            return (...x) => {
+                return target[prop](...x);
+            };
         },
     });
 };
@@ -53,10 +59,27 @@ const butThenProxy = (pm, filepath, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
+                console.log(`[DEBUG] butThenProxy writeFileSync: fp="${fp}" (type: ${typeof fp}), contents="${contents}" (type: ${typeof contents}), testName="${testName}" (type: ${typeof testName})`);
+                // Check if fp is being treated as individual characters
+                if (typeof fp !== "string") {
+                    console.log(`[ERROR] fp is not a string:`, fp);
+                    // If fp is not a string, try to handle it
+                    if (Array.isArray(fp)) {
+                        // If it's an array, join it back into a string
+                        fp = fp.join("");
+                        console.log(`[DEBUG] Converted array to string: "${fp}"`);
+                    }
+                    else {
+                        // For other cases, convert to string
+                        fp = String(fp);
+                        console.log(`[DEBUG] Converted to string: "${fp}"`);
+                    }
+                }
                 const path = `${filepath}/butThen/${fp}`;
+                console.log(`[DEBUG] Generated path: "${path}"`);
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -96,10 +119,10 @@ const andWhenProxy = (pm, filepath, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `${filepath}/andWhen/${fp}`;
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -140,10 +163,10 @@ const afterEachProxy = (pm, suite, given, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `suite-${suite}/given-${given}/afterEach/${fp}`;
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -176,10 +199,10 @@ const beforeEachProxy = (pm, suite, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `suite-${suite}/beforeEach/${fp}`;
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -208,10 +231,10 @@ const beforeAllProxy = (pm, suite, addArtifact) => {
     return baseProxy(pm, [
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `suite-${suite}/beforeAll/${fp}`;
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -248,10 +271,10 @@ const afterAllProxy = (pm, suite, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `suite-${suite}/afterAll/${fp}`;
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [

package/dist/common/src/lib/pmProxy.test/adapter.js

@@ -38,7 +38,17 @@ exports.testAdapter = {
             beforeEachProxy: input.butThenProxy(new mockPMBase_1.MockPMBase(), theGivenString),
         };
     },
-    assertThis: (returnedFilePath, expectation) => {
-        chai_1.assert.equal(returnedFilePath, expectation);
+    assertThis: (actualResult, expectedResult) => {
+        // Handle both path assertions and our new test result
+        if (typeof actualResult === 'string' && actualResult.startsWith('PASS')) {
+            chai_1.assert.equal(actualResult, 'PASS', 'tests.json should be written with correct path and content');
+        }
+        else if (typeof actualResult === 'string' && actualResult.startsWith('FAIL')) {
+            // For the tests.json write test, we want to see what's actually happening
+            chai_1.assert.fail(`Test failed: ${actualResult}`);
+        }
+        else {
+            chai_1.assert.equal(actualResult, expectedResult);
+        }
     },
 };