testeranto 0.219.14 → 0.219.15

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

@@ -1,32 +0,0 @@
-import fs from "fs";
-export const consoleDetectorPlugin = {
-    name: "console-detector",
-    setup(build) {
-        build.onLoad({ filter: /\.(js|ts)$/ }, async (args) => {
-            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: `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/eslint-formatter-testeranto.js

@@ -1,18 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

@@ -1,20 +0,0 @@
-// import { ITestconfig } from "../Types";
-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

@@ -1,25 +0,0 @@
-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 = `${testName}`;
-    // if (!fs.existsSync(``)) {
-    //   fs.mkdirSync(``, { 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

@@ -1,21 +0,0 @@
-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/rebuildPlugin.js

@@ -1,14 +0,0 @@
-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/init-docs.js

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

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

@@ -1,92 +0,0 @@
-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) {
-        return store;
-    }
-    async give(subject, key, testResourceConfiguration, tester, artifactory, suiteNdx) {
-        this.key = key;
-        this.fails = 0; // Initialize fail count for this given
-        const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
-        try {
-            // Ensure addArtifact is properly bound to 'this'
-            const addArtifact = this.addArtifact.bind(this);
-            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues);
-            this.status = true;
-        }
-        catch (e) {
-            this.status = false;
-            this.failed = true;
-            this.fails++; // Increment fail count
-            this.error = e.stack;
-        }
-        try {
-            const whens = this.whens || [];
-            for (const [thenNdx, thenStep] of this.thens.entries()) {
-                try {
-                    const t = await thenStep.test(this.store, testResourceConfiguration, `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;
-        }
-        finally {
-            try {
-                const addArtifact = this.addArtifact.bind(this);
-                await this.afterEach(this.store, this.key);
-            }
-            catch (e) {
-                this.failed = true;
-                this.fails++; // Increment fail count
-                throw e;
-                // this.error = e.message;
-            }
-        }
-        return this.store;
-    }
-}

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

@@ -1,130 +0,0 @@
-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: IPM
-    ) {
-        console.log("mark9");
-        return new Promise((res) => res(s));
-    }
-    assertThat(t) {
-        return !!t;
-    }
-    afterAll(store, artifactory) {
-        return store;
-    }
-    async run(input, testResourceConfiguration) {
-        this.testResourceConfiguration = testResourceConfiguration;
-        const sNdx = this.index;
-        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, 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'
-            this.afterAll(this.store);
-        }
-        catch (e) {
-            console.error(JSON.stringify(e));
-            // this.fails.push(this);
-            // return this;
-        }
-        return this;
-    }
-}

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

@@ -1,61 +0,0 @@
-export class BaseThen {
-    constructor(name, thenCB) {
-        this.artifacts = [];
-        this.name = name;
-        this.thenCB = thenCB;
-        this.error = false;
-        this.artifacts = [];
-    }
-    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);
-    }
-    toObj() {
-        const obj = {
-            name: this.name,
-            error: this.error,
-            artifacts: this.artifacts,
-            status: this.status,
-        };
-        return obj;
-    }
-    async test(store, testResourceConfiguration, 
-    // tLog: ITLog,
-    // pm: IPM,
-    filepath) {
-        // Ensure addArtifact is properly bound to 'this'
-        const addArtifact = this.addArtifact.bind(this);
-        // const proxiedPm = butThenProxy(pm, filepath, addArtifact);
-        try {
-            const x = await this.butThen(store, async (s) => {
-                try {
-                    if (typeof this.thenCB === "function") {
-                        const result = await this.thenCB(s);
-                        return result;
-                    }
-                    else {
-                        return this.thenCB;
-                    }
-                }
-                catch (e) {
-                    // Mark this then step as failed
-                    this.error = true;
-                    // Re-throw to be caught by the outer catch block
-                    throw e;
-                }
-            }, testResourceConfiguration
-            // proxiedPm
-            );
-            this.status = true;
-            return x;
-        }
-        catch (e) {
-            this.status = false;
-            this.error = true;
-            throw e;
-        }
-    }
-}

package/dist/module/src/lib/tiposkripto/BaseTiposkripto.js

