testeranto 0.203.0 → 0.205.0

package/dist/module/src/esbuildConfigs/eslint-formatter-testeranto.js

@@ -0,0 +1,18 @@
+export default function (results) {
+    return results
+        .filter((r) => r.messages.length)
+        .map((r) => {
+        const path = r.filePath.replace(process.cwd() + "/", "");
+        return [
+            path,
+            ...r.messages.map((m) => {
+                var _a;
+                return [
+                    `${m.line}:${m.column} ${m.message} (${m.ruleId || ""})`,
+                    ...(((_a = m.suggestions) === null || _a === void 0 ? void 0 : _a.map((s) => `- ${s.message}${s.fix ? " (fix)" : ""}`)) || []),
+                ].join("\n");
+            }),
+        ].join("\n");
+    })
+        .join("\n\n");
+}

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

@@ -0,0 +1,34 @@
+import path from "path";
+export default {
+    name: "feature-markdown",
+    setup(build) {
+        build.onResolve({ filter: /\.md$/ }, (args) => {
+            if (args.resolveDir === "")
+                return;
+            return {
+                path: path.isAbsolute(args.path)
+                    ? args.path
+                    : path.join(args.resolveDir, args.path),
+                namespace: "feature-markdown",
+            };
+        });
+        build.onLoad({ filter: /.*/, namespace: "feature-markdown" }, async (args) => {
+            // const markdownContent = new TextDecoder().decode(
+            //   await fs.readFileSync(args.path)
+            // );
+            // markdownHTML = marked(markdownContent, options?.markedOptions);
+            return {
+                contents: `file://${args.path}`,
+                loader: "text",
+                // contents: JSON.stringify({ path: args.path }),
+                // loader: "json",
+                // contents: JSON.stringify({
+                //   // html: markdownHTML,
+                //   raw: markdownContent,
+                //   filename: args.path, //path.basename(args.path),
+                // }),
+                // loader: "json",
+            };
+        });
+    },
+};

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

@@ -0,0 +1,19 @@
+export default (config) => {
+    return {
+        // packages: "external",
+        target: "esnext",
+        format: "esm",
+        splitting: true,
+        outExtension: { ".js": ".mjs" },
+        outbase: ".",
+        jsx: "transform",
+        bundle: true,
+        minify: config.minify === true,
+        write: true,
+        loader: {
+            ".js": "jsx",
+            ".png": "binary",
+            ".jpg": "binary",
+        },
+    };
+};

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

@@ -0,0 +1,25 @@
+import fs from "fs";
+const otherInputs = {};
+const register = (entrypoint, sources) => {
+    if (!otherInputs[entrypoint]) {
+        otherInputs[entrypoint] = new Set();
+    }
+    sources.forEach((s) => otherInputs[entrypoint].add(s));
+};
+export default (platform, testName) => {
+    const f = `testeranto/metafiles/${platform}/${testName}.json`;
+    if (!fs.existsSync(`testeranto/metafiles/${platform}`)) {
+        fs.mkdirSync(`testeranto/metafiles/${platform}`, { recursive: true });
+    }
+    return {
+        register,
+        inputFilesPluginFactory: {
+            name: "metafileWriter",
+            setup(build) {
+                build.onEnd((result) => {
+                    fs.writeFileSync(f, JSON.stringify(result, null, 2));
+                });
+            },
+        },
+    };
+};

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/node.js

@@ -0,0 +1,21 @@
+import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin.js";
+import featuresPlugin from "./featuresPlugin";
+import rebuildPlugin from "./rebuildPlugin.js";
+export default (config, entryPoints, testName) => {
+    const { inputFilesPluginFactory, register } = inputFilesPlugin("node", testName);
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: `testeranto/bundles/node/${testName}/`, 
+        // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
+        metafile: true, supported: {
+            "dynamic-import": true,
+        }, define: {
+            "process.env.FLUENTFFMPEG_COV": "0",
+        }, absWorkingDir: process.cwd(), banner: {
+            js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
+        }, platform: "node", external: ["react", ...config.externals], entryPoints: [...entryPoints], plugins: [
+            featuresPlugin,
+            inputFilesPluginFactory,
+            rebuildPlugin("node"),
+            ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
+        ] });
+};

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

