testeranto 0.146.1 → 0.146.4

package/dist/module/src/Pure.test.js

@@ -0,0 +1,167 @@
+import PureTesteranto from "./Pure";
+import { MockPMBase } from "./lib/pmProxy.test/mockPMBase";
+// Implementation for PureTesteranto tests
+const implementation = {
+    suites: {
+        Default: "PureTesteranto Test Suite",
+    },
+    givens: {
+        Default: () => ({
+            pm: new MockPMBase(),
+            config: {},
+            proxies: {
+                butThenProxy: (pm, path) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => pm.writeFileSync(`${path}/butThen/${p}`, c) })),
+                andWhenProxy: (pm, path) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => pm.writeFileSync(`${path}/andWhen/${p}`, c) })),
+                beforeEachProxy: (pm, suite) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => pm.writeFileSync(`suite-${suite}/beforeEach/${p}`, c) }))
+            }
+        }),
+    },
+    whens: {
+        applyProxy: (proxyType) => (store) => {
+            switch (proxyType) {
+                case "invalidConfig":
+                    throw new Error("Invalid configuration");
+                case "missingProxy":
+                    return Object.assign(Object.assign({}, store), { pm: {} }); // Break proxy chain
+                case "largePayload":
+                    return Object.assign(Object.assign({}, store), { largePayload: true, pm: Object.assign(Object.assign({}, store.pm), { writeFileSync: (p, c) => {
+                                if (c.length > 1e6) {
+                                    return true;
+                                }
+                                throw new Error("Payload too small");
+                            } }) });
+                default:
+                    return store;
+            }
+        },
+    },
+    thens: {
+        verifyProxy: (expectedPath) => (store) => {
+            var _a;
+            const testPath = "expected";
+            const result = store.pm.writeFileSync(testPath, "content");
+            const actualPath = (_a = store.pm.getLastCall("writeFileSync")) === null || _a === void 0 ? void 0 : _a.path;
+            if (actualPath !== expectedPath) {
+                throw new Error(`Expected path ${expectedPath}, got ${actualPath}`);
+            }
+            return store;
+        },
+        verifyNoProxy: () => (store) => {
+            if (store.pm.getCallCount("writeFileSync") > 0) {
+                throw new Error("Proxy was unexpectedly applied");
+            }
+            return store;
+        },
+        verifyError: (expectedError) => (store) => {
+            try {
+                store.pm.writeFileSync("test", "content");
+                throw new Error("Expected error but none was thrown");
+            }
+            catch (error) {
+                if (!error.message.includes(expectedError)) {
+                    throw new Error(`Expected error "${expectedError}", got "${error.message}"`);
+                }
+            }
+            return store;
+        },
+        verifyResourceConfig: () => (store) => {
+            if (!store.pm.testResourceConfiguration) {
+                throw new Error("Missing test resource configuration");
+            }
+            return store;
+        },
+        verifyLargePayload: () => (store) => {
+            const largeContent = "x".repeat(2e6); // 2MB payload
+            const result = store.pm.writeFileSync("large.txt", largeContent);
+            if (!result) {
+                throw new Error("Failed to handle large payload");
+            }
+            return store;
+        },
+        verifyTypeSafety: () => (store) => {
+            // TypeScript will catch these at compile time
+            return store;
+        },
+    },
+    checks: {
+        Default: () => ({}),
+    },
+};
+// Specification for PureTesteranto tests
+const specification = (Suite, Given, When, Then, Check) => [
+    Suite.Default("Core Functionality", {
+        initializationTest: Given.Default(["Should initialize with default configuration"], [], [Then.verifyNoProxy()]),
+        resourceConfigTest: Given.Default(["Should handle test resource configuration"], [When.applyProxy("resourceConfig")], [Then.verifyResourceConfig()]),
+    }),
+    Suite.Default("Proxy Integration", {
+        butThenProxyTest: Given.Default(["Should integrate with butThenProxy"], [When.applyProxy("butThenProxy")], [Then.verifyProxy("test/path/butThen/expected")]),
+        andWhenProxyTest: Given.Default(["Should integrate with andWhenProxy"], [When.applyProxy("andWhenProxy")], [Then.verifyProxy("test/path/andWhen/expected")]),
+        beforeEachProxyTest: Given.Default(["Should integrate with beforeEachProxy"], [When.applyProxy("beforeEachProxy")], [Then.verifyProxy("suite-1/beforeEach/expected")]),
+    }),
+    Suite.Default("Error Handling", {
+        invalidConfigTest: Given.Default(["Should handle invalid configuration"], [When.applyProxy("invalidConfig")], [Then.verifyError("Invalid configuration")]),
+        missingProxyTest: Given.Default(["Should handle missing proxy"], [When.applyProxy("missingProxy")], [Then.verifyError("Proxy not found")]),
+    }),
+    Suite.Default("Performance", {
+        multipleProxiesTest: Given.Default(["Should handle multiple proxies efficiently"], [
+            When.applyProxy("butThenProxy"),
+            When.applyProxy("andWhenProxy"),
+            When.applyProxy("beforeEachProxy")
+        ], [
+            Then.verifyProxy("test/path/butThen/expected"),
+            Then.verifyProxy("test/path/andWhen/expected"),
+            Then.verifyProxy("suite-1/beforeEach/expected")
+        ]),
+        largePayloadTest: Given.Default(["Should handle large payloads"], [When.applyProxy("largePayload")], [Then.verifyLargePayload()]),
+    }),
+    Suite.Default("Cross-Component Verification", {
+        proxyChainTest: Given.Default(["Proxies should chain correctly"], [
+            When.applyProxy("butThenProxy"),
+            When.applyProxy("andWhenProxy")
+        ], [
+            Then.verifyProxy("test/path/andWhen/butThen/expected")
+        ]),
+        errorPropagationTest: Given.Default(["Errors should propagate across components"], [When.applyProxy("invalidConfig")], [Then.verifyError("Invalid configuration")]),
+        resourceSharingTest: Given.Default(["Resources should be shared correctly"], [When.applyProxy("resourceConfig")], [Then.verifyResourceConfig()])
+    }),
+    Suite.Default("Type Safety", {
+        strictTypeTest: Given.Default(["Should enforce type safety"], [When.applyProxy("typeSafe")], [Then.verifyTypeSafety()]),
+        invalidTypeTest: Given.Default(["Should reject invalid types"], [When.applyProxy("invalidType")], [Then.verifyError("Type mismatch")]),
+    }),
+    Suite.Default("Integration Tests", {
+        // Verify builders work together
+        builderIntegration: Given.Default(["BaseBuilder and ClassBuilder should integrate properly"], [], [
+            Then.initializedProperly(),
+            Then.specsGenerated(),
+            Then.jobsCreated(),
+            Then.artifactsTracked()
+        ]),
+        // Verify PM proxy integration  
+        pmProxyIntegration: Given.Default(["PM proxies should work with test runners"], [When.applyProxy("butThenProxy")], [Then.verifyProxy("test/path/butThen/expected")]),
+        // Verify full test lifecycle
+        fullLifecycle: Given.Default(["Should complete full test lifecycle"], [
+            When.addArtifact(Promise.resolve("test")),
+            When.setTestJobs([]),
+            When.modifySpecs((specs) => [...specs])
+        ], [
+            Then.testRunSuccessful(),
+            Then.artifactsTracked(),
+            Then.specsModified(0)
+        ])
+    })
+];
+// Test interface for PureTesteranto
+const testInterface = {
+    beforeEach: async (subject, initializer) => {
+        return { pm: initializer() };
+    },
+    andWhen: async (store, whenCB) => whenCB(store),
+    butThen: async (store, thenCB) => thenCB(store),
+    afterEach: async (store) => store,
+    afterAll: async () => { },
+    beforeAll: async (input, testResource) => ({}),
+    assertThis: (x) => x,
+};
+// Export the test suite
+export default PureTesteranto(null, // No initial input
+specification, implementation, testInterface);

