testeranto 0.146.2 → 0.146.5

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

@@ -1,92 +1,6 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { afterAllProxy, afterEachProxy, andWhenProxy, beforeAllProxy, beforeEachProxy, butThenProxy, } from "./pmProxy.js";
-export class BaseSuite {
-    constructor(name, index, givens = {}, checks = []) {
-        this.name = name;
-        this.index = index;
-        this.givens = givens;
-        this.checks = checks;
-        this.fails = 0;
-    }
-    features() {
-        const features = Object.keys(this.givens)
-            .map((k) => this.givens[k].features)
-            .flat()
-            .filter((value, index, array) => {
-            return array.indexOf(value) === index;
-        });
-        return features || [];
-    }
-    toObj() {
-        const givens = Object.keys(this.givens).map((k) => this.givens[k].toObj());
-        const checks = Object.keys(this.checks).map((k) => this.checks[k].toObj());
-        return {
-            name: this.name,
-            givens,
-            checks,
-            fails: this.fails,
-            failed: this.failed,
-            features: this.features(),
-        };
-    }
-    setup(s, artifactory, tr, pm) {
-        return new Promise((res) => res(s));
-    }
-    assertThat(t) {
-        return !!t;
-    }
-    afterAll(store, artifactory, pm) {
-        return store;
-    }
-    async run(input, testResourceConfiguration, artifactory, tLog, pm) {
-        this.testResourceConfiguration = testResourceConfiguration;
-        // tLog("test resources: ", JSON.stringify(testResourceConfiguration));
-        const suiteArtifactory = (fPath, value) => artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
-        // console.log("\nSuite:", this.index, this.name);
-        tLog("\nSuite:", this.index, this.name);
-        const sNdx = this.index;
-        // const sName = this.name;
-        const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, beforeAllProxy(pm, sNdx.toString()));
-        for (const [gKey, g] of Object.entries(this.givens)) {
-            const giver = this.givens[gKey];
-            try {
-                this.store = await giver.give(subject, gKey, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, pm, sNdx);
-            }
-            catch (e) {
-                this.failed = true;
-                this.fails = this.fails + 1;
-                console.error(e);
-                // this.fails.push(giver);
-                // return this;
-            }
-        }
-        for (const [ndx, thater] of this.checks.entries()) {
-            await thater.check(subject, thater.name, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, pm);
-        }
-        try {
-            this.afterAll(this.store, artifactory, afterAllProxy(pm, sNdx.toString()));
-        }
-        catch (e) {
-            console.error(e);
-            // this.fails.push(this);
-            // return this;
-        }
-        // @TODO fix me
-        // for (const k of Object.keys(this.givens)) {
-        //   const giver = this.givens[k];
-        //   try {
-        //     giver.afterAll(this.store, artifactory, pm);
-        //   } catch (e) {
-        //     console.error(e);
-        //     this.fails.push(giver);
-        //     return this;
-        //   }
-        // }
-        ////////////////
-        return this;
-    }
-}
+import { afterEachProxy, andWhenProxy, beforeEachProxy, butThenProxy, } from "./pmProxy.js";
 export class BaseGiven {
     constructor(name, features, whens, thens, givenCB, initialValues) {
         this.name = name;
@@ -183,7 +97,6 @@ export class BaseWhen {
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
         tLog(" When:", this.name);
         return await this.andWhen(store, this.whenCB, testResourceConfiguration, andWhenProxy(pm, filepath)).catch((e) => {
-            console.log("MARK9", e);
             this.error = e;
             throw e;
         });
@@ -211,7 +124,6 @@ export class BaseThen {
                 return this.thenCB;
             }
         }, testResourceConfiguration, butThenProxy(pm, filepath)).catch((e) => {
-            console.log("test failed 3", e);
             this.error = e;
             throw e;
         });

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

@@ -0,0 +1,13 @@
+import { BaseGiven } from "../abstractBase";
+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();
+    }
+    uberCatcher(e) {
+        console.error("MockGiven error:", e);
+        this.error = e;
+    }
+}

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

@@ -0,0 +1,9 @@
+import { BaseThen } from "../abstractBase";
+export class MockThen extends BaseThen {
+    constructor(name, thenCB) {
+        super(name, thenCB);
+    }
+    async butThen(store, thenCB, testResourceConfiguration, pm) {
+        return thenCB(store);
+    }
+}

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