@@ -0,0 +1,37 @@
+import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin.js";
+import featuresPlugin from "./featuresPlugin.js";
+import { isBuiltin } from "node:module";
+import { consoleDetectorPlugin } from "./consoleDetectorPlugin.js";
+import rebuildPlugin from "./rebuildPlugin.js";
+export default (config, entryPoints, testName) => {
+    const { inputFilesPluginFactory, register } = inputFilesPlugin("pure", testName);
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { drop: [], splitting: true, outdir: `testeranto/bundles/pure/${testName}/`, 
+        // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
+        metafile: true, supported: {
+            "dynamic-import": true,
+        }, define: {
+            "process.env.FLUENTFFMPEG_COV": "0",
+        }, absWorkingDir: process.cwd(), banner: {
+            js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
+        }, platform: "node", external: ["react", ...config.externals], entryPoints: [...entryPoints], plugins: [
+            featuresPlugin,
+            inputFilesPluginFactory,
+            consoleDetectorPlugin,
+            // nativeImportDetectorPlugin,
+            {
+                name: "native-node-import-filter",
+                setup(build) {
+                    build.onResolve({ filter: /fs/ }, (args) => {
+                        if (isBuiltin(args.path)) {
+                            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 };
+                    });
+                },
+            },
+            rebuildPlugin("pure"),
+            ...((config.nodePlugins || []).map((p) => p(register, entryPoints)) ||
+                []),
+        ] });
+};

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