package/dist/module/src/build.js

@@ -151,7 +151,6 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
         // ],
     ];
     x.forEach(async ([runtime, keys]) => {
-        console.log(runtime, keys);
         keys.forEach(async (k) => {
             const folder = `testeranto/reports/${testName}/${k
                 .split(".")

package/dist/module/src/esbuildConfigs/consoleDetectorPlugin.js

@@ -1,24 +1,32 @@
+import fs from "fs";
 export const consoleDetectorPlugin = {
-    name: 'console-detector',
+    name: "console-detector",
     setup(build) {
         build.onLoad({ filter: /\.(js|ts)$/ }, async (args) => {
-            const contents = await require('fs').promises.readFile(args.path, 'utf8');
+            const contents = await fs.promises.readFile(args.path, "utf8");
             const consolePattern = /console\.(log|error|warn|info|debug|trace|dir|dirxml|table|group|groupEnd|clear|count|countReset|assert|profile|profileEnd|time|timeLog|timeEnd|timeStamp|context|memory)/g;
             const matches = contents.match(consolePattern);
             if (matches) {
                 const uniqueMethods = [...new Set(matches)];
                 return {
-                    warnings: uniqueMethods.map(method => ({
-                        text: `Detected ${method} call - Pure runtime does not allow IO operations. Use Node runtime instead.`,
-                        location: {
-                            file: args.path,
-                            line: contents.split('\n').findIndex(line => line.includes(method)) + 1,
-                            column: 0
-                        }
-                    }))
+                    warnings: uniqueMethods.map((method) => ({
+                        text: `call of "${method}" was detected, which is not supported in the pure runtime.`,
+                        // location: {
+                        //   file: args.path,
+                        //   line:
+                        //     contents
+                        //       .split("\n")
+                        //       .findIndex((line) => line.includes(method)) + 1,
+                        //   column: 0,
+                        // },
+                    })),
                 };
             }
             return null;
         });
-    }
+        build.onEnd((buildResult) => {
+            if (buildResult.warnings.find((br) => br.pluginName === "console-detector"))
+                console.warn(`Warning: An unsupported method call was detected in a source file used to build for the pure runtime. It is possible that this method call is in a comment block. If you really want to use this function, change this test to the "node" runtime.`);
+        });
+    },
 };

package/dist/module/src/esbuildConfigs/nativeImportDetectorPlugin.js

@@ -0,0 +1,21 @@
+import { isBuiltin } from "node:module";
+export const nativeImportDetectorPlugin = {
+    name: "native-node-import-filter",
+    setup(build) {
+        build.onResolve({ filter: /fs/ }, (args) => {
+            if (isBuiltin(args.path)) {
+                return {
+                    warnings: [
+                        {
+                            text: `cannot use native node package "${args.path}" in a "pure" test. If you really want to use this package, convert this test from "pure" to "node"`,
+                        },
+                    ],
+                };
+                // throw new Error(
+                //   `cannot use native node package "${args.path}" in a "pure" test. If you really want to use this package, convert this test from "pure" to "node"`
+                // );
+            }
+            return { path: args.path };
+        });
+    },
+};

package/dist/module/src/esbuildConfigs/pure.js

@@ -18,12 +18,13 @@ export default (config, entryPoints, testName) => {
             featuresPlugin,
             inputFilesPluginFactory,
             consoleDetectorPlugin,
+            // nativeImportDetectorPlugin,
             {
                 name: "native-node-import-filter",
                 setup(build) {
                     build.onResolve({ filter: /fs/ }, (args) => {
                         if (isBuiltin(args.path)) {
-                            throw new Error(`cannot use native node package "${args.path}" in a "pure" test. If you really want to use this package, convert this test from "pure" to "node"`);
+                            throw new Error(`You attempted to import a node module "${args.path}" into a "pure" test, which is not allowed. If you really want to use this package, convert this test from "pure" to "node"`);
                         }
                         return { path: args.path };
                     });

package/dist/module/src/esbuildConfigs/rebuildPlugin.js

@@ -3,11 +3,8 @@ export default (r) => {
     return {
         name: "rebuild-notify",
         setup: (build) => {
-            build.onStart(() => {
-                console.log(`> web build starting...`);
-            });
             build.onEnd((result) => {
-                console.log(`> web build ended with ${result.errors.length} errors`);
+                console.log(`${r} > build ended with ${result.errors.length} errors`);
                 if (result.errors.length > 0) {
                     fs.writeFileSync(`./testeranto/reports${r}_build_errors`, JSON.stringify(result, null, 2));
                 }

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

@@ -0,0 +1,85 @@
+import { beforeAllProxy, afterAllProxy } from "./pmProxy";
+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];
+            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("Given error 1:", e);
+                throw e;
+            });
+        }
+        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;
+    }
+}

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

@@ -0,0 +1,4 @@
+import Testeranto from "../../Node";
+import { BaseSuite } from "../BaseSuite";
+import { implementation, specification, testInterface } from "./test";
+export default Testeranto(BaseSuite, specification, implementation, testInterface);

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

@@ -0,0 +1,4 @@
+import Testeranto from "../../Pure";
+import { BaseSuite } from "../BaseSuite";
+import { implementation, specification, testInterface } from "./test";
+export default Testeranto(BaseSuite, specification, implementation, testInterface);

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

@@ -0,0 +1,227 @@
+import { BaseGiven, BaseWhen, BaseThen, BaseCheck } from "../abstractBase";
+import { BaseSuite } from "../BaseSuite";
+// 2. Mock implementations with proper typing
+export class MockGiven extends BaseGiven {
+    constructor(name, features, whens, thens) {
+        super(name, features, whens, thens, async () => ({ testStore: true }), // givenCB
+        {} // initialValues
+        );
+    }
+    async givenThat(subject, testResourceConfiguration, artifactory, givenCB, initialValues, pm) {
+        return { testStore: true };
+    }
+    uberCatcher(e) {
+        console.error("Given error 2:", e);
+    }
+}
+class MockWhen extends BaseWhen {
+    async andWhen(store, whenCB, testResource, pm) {
+        return Object.assign(Object.assign({}, store), { testStore: true });
+    }
+}
+class MockThen extends BaseThen {
+    async butThen(store, thenCB, testResourceConfiguration, pm) {
+        return { testSelection: true };
+    }
+}
+class MockCheck extends BaseCheck {
+    async checkThat(subject, testResourceConfiguration, artifactory, initializer, initialValues, pm) {
+        return { testStore: true };
+    }
+}
+class TestableSuite extends BaseSuite {
+    constructor(name, index) {
+        super(name, index, {
+            testGiven: new MockGiven("testGiven", ["testFeature"], [
+                new MockWhen("testWhen", () => Promise.resolve({ testStore: true })),
+            ], [
+                new MockThen("testThen", async () => Promise.resolve({ testSelection: true })),
+            ]),
+        }, [
+            new MockCheck("testCheck", ["testFeature"], () => Promise.resolve({ testStore: true }), null, () => { }),
+        ]);
+    }
+}
+// 3. Enhanced Test Specification with more test cases
+export const specification = (Suite, Given, When, Then, Check) => [
+    Suite.Default("BaseSuite Core Functionality Tests", {
+        // Test initialization and basic properties
+        initialization: Given.Default(["BaseSuite should initialize with correct name and index"], [], [
+            Then.SuiteNameMatches("testSuite"),
+            Then.SuiteIndexMatches(0),
+            Then.FeaturesIncludes("testFeature"),
+        ]),
+        // Test execution flow
+        execution: Given.Default(["BaseSuite should execute all phases successfully"], [When.RunSuite()], [Then.StoreValid(), Then.NoErrorsOccurred(), Then.AllChecksCompleted()]),
+        // Test multiple features
+        multipleFeatures: Given.Default(["BaseSuite should handle multiple features"], [When.AddFeature("additionalFeature")], [
+            Then.FeaturesIncludes("testFeature"),
+            Then.FeaturesIncludes("additionalFeature"),
+            Then.FeatureCountMatches(2),
+        ]),
+        // Test error handling
+        errorHandling: Given.Default(["BaseSuite should handle errors gracefully"], [When.RunSuiteWithError()], [
+            Then.ErrorCountMatches(1),
+            // Then.FailedFlagSet(),
+        ]),
+    }, [
+    // Additional validation checks
+    // Check.Default(
+    //   ["Verify suite state after all tests"],
+    //   [],
+    //   [
+    //     Then.AllTestsCompleted(),
+    //     Then.CleanExit()
+    //   ]
+    // )
+    ]),
+    Suite.Default("Comprehensive Integration", {
+        fullStackTest: Given.Default(["All components should work together"], [
+            When.addArtifact(Promise.resolve("test")),
+            When.modifySpecs((specs) => [...specs, "extra"]),
+            When.modifyJobs((jobs) => [...jobs, {}]),
+        ], [
+            Then.specsModified(1),
+            Then.jobsModified(1),
+            Then.artifactsTracked(),
+            Then.testRunSuccessful(),
+        ]),
+    }),
+];
+// 4. Enhanced Test Implementation with more operations
+export const implementation = {
+    suites: {
+        Default: "BaseSuite Comprehensive Test Suite",
+    },
+    givens: {
+        Default: () => new TestableSuite("testSuite", 0),
+    },
+    whens: {
+        RunSuite: () => async (suite) => {
+            const mockConfig = {
+                name: "test",
+                fs: "/tmp",
+                ports: [3000],
+                environment: {},
+                timeout: 5000,
+                retries: 3,
+            };
+            const mockArtifactory = (key, value) => { };
+            const mockTLog = (...args) => { };
+            const mockPM = {
+                server: null,
+                testResourceConfiguration: mockConfig,
+                start: async () => { },
+                stop: async () => { },
+                testArtiFactoryfileWriter: () => { },
+                $: () => { },
+                click: () => { },
+                closePage: () => { },
+                createWriteStream: async () => "",
+            };
+            return await suite.run(null, mockConfig, mockArtifactory, mockTLog, mockPM);
+        },
+        RunSuiteWithError: () => async (suite) => {
+            // Force an error by passing invalid config
+            try {
+                await suite.run(null, {}, // Invalid config
+                () => { }, () => { }, {});
+            }
+            catch (e) {
+                // Error is caught and counted by BaseSuite
+            }
+            return suite;
+        },
+        AddFeature: (feature) => (suite) => {
+            // Add a feature to the first given
+            const firstGivenKey = Object.keys(suite.givens)[0];
+            if (firstGivenKey) {
+                suite.givens[firstGivenKey].features.push(feature);
+            }
+            return suite;
+        },
+    },
+    thens: {
+        SuiteNameMatches: (expectedName) => (suite) => {
+            if (suite.name !== expectedName) {
+                throw new Error(`Expected suite name '${expectedName}', got '${suite.name}'`);
+            }
+            return suite;
+        },
+        SuiteIndexMatches: (expectedIndex) => (suite) => {
+            if (suite.index !== expectedIndex) {
+                throw new Error(`Expected suite index ${expectedIndex}, got ${suite.index}`);
+            }
+            return suite;
+        },
+        FeaturesIncludes: (feature) => (suite) => {
+            if (!suite.features().includes(feature)) {
+                throw new Error(`Expected features to include ${feature}`);
+            }
+            return suite;
+        },
+        FeatureCountMatches: (expectedCount) => (suite) => {
+            const actualCount = suite.features().length;
+            if (actualCount !== expectedCount) {
+                throw new Error(`Expected ${expectedCount} features, got ${actualCount}`);
+            }
+            return suite;
+        },
+        StoreValid: () => (suite) => {
+            var _a;
+            if (!((_a = suite.store) === null || _a === void 0 ? void 0 : _a.testStore)) {
+                throw new Error("Expected valid store after execution");
+            }
+            return suite;
+        },
+        NoErrorsOccurred: () => (suite) => {
+            if (suite.failed || suite.fails > 0) {
+                throw new Error("Expected no errors to occur during execution");
+            }
+            return suite;
+        },
+        ErrorCountMatches: (expectedCount) => (suite) => {
+            if (suite.fails !== expectedCount) {
+                throw new Error(`Expected ${expectedCount} errors, got ${suite.fails}`);
+            }
+            return suite;
+        },
+        FailedFlagSet: () => (suite) => {
+            if (!suite.failed) {
+                throw new Error("Expected failed flag to be set after error");
+            }
+            return suite;
+        },
+        AllChecksCompleted: () => (suite) => {
+            if (suite.checks.some((check) => !check.key)) {
+                throw new Error("Expected all checks to be completed");
+            }
+            return suite;
+        },
+        AllTestsCompleted: () => (suite) => {
+            if (!suite.store) {
+                throw new Error("Expected all tests to be completed");
+            }
+            return suite;
+        },
+        CleanExit: () => (suite) => {
+            if (suite.failed && suite.fails === 0) {
+                throw new Error("Expected clean exit state");
+            }
+            return suite;
+        },
+    },
+    checks: {
+        Default: () => new TestableSuite("testCheck", 1),
+    },
+};
+// 5. Fully typed Test Interface
+export const testInterface = {
+    beforeEach: async (subject, initializer) => initializer(),
+    andWhen: async (store, whenCB, testResource, pm) => whenCB(store, pm),
+    butThen: async (store, thenCB, testResource, pm) => thenCB(store, pm),
+    afterEach: (store) => store,
+    afterAll: (store, pm) => { },
+    assertThis: (result) => !!result,
+    beforeAll: async (input, testResource, pm) => input,
+};

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

@@ -0,0 +1,4 @@
+import Testeranto from "../../Web";
+import { BaseSuite } from "../BaseSuite";
+import { implementation, specification, testInterface } from "./test";
+export default Testeranto(BaseSuite, specification, implementation, testInterface);