@@ -1,190 +0,0 @@
-import { BaseGiven } from "./BaseGiven";
-import { BaseSuite } from "./BaseSuite";
-import { BaseThen } from "./BaseThen.js";
-import { BaseWhen } from "./BaseWhen.js";
-import { DefaultAdapter, defaultTestResourceRequirement, } from "./index.js";
-export default class BaseTiposkripto {
-    constructor(webOrNode, input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testAdapter = {}, testResourceConfiguration, wsPort = "3456", wsHost = "localhost") {
-        this.totalTests = 0;
-        this.artifacts = [];
-        this.testResourceConfiguration = testResourceConfiguration;
-        const fullAdapter = DefaultAdapter(testAdapter);
-        if (!testImplementation.suites ||
-            typeof testImplementation.suites !== "object") {
-            throw new Error(`testImplementation.suites must be an object, got ${typeof testImplementation.suites}: ${JSON.stringify(testImplementation.suites)}`);
-        }
-        const classySuites = Object.entries(testImplementation.suites).reduce((a, [key], index) => {
-            a[key] = (somestring, givens) => {
-                return new (class extends BaseSuite {
-                    afterAll(store) {
-                        return fullAdapter.afterAll(store);
-                    }
-                    assertThat(t) {
-                        return fullAdapter.assertThis(t);
-                    }
-                    async setup(s, tr) {
-                        var _a, _b;
-                        return ((_b = (_a = fullAdapter.beforeAll) === null || _a === void 0 ? void 0 : _a.call(fullAdapter, s, tr)) !== null && _b !== void 0 ? _b : s);
-                    }
-                })(somestring, index, givens);
-            };
-            return a;
-        }, {});
-        const classyGivens = Object.entries(testImplementation.givens).reduce((a, [key, g]) => {
-            a[key] = (features, whens, thens, gcb, initialValues) => {
-                // WTF
-                // Ensure parameters are arrays and create copies to avoid reference issues
-                const safeFeatures = Array.isArray(features) ? [...features] : [];
-                const safeWhens = Array.isArray(whens) ? [...whens] : [];
-                const safeThens = Array.isArray(thens) ? [...thens] : [];
-                return new (class extends BaseGiven {
-                    async givenThat(subject, testResource, initializer, initialValues) {
-                        return fullAdapter.beforeEach(subject, initializer, testResource, initialValues);
-                    }
-                    afterEach(store, key) {
-                        return Promise.resolve(fullAdapter.afterEach(store, key));
-                    }
-                })(safeFeatures, safeWhens, safeThens, testImplementation.givens[key], initialValues);
-            };
-            return a;
-        }, {});
-        const classyWhens = Object.entries(testImplementation.whens).reduce((a, [key, whEn]) => {
-            a[key] = (...payload) => {
-                const whenInstance = new (class extends BaseWhen {
-                    async andWhen(store, whenCB, testResource) {
-                        return await fullAdapter.andWhen(store, whenCB, testResource);
-                    }
-                })(`${key}: ${payload && payload.toString()}`, whEn(...payload));
-                return whenInstance;
-            };
-            return a;
-        }, {});
-        const classyThens = Object.entries(testImplementation.thens).reduce((a, [key, thEn]) => {
-            a[key] = (...args) => {
-                const thenInstance = new (class extends BaseThen {
-                    async butThen(store, thenCB, testResource) {
-                        return await fullAdapter.butThen(store, thenCB, testResource);
-                    }
-                })(`${key}: ${args && args.toString()}`, thEn(...args));
-                return thenInstance;
-            };
-            return a;
-        }, {});
-        this.suitesOverrides = classySuites;
-        this.givenOverrides = classyGivens;
-        this.whenOverrides = classyWhens;
-        this.thenOverrides = classyThens;
-        this.testResourceRequirement = testResourceRequirement;
-        this.testSpecification = testSpecification;
-        this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then());
-        this.totalTests = this.calculateTotalTests();
-        this.testJobs = this.specs.map((suite) => {
-            const suiteRunner = (suite) => async (testResourceConfiguration) => {
-                try {
-                    const x = await suite.run(input, testResourceConfiguration || {
-                        name: suite.name,
-                        fs: process.cwd(),
-                        ports: [],
-                        timeout: 30000,
-                        retries: 3,
-                        environment: {},
-                    });
-                    return x;
-                }
-                catch (e) {
-                    console.error(e.stack);
-                    throw e;
-                }
-            };
-            const runner = suiteRunner(suite);
-            const totalTests = this.totalTests;
-            const testJob = {
-                test: suite,
-                toObj: () => {
-                    return suite.toObj();
-                },
-                runner,
-                receiveTestResourceConfig: async (testResourceConfiguration) => {
-                    try {
-                        const suiteDone = await runner(testResourceConfiguration);
-                        const fails = suiteDone.fails;
-                        return {
-                            failed: fails > 0,
-                            fails,
-                            artifacts: [], // this.artifacts is not accessible here
-                            features: suiteDone.features(),
-                            tests: 0,
-                            runTimeTests: totalTests,
-                            testJob: testJob.toObj(),
-                        };
-                    }
-                    catch (e) {
-                        console.error(e.stack);
-                        return {
-                            failed: true,
-                            fails: -1,
-                            artifacts: [],
-                            features: [],
-                            tests: 0,
-                            runTimeTests: -1,
-                            testJob: testJob.toObj(),
-                        };
-                    }
-                },
-            };
-            return testJob;
-        });
-        this.testJobs[0].receiveTestResourceConfig(testResourceConfiguration).then((results) => {
-            // The actual path is determined by the concrete implementation (Node.ts or Web.ts)
-            // They will write to the correct pattern: testeranto/reports/allTests/example/${runtime}.Calculator.test.ts.json
-            // We just pass a placeholder filename webOrNode
-            this.writeFileSync(`testeranto/reports/allTests/example/${webOrNode}/Calculator.test.ts.json`, JSON.stringify(results));
-        });
-    }
-    async receiveTestResourceConfig(testResourceConfig) {
-        if (this.testJobs && this.testJobs.length > 0) {
-            return this.testJobs[0].receiveTestResourceConfig(testResourceConfig);
-        }
-        else {
-            throw new Error("No test jobs available");
-        }
-    }
-    Specs() {
-        return this.specs;
-    }
-    Suites() {
-        if (!this.suitesOverrides) {
-            throw new Error(`suitesOverrides is undefined. classySuites: ${JSON.stringify(Object.keys(this.suitesOverrides || {}))}`);
-        }
-        return this.suitesOverrides;
-    }
-    Given() {
-        return this.givenOverrides;
-    }
-    When() {
-        return this.whenOverrides;
-    }
-    Then() {
-        return this.thenOverrides;
-    }
-    // Add a method to access test jobs which can be used by receiveTestResourceConfig
-    getTestJobs() {
-        return this.testJobs;
-    }
-    calculateTotalTests() {
-        let total = 0;
-        for (const suite of this.specs) {
-            if (suite && typeof suite === "object") {
-                // Access the givens property which should be a record of test names to BaseGiven instances
-                // The givens property is typically on the suite instance
-                if ("givens" in suite) {
-                    const givens = suite.givens;
-                    if (givens && typeof givens === "object") {
-                        total += Object.keys(givens).length;
-                    }
-                }
-            }
-        }
-        return total;
-    }
-}