@@ -0,0 +1,9 @@
+import { BaseWhen } from "../abstractBase";
+export class MockWhen extends BaseWhen {
+    constructor(name, whenCB) {
+        super(name, whenCB);
+    }
+    async andWhen(store, whenCB, testResource, pm) {
+        return whenCB(store);
+    }
+}

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

@@ -0,0 +1,39 @@
+import { PassThrough } from "stream";
+export const implementation = {
+    suites: {
+        Default: "Abstract Base Test Suite",
+    },
+    givens: {
+        Default: () => ({
+            testStore: { value: "initial" },
+            testSelection: { selected: true },
+        }),
+        WithError: () => ({
+            testStore: { value: "error" },
+            testSelection: { selected: false },
+        }),
+    },
+    whens: {
+        modifyStore: (newValue) => (store) => (Object.assign(Object.assign({}, store), { testStore: { value: newValue } })),
+        throwError: () => () => {
+            throw new Error("Test error");
+        },
+    },
+    thens: {
+        verifyStore: (expected) => (store) => {
+            if (store.testStore.value !== expected) {
+                throw new Error(`Expected ${expected}, got ${store.testStore.value}`);
+            }
+            return store;
+        },
+        verifyError: (expected) => (store) => {
+            if (!store.error || !store.error.message.includes(expected)) {
+                throw new Error(`Expected error "${expected}" not found`);
+            }
+            return store;
+        },
+    },
+    checks: {
+        Default: () => new PassThrough(),
+    },
+};

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

@@ -0,0 +1,12 @@
+import Testeranto from "../../Node";
+import { specification } from "./specification";
+import { implementation } from "./implementation";
+import { testInterface } from "./interface";
+import { MockGiven } from "./MockGiven";
+import { MockThen } from "./MockThen";
+import { MockWhen } from "./MockWhen";
+export default Testeranto({
+    MockGiven,
+    MockWhen,
+    MockThen,
+}, specification, implementation, testInterface);

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

@@ -0,0 +1,9 @@
+export const testInterface = {
+    beforeEach: async (subject, initializer) => initializer(),
+    andWhen: async (store, whenCB) => whenCB(store),
+    butThen: async (store, thenCB) => thenCB(store),
+    afterEach: (store) => store,
+    afterAll: () => { },
+    assertThis: (result) => !!result,
+    beforeAll: async (input) => input
+};

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

@@ -0,0 +1,15 @@
+export const specification = (Suite, Given, When, Then, Check) => [
+    Suite.Default("BaseGiven Tests", {
+        initialization: Given.Default(["Should initialize with default values"], [], [Then.verifyStore("initial")]),
+        errorHandling: Given.WithError(["Should handle errors properly"], [When.throwError()], [Then.verifyError("Test error")])
+    }),
+    Suite.Default("BaseWhen Tests", {
+        stateModification: Given.Default(["Should modify state correctly"], [When.modifyStore("modified")], [Then.verifyStore("modified")]),
+        errorPropagation: Given.Default(["Should propagate errors"], [When.throwError()], [Then.verifyError("Test error")])
+    }),
+    Suite.Default("BaseThen Tests", {
+        assertionPassing: Given.Default(["Should pass valid assertions"], [When.modifyStore("asserted")], [Then.verifyStore("asserted")]),
+        assertionFailing: Given.Default(["Should fail invalid assertions"], [When.modifyStore("wrong")], [Then.verifyStore("right")] // This should fail
+        )
+    })
+];

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

@@ -0,0 +1 @@
+export {};

package/dist/module/src/lib/baseBuilder.test/TestBaseBuilder.js

@@ -0,0 +1,32 @@
+import { BaseBuilder } from "../basebuilder";
+/**
+ * Concrete implementation of BaseBuilder for testing purposes only
+ */
+export class TestBaseBuilder extends BaseBuilder {
+    constructor(input, suitesOverrides = {}, givenOverrides = {}, whenOverrides = {}, thenOverrides = {}, checkOverrides = {}, testResourceRequirement = { ports: [] }, testSpecification = () => []) {
+        super(input, suitesOverrides, givenOverrides, whenOverrides, thenOverrides, checkOverrides, testResourceRequirement, testSpecification);
+        this.summary = {};
+        this.summary = {};
+    }
+    /**
+     * Simplified version for testing that doesn't actually run tests
+     */
+    testRun(puppetMaster) {
+        this.summary = {
+            [puppetMaster.testResourceConfiguration.name]: {
+                typeErrors: 0,
+                staticErrors: 0,
+                runTimeError: "",
+                prompt: "",
+                failingFeatures: {},
+            },
+        };
+        return Promise.resolve({
+            failed: false,
+            fails: 0,
+            artifacts: [],
+            logPromise: Promise.resolve(),
+            features: [],
+        });
+    }
+}

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