@@ -0,0 +1,14 @@
+import fs from "fs";
+export default (r) => {
+    return {
+        name: "rebuild-notify",
+        setup: (build) => {
+            build.onEnd((result) => {
+                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/esbuildConfigs/web.js

@@ -0,0 +1,43 @@
+import { polyfillNode } from "esbuild-plugin-polyfill-node";
+import path from "path";
+import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin.js";
+import featuresPlugin from "./featuresPlugin.js";
+import rebuildPlugin from "./rebuildPlugin.js";
+export default (config, entryPoints, testName) => {
+    const { inputFilesPluginFactory, register } = inputFilesPlugin("web", testName);
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { treeShaking: true, outdir: `testeranto/bundles/web/${testName}`, alias: {
+            react: path.resolve("./node_modules/react"),
+        }, metafile: true, external: [
+            "path",
+            "fs",
+            "stream",
+            "http",
+            "constants",
+            "net",
+            "assert",
+            "tls",
+            "os",
+            "child_process",
+            "readline",
+            "zlib",
+            "crypto",
+            "https",
+            "util",
+            "process",
+            "dns",
+        ], platform: "browser", entryPoints: [...entryPoints], loader: config.webLoaders, plugins: [
+            featuresPlugin,
+            inputFilesPluginFactory,
+            polyfillNode({
+            // You might need to configure specific Node.js modules you want to polyfill
+            // Example:
+            // modules: {
+            //   'util': true,
+            //   'fs': false,
+            // }
+            }),
+            rebuildPlugin("web"),
+            ...((config.webPlugins || []).map((p) => p(register, entryPoints)) || []),
+        ] });
+};

package/dist/module/src/init-docs.js

@@ -0,0 +1,4 @@
+import Init from "./Init";
+console.log("Initializing a testeranto project");
+Init();
+console.log("testeranto project initialized");

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

@@ -0,0 +1,172 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { afterEachProxy, beforeEachProxy } from "./pmProxy.js";
+export class BaseGiven {
+    addArtifact(path) {
+        if (typeof path !== "string") {
+            throw new Error(`[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(path)}`);
+        }
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
+    }
+    constructor(features, whens, thens, givenCB, initialValues) {
+        this.artifacts = [];
+        this.features = features;
+        this.whens = whens;
+        this.thens = thens;
+        this.givenCB = givenCB;
+        this.initialValues = initialValues;
+        this.fails = 0; // Initialize fail count
+    }
+    beforeAll(store) {
+        return store;
+    }
+    toObj() {
+        return {
+            key: this.key,
+            whens: (this.whens || []).map((w) => {
+                if (w && w.toObj)
+                    return w.toObj();
+                console.error("When step is not as expected!", JSON.stringify(w));
+                return {};
+            }),
+            thens: (this.thens || []).map((t) => (t && t.toObj ? t.toObj() : {})),
+            error: this.error ? [this.error, this.error.stack] : null,
+            failed: this.failed,
+            features: this.features || [],
+            artifacts: this.artifacts,
+            status: this.status,
+        };
+    }
+    async afterEach(store, key, artifactory, pm) {
+        return store;
+    }
+    async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm, suiteNdx) {
+        this.key = key;
+        this.fails = 0; // Initialize fail count for this given
+        tLog(`\n ${this.key}`);
+        tLog(`\n Given: ${this.key}`);
+        const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
+        this.uberCatcher((e) => {
+            console.error(e.toString());
+            this.error = e.error;
+            tLog(e.stack);
+        });
+        try {
+            // Ensure addArtifact is properly bound to 'this'
+            const addArtifact = this.addArtifact.bind(this);
+            const proxiedPm = beforeEachProxy(pm, suiteNdx.toString(), addArtifact);
+            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues, proxiedPm);
+            this.status = true;
+        }
+        catch (e) {
+            this.status = false;
+            // console.error("Given failure: ", e.stack);
+            this.failed = true;
+            this.fails++; // Increment fail count
+            this.error = e.stack;
+            // throw e;
+        }
+        try {
+            const whens = this.whens || [];
+            // console.log(`[BaseGiven.give] Number of when steps: ${whens.length}`);
+            // if (whens.length > 0) {
+            //   // console.log(`[BaseGiven.give] When steps exist, let's process them`);
+            //   for (const [whenNdx, whenStep] of whens.entries()) {
+            //     // console.log(
+            //     //   `[BaseGiven.give] Processing when step ${whenNdx}:`,
+            //     //   whenStep?.name
+            //     // );
+            //     // console.log(`[BaseGiven.give] Store before when step:`, this.store);
+            //     // console.log(`[BaseGiven.give] When step instance:`, whenStep);
+            //     // Check if this is actually a then step that was incorrectly placed in whens
+            //     // if (
+            //     //   whenStep &&
+            //     //   whenStep.name &&
+            //     //   whenStep.name.startsWith("result:")
+            //     // ) {
+            //     //   // console.error(
+            //     //   //   `[BaseGiven.give] ERROR: Found then step "${whenStep.name}" in whens array!`
+            //     //   // );
+            //     //   // Move it to thens array
+            //     //   this.thens.push(whenStep);
+            //     //   // console.log(
+            //     //   //   `[BaseGiven.give] Moved "${whenStep.name}" from whens to thens`
+            //     //   // );
+            //     //   continue; // Skip processing as a when step
+            //     // }
+            //     // // Check if whenStep exists and whenStep.test is a function
+            //     // if (whenStep && typeof whenStep.test === "function") {
+            //     //   try {
+            //     //     // Update the store with the result of the when step
+            //     //     this.store = await whenStep.test(
+            //     //       this.store,
+            //     //       testResourceConfiguration,
+            //     //       tLog,
+            //     //       pm,
+            //     //       `suite-${suiteNdx}/given-${key}/when/${whenNdx}`
+            //     //     );
+            //     //     // console.log(
+            //     //     //   `[BaseGiven.give] Store after when step ${whenNdx}:`,
+            //     //     //   this.store
+            //     //     // );
+            //     //   } catch (e) {
+            //     //     // console.error(
+            //     //     //   `[BaseGiven.give] Error in when step ${whenNdx}:`,
+            //     //     //   e
+            //     //     // );
+            //     //     this.failed = true;
+            //     //     this.fails++; // Increment fail count
+            //     //     throw e;
+            //     //   }
+            //     // } else {
+            //     //   // console.error(
+            //     //   //   `[BaseGiven.give] whenStep.test is not a function:`,
+            //     //   //   typeof whenStep?.test
+            //     //   // );
+            //     //   this.failed = true;
+            //     //   this.fails++; // Increment fail count
+            //     //   throw new Error(`When step ${whenNdx} does not have a test method`);
+            //     // }
+            //   }
+            // } else {
+            //   console.log(`[BaseGiven.give] No when steps to process`);
+            // }
+            for (const [thenNdx, thenStep] of this.thens.entries()) {
+                try {
+                    const t = await thenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/then-${thenNdx}`);
+                    // If the test doesn't throw, it passed
+                    tester(t);
+                }
+                catch (e) {
+                    // Mark the given as failed if any then step fails
+                    this.failed = true;
+                    this.fails++; // Increment fail count
+                    // Re-throw to propagate the error
+                    throw e;
+                }
+            }
+        }
+        catch (e) {
+            this.error = e.stack;
+            this.failed = true;
+            // tLog(e.stack);
+            // throw e;
+        }
+        finally {
+            try {
+                const addArtifact = this.addArtifact.bind(this);
+                const proxiedPm = afterEachProxy(pm, suiteNdx.toString(), key, addArtifact);
+                // (proxiedPm as any).currentStep = this;
+                await this.afterEach(this.store, this.key, givenArtifactory, proxiedPm);
+            }
+            catch (e) {
+                this.failed = true;
+                this.fails++; // Increment fail count
+                throw e;
+                // this.error = e.message;
+            }
+        }
+        return this.store;
+    }
+}

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

@@ -0,0 +1,134 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { beforeAllProxy, afterAllProxy } from "./pmProxy";
+export class BaseSuite {
+    addArtifact(path) {
+        if (typeof path !== "string") {
+            throw new Error(`[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(path)}`);
+        }
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
+    }
+    constructor(name, index, givens = {}) {
+        this.artifacts = [];
+        const suiteName = name || "testSuite"; // Ensure name is never undefined
+        if (!suiteName) {
+            throw new Error("BaseSuite requires a non-empty name");
+        }
+        this.name = suiteName;
+        this.index = index;
+        this.givens = givens;
+        this.fails = 0;
+    }
+    features() {
+        try {
+            const features = Object.keys(this.givens)
+                .map((k) => this.givens[k].features)
+                .flat()
+                .filter((value, index, array) => {
+                return array.indexOf(value) === index;
+            });
+            // Convert all features to strings
+            const stringFeatures = features.map((feature) => {
+                if (typeof feature === "string") {
+                    return feature;
+                }
+                else if (feature && typeof feature === "object") {
+                    return feature.name || JSON.stringify(feature);
+                }
+                else {
+                    return String(feature);
+                }
+            });
+            return stringFeatures || [];
+        }
+        catch (e) {
+            console.error("[ERROR] Failed to extract features:", JSON.stringify(e));
+            return [];
+        }
+    }
+    toObj() {
+        const givens = Object.keys(this.givens).map((k) => {
+            const givenObj = this.givens[k].toObj();
+            // Ensure given features are strings
+            // if (givenObj.features) {
+            //   givenObj.features = givenObj.features.map(feature => {
+            //     return feature;
+            //     // if (typeof feature === 'string') {
+            //     //   return feature;
+            //     // } else if (feature && typeof feature === 'object') {
+            //     //   return feature.name || JSON.stringify(feature);
+            //     // } else {
+            //     //   return String(feature);
+            //     // }
+            //   });
+            // }
+            return givenObj;
+        });
+        return {
+            name: this.name,
+            givens,
+            fails: this.fails,
+            failed: this.failed,
+            features: this.features(),
+            artifacts: this.artifacts
+                ? this.artifacts.filter((art) => typeof art === "string")
+                : [],
+        };
+    }
+    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;
+        // Ensure addArtifact is properly bound to 'this'
+        const addArtifact = this.addArtifact.bind(this);
+        const proxiedPm = beforeAllProxy(pm, sNdx.toString(), addArtifact);
+        const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, proxiedPm);
+        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);
+                // Add the number of failures from this given to the suite's total
+                this.fails += giver.fails || 0;
+            }
+            catch (e) {
+                this.failed = true;
+                // Add 1 to fails for the caught error
+                this.fails += 1;
+                // Also add any failures from the given itself
+                if (giver.fails) {
+                    this.fails += giver.fails;
+                }
+                console.error(`Error in given ${gKey}:`, e);
+                // Don't re-throw to continue with other givens
+            }
+        }
+        // Mark the suite as failed if there are any failures
+        if (this.fails > 0) {
+            this.failed = true;
+        }
+        try {
+            // Ensure addArtifact is properly bound to 'this'
+            const addArtifact = this.addArtifact.bind(this);
+            const afterAllPm = afterAllProxy(pm, sNdx.toString(), addArtifact);
+            this.afterAll(this.store, artifactory, afterAllPm);
+        }
+        catch (e) {
+            console.error(JSON.stringify(e));
+            // this.fails.push(this);
+            // return this;
+        }
+        return this;
+    }
+}

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

@@ -0,0 +1,61 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { BaseGiven } from "../BaseGiven";
+import { BaseSuite } from "../BaseSuite";
+import { BaseThen } from "../BaseThen";
+import { BaseWhen } from "../BaseWhen";
+export class MockGiven extends BaseGiven {
+    constructor(name, features, whens, thens) {
+        super(name, features, whens, thens, async () => ({ testStore: true, testSelection: false }), // givenCB
+        {} // initialValues
+        );
+    }
+    async givenThat() {
+        return { testStore: true, testSelection: false };
+    }
+    uberCatcher(e) {
+        console.error("Given error 2:", e);
+    }
+}
+export class MockWhen extends BaseWhen {
+    async andWhen(store, whenCB, testResource, pm) {
+        // Create a TestSelection from the store
+        const selection = {
+            testSelection: store.testStore,
+            testStore: store.testStore
+        };
+        // Call whenCB with the selection
+        await whenCB(selection);
+        return store;
+    }
+    addArtifact(path) {
+        // Mock implementation
+    }
+}
+export class MockThen extends BaseThen {
+    async butThen(store, thenCB, testResourceConfiguration, pm) {
+        // Create a TestSelection from the store
+        const selection = {
+            testSelection: store.testStore,
+            testStore: store.testStore
+        };
+        // Call thenCB with the selection
+        await thenCB(selection);
+        return selection;
+    }
+}
+export class MockSuite extends BaseSuite {
+    constructor(name, index) {
+        if (!name) {
+            throw new Error("MockSuite requires a non-empty name");
+        }
+        const suiteName = name || "testSuite";
+        super(suiteName, index, {
+            testGiven: new MockGiven("testGiven", ["testFeature"], [
+                new MockWhen("testWhen", async () => Promise.resolve({ testSelection: true })),
+            ], [
+                new MockThen("testThen", async () => Promise.resolve(new BaseSuite("temp", 0, {}))),
+            ]),
+        });
+    }
+}

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

@@ -0,0 +1,5 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+import Testeranto from "../../Node";
+import { BaseSuite } from "../BaseSuite";
+import { implementation, specification, testAdapter } from "./test";
+export default Testeranto(BaseSuite, specification, implementation, testAdapter);

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

@@ -0,0 +1,5 @@
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+import Testeranto from "../../Pure";
+import { BaseSuite } from "../BaseSuite";
+import { implementation, specification, testAdapter } from "./test";
+export default Testeranto(BaseSuite, specification, implementation, testAdapter);