@@ -0,0 +1,94 @@
+import { PassThrough } from "stream";
+import { TestBaseBuilder } from "./TestBaseBuilder";
+import { BaseBuilder } from "../basebuilder";
+export const implementation = {
+    suites: {
+        Default: "BaseBuilder test suite",
+    },
+    givens: {
+        Default: () => {
+            return new TestBaseBuilder({}, {}, {}, {}, {}, {}, { ports: [] }, () => []);
+        },
+        WithCustomInput: (input) => {
+            return new TestBaseBuilder(input, {}, {}, {}, {}, {}, { ports: [] }, () => []);
+        },
+        WithResourceRequirements: (requirements) => {
+            return new TestBaseBuilder({}, {}, {}, {}, {}, {}, requirements, () => []);
+        },
+    },
+    whens: {
+        addArtifact: (artifact) => (builder) => {
+            builder.artifacts.push(artifact);
+            return builder;
+        },
+        setTestJobs: (jobs) => (builder) => {
+            builder.testJobs = jobs;
+            return builder;
+        },
+    },
+    thens: {
+        initializedProperly: () => (builder) => {
+            if (!(builder instanceof BaseBuilder)) {
+                throw new Error("Builder was not properly initialized");
+            }
+            return builder;
+        },
+        specsGenerated: () => (builder) => {
+            if (!Array.isArray(builder.specs)) {
+                throw new Error("Specs were not generated");
+            }
+            return builder;
+        },
+        jobsCreated: () => (builder) => {
+            if (!Array.isArray(builder.testJobs)) {
+                throw new Error("Test jobs were not created");
+            }
+            return builder;
+        },
+        artifactsTracked: () => (builder) => {
+            if (!Array.isArray(builder.artifacts)) {
+                throw new Error("Artifacts array not initialized");
+            }
+            return builder;
+        },
+        resourceRequirementsSet: () => (builder) => {
+            if (!builder.testResourceRequirement) {
+                throw new Error("Resource requirements not set");
+            }
+            return builder;
+        },
+        suitesOverridesConfigured: () => (builder) => {
+            if (!builder.suitesOverrides) {
+                throw new Error("Suites overrides not configured");
+            }
+            return builder;
+        },
+        givensOverridesConfigured: () => (builder) => {
+            if (!builder.givenOverides) {
+                throw new Error("Givens overrides not configured");
+            }
+            return builder;
+        },
+        whensOverridesConfigured: () => (builder) => {
+            if (!builder.whenOverides) {
+                throw new Error("Whens overrides not configured");
+            }
+            return builder;
+        },
+        thensOverridesConfigured: () => (builder) => {
+            if (!builder.thenOverides) {
+                throw new Error("Thens overrides not configured");
+            }
+            return builder;
+        },
+        checksOverridesConfigured: () => (builder) => {
+            if (!builder.checkOverides) {
+                throw new Error("Checks overrides not configured");
+            }
+            return builder;
+        },
+    },
+    checks: {
+        Default: () => new PassThrough(), // Not used in these tests
+    },
+};

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.interface.js

@@ -0,0 +1,14 @@
+export const testInterface = {
+    beforeEach: async (subject, initializer) => {
+        return initializer();
+    },
+    andWhen: async (store, whenCB, testResource, utils) => {
+        return whenCB(store, utils);
+    },
+    butThen: async (store, thenCB, testResource, pm) => {
+        return thenCB(store, pm);
+    },
+    afterEach: (store) => store,
+    afterAll: () => { },
+    assertThis: (x) => { },
+};

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.node.js

@@ -0,0 +1,6 @@
+import Testeranto from "../../Pure";
+import { specification } from "./baseBuilder.test.specification";
+import { implementation } from "./baseBuilder.test.implementation";
+import { testInterface } from "./baseBuilder.test.interface";
+import { BaseBuilder } from "../basebuilder";
+export default Testeranto(BaseBuilder.prototype, specification, implementation, testInterface);

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.pure.js

@@ -0,0 +1,6 @@
+import Testeranto from "../../Pure";
+import { specification } from "./baseBuilder.test.specification";
+import { implementation } from "./baseBuilder.test.implementation";
+import { testInterface } from "./baseBuilder.test.interface";
+import { BaseBuilder } from "../basebuilder";
+export default Testeranto(BaseBuilder.prototype, specification, implementation, testInterface);

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.specification.js

@@ -0,0 +1,9 @@
+export const specification = (Suite, Given, When, Then, Check) => {
+    return [
+        Suite.Default("Testing BaseBuilder functionality", {
+            testInitialization: Given.Default(["BaseBuilder should initialize correctly"], [], [Then.initializedProperly()]),
+            testSpecsGeneration: Given.Default(["BaseBuilder should generate specs from test specification"], [], [Then.specsGenerated()]),
+            testJobsCreation: Given.Default(["BaseBuilder should create test jobs"], [], [Then.jobsCreated()]),
+        }, []),
+    ];
+};

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.types.js

@@ -0,0 +1 @@
+export {};

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.web.js

@@ -0,0 +1,6 @@
+import Testeranto from "../../Web";
+import { specification } from "./baseBuilder.test.specification";
+import { implementation } from "./baseBuilder.test.implementation";
+import { testInterface } from "./baseBuilder.test.interface";
+import { BaseBuilder } from "../basebuilder";
+export default Testeranto(BaseBuilder.prototype, specification, implementation, testInterface);

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

@@ -31,8 +31,9 @@ export class BaseBuilder {
                 receiveTestResourceConfig: async function (puppetMaster) {
                     const logFilePath = "log.txt";
                     const access = await puppetMaster.createWriteStream(logFilePath);
+                    // deprecated?
                     const tLog = async (...l) => {
-                        // console.log("x", x);
+                        //
                     };
                     const suiteDone = await runner(puppetMaster, tLog);
                     const logPromise = new Promise(async (res) => {
@@ -41,25 +42,6 @@ export class BaseBuilder {
                     });
                     const fails = suiteDone.fails;
                     await puppetMaster.writeFileSync(`bdd_errors.txt`, fails.toString());
-                    //           await puppetMaster.writeFileSync(
-                    //             `index.html`,
-                    //             `
-                    // <!DOCTYPE html>
-                    // <html lang="en">
-                    // <head>
-                    //   <meta name="description" content="Webpage description goes here" />
-                    //   <meta charset="utf-8" />
-                    //   <title>kokomoBay - testeranto</title>
-                    //   <meta name="viewport" content="width=device-width, initial-scale=1" />
-                    //   <meta name="author" content="" />
-                    //   <link rel="stylesheet" href="/kokomoBay/testeranto/TestReport.css" />
-                    //   <script src="/kokomoBay/testeranto/TestReport.js"></script>
-                    // </head>
-                    // <body>
-                    //   <div id="root"/>
-                    // </body>
-                    //             `
-                    //           );
                     await puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2));
                     return {
                         failed: fails > 0,

package/dist/module/src/lib/classBuilder.test/TestClassBuilder.js

@@ -0,0 +1,37 @@
+import { BaseBuilder } from "../basebuilder";
+/**
+ * Concrete implementation of BaseBuilder for testing ClassBuilder
+ */
+export class TestClassBuilder extends BaseBuilder {
+    constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, checkKlasser, testResourceRequirement) {
+        super(input, {}, // suitesOverrides
+        {}, // givenOverides
+        {}, // whenOverides
+        {}, // thenOverides
+        {}, // checkOverides
+        testResourceRequirement, testSpecification);
+        this.summary = {};
+        this.summary = {};
+    }
+    /**
+     * Simplified test run for verification
+     */
+    testRun(puppetMaster) {
+        this.summary = {
+            [puppetMaster.testResourceConfiguration.name]: {
+                typeErrors: 0,
+                staticErrors: 0,
+                runTimeError: "",
+                prompt: "",
+                failingFeatures: {},
+            },
+        };
+        return Promise.resolve({
+            failed: false,
+            fails: 0,
+            artifacts: [],
+            logPromise: Promise.resolve(),
+            features: [],
+        });
+    }
+}

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

@@ -0,0 +1,179 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { PassThrough } from "stream";
+import { TestClassBuilder } from "./TestClassBuilder";
+import { specification } from "./classBuilder.test.specification";
+export const implementation = {
+    suites: {
+        Default: "ClassBuilder test suite",
+    },
+    givens: {
+        Default: () => {
+            return new TestClassBuilder(implementation, // Use the current implementation
+            specification, // Use the current specification
+            {}, // Default input
+            class {
+            }, // suiteKlasser
+            class {
+            }, // givenKlasser
+            class {
+            }, // whenKlasser
+            class {
+            }, // thenKlasser
+            class {
+            }, // checkKlasser
+            { ports: [] } // Default resource requirements
+            );
+        },
+        WithCustomInput: (input) => {
+            return new TestClassBuilder(implementation, specification, input, class {
+            }, class {
+            }, class {
+            }, class {
+            }, class {
+            }, { ports: [] });
+        },
+        WithResourceRequirements: (requirements) => {
+            return new TestClassBuilder(implementation, specification, {}, class {
+            }, class {
+            }, class {
+            }, class {
+            }, class {
+            }, requirements);
+        },
+        WithCustomImplementation: (impl) => {
+            return new TestClassBuilder(impl, specification, {}, class {
+            }, class {
+            }, class {
+            }, class {
+            }, class {
+            }, { ports: [] });
+        },
+        WithCustomSpecification: (spec) => {
+            return new TestClassBuilder(implementation, spec, {}, class {
+            }, class {
+            }, class {
+            }, class {
+            }, class {
+            }, { ports: [] });
+        },
+    },
+    whens: {
+        addArtifact: (artifact) => (builder) => {
+            builder.artifacts.push(artifact);
+            return builder;
+        },
+        setTestJobs: (jobs) => (builder) => {
+            builder.testJobs = jobs;
+            return builder;
+        },
+        modifySpecs: (modifier) => (builder) => {
+            builder.specs = modifier(builder.specs || []);
+            return builder;
+        },
+        modifyJobs: (modifier) => (builder) => {
+            builder.testJobs = modifier(builder.testJobs || []);
+            return builder;
+        },
+        triggerError: (message) => (builder) => {
+            throw new Error(message);
+        },
+    },
+    thens: {
+        initializedProperly: () => (builder) => {
+            if (!(builder instanceof TestClassBuilder)) {
+                throw new Error("Builder was not properly initialized");
+            }
+            return builder;
+        },
+        specsGenerated: () => (builder) => {
+            if (!Array.isArray(builder.specs)) {
+                throw new Error("Specs were not generated");
+            }
+            return builder;
+        },
+        jobsCreated: () => (builder) => {
+            if (!Array.isArray(builder.testJobs)) {
+                throw new Error("Test jobs were not created");
+            }
+            return builder;
+        },
+        artifactsTracked: () => (builder) => {
+            if (!Array.isArray(builder.artifacts)) {
+                throw new Error("Artifacts array not initialized");
+            }
+            return builder;
+        },
+        resourceRequirementsSet: () => (builder) => {
+            if (!builder.testResourceRequirement) {
+                throw new Error("Resource requirements not set");
+            }
+            return builder;
+        },
+        suitesOverridesConfigured: () => (builder) => {
+            if (!builder.suitesOverrides) {
+                throw new Error("Suites overrides not configured");
+            }
+            return builder;
+        },
+        givensOverridesConfigured: () => (builder) => {
+            if (!builder.givenOverides) {
+                throw new Error("Givens overrides not configured");
+            }
+            return builder;
+        },
+        whensOverridesConfigured: () => (builder) => {
+            if (!builder.whenOverides) {
+                throw new Error("Whens overrides not configured");
+            }
+            return builder;
+        },
+        thensOverridesConfigured: () => (builder) => {
+            if (!builder.thenOverides) {
+                throw new Error("Thens overrides not configured");
+            }
+            return builder;
+        },
+        checksOverridesConfigured: () => (builder) => {
+            if (!builder.checkOverides) {
+                throw new Error("Checks overrides not configured");
+            }
+            return builder;
+        },
+        specsModified: (expectedCount) => (builder) => {
+            if (builder.specs.length <= expectedCount) {
+                throw new Error(`Expected at least ${expectedCount} modified specs`);
+            }
+            return builder;
+        },
+        jobsModified: (expectedCount) => (builder) => {
+            if (builder.testJobs.length <= expectedCount) {
+                throw new Error(`Expected at least ${expectedCount} modified jobs`);
+            }
+            return builder;
+        },
+        errorThrown: (expectedMessage) => (builder) => {
+            // This is handled by the test runner
+            return builder;
+        },
+        testRunSuccessful: () => async (builder) => {
+            try {
+                await builder.testRun({
+                    testResourceConfiguration: {
+                        name: "test",
+                        fs: "/tmp",
+                        ports: [],
+                    },
+                });
+                return builder;
+            }
+            catch (e) {
+                throw new Error(`Test run failed: ${e.message}`);
+            }
+        },
+    },
+    checks: {
+        Default: () => new PassThrough(),
+        ImplementationCheck: (validator) => validator(implementation),
+        SpecificationCheck: (validator) => validator(specification),
+    },
+};