testeranto 0.219.17 → 0.219.19

package/dist/common/allTestsUtils.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLangConfig = void 0;
+const createLangConfig = (testFile, checks, dockerfile, options) => {
+    return {
+        plugins: (options === null || options === void 0 ? void 0 : options.plugins) || [],
+        loaders: (options === null || options === void 0 ? void 0 : options.loaders) || {},
+        tests: { [testFile]: { ports: 0 } },
+        externals: (options === null || options === void 0 ? void 0 : options.externals) || [],
+        test: options === null || options === void 0 ? void 0 : options.testBlocks,
+        prod: options === null || options === void 0 ? void 0 : options.prodBlocks,
+        checks,
+        volumes: options === null || options === void 0 ? void 0 : options.volumes,
+        dockerfile,
+    };
+};
+exports.createLangConfig = createLangConfig;

package/dist/common/scripts/build-example.js

@@ -0,0 +1,105 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+console.log("Building example project (ES module version)...");
+try {
+    // Always work from the project root
+    const projectRoot = path_1.default.resolve(import.meta.dirname, "..");
+    console.log(`Project root: ${projectRoot}`);
+    // Change to project root
+    process.chdir(projectRoot);
+    console.log(`Current working directory (build-example): ${projectRoot}`);
+    // The example directory is now relative to project root
+    const exampleDir = path_1.default.join(projectRoot, "example");
+    console.log(`Example directory: ${exampleDir}`);
+    // Ensure go.mod exists - create one if it doesn't
+    const goModPath = path_1.default.join(exampleDir, "go.mod");
+    if (!fs_1.default.existsSync(goModPath)) {
+        console.log("go.mod not found, creating a new one...");
+        const defaultGoMod = `module example
+
+go 1.19
+`;
+        fs_1.default.writeFileSync(goModPath, defaultGoMod);
+        console.log("Created default go.mod");
+    }
+    else {
+        // Read the existing go.mod and remove any replace directives
+        let goModContent = fs_1.default.readFileSync(goModPath, "utf8");
+        // Remove any replace directives that might cause issues
+        const lines = goModContent.split('\n').filter(line => !line.trim().startsWith('replace '));
+        // Also remove any require directives for testeranto
+        const cleanedLines = lines.filter(line => !line.trim().startsWith('require github.com/adamwong246/testeranto'));
+        goModContent = cleanedLines.join('\n');
+        fs_1.default.writeFileSync(goModPath, goModContent);
+        console.log("Cleaned up go.mod by removing replace and testeranto require directives");
+    }
+    // Read the current go.mod content
+    let goModContent = fs_1.default.readFileSync(goModPath, "utf8");
+    // Ensure the module is properly set up
+    if (!goModContent.includes("module ")) {
+        console.log("Initializing go module...");
+        (0, child_process_1.execSync)("go mod init example", {
+            stdio: "pipe",
+            cwd: exampleDir,
+        });
+        // Re-read the content
+        goModContent = fs_1.default.readFileSync(goModPath, "utf8");
+    }
+    // Add the replace directive to point to the local testeranto
+    // This tells Go to use the local directory instead of trying to download from GitHub
+    if (!goModContent.includes("replace github.com/adamwong246/testeranto")) {
+        console.log("Adding replace directive...");
+        (0, child_process_1.execSync)("go mod edit -replace github.com/adamwong246/testeranto=../", {
+            stdio: "pipe",
+            cwd: exampleDir,
+        });
+    }
+    // Add the require directive to explicitly list the dependency
+    // This ensures the dependency is tracked even if it's not imported directly in the example
+    console.log("Adding require directive...");
+    try {
+        (0, child_process_1.execSync)("go mod edit -require github.com/adamwong246/testeranto@v0.0.0", {
+            stdio: "pipe",
+            cwd: exampleDir,
+        });
+    }
+    catch (error) {
+        // It's okay if this fails - the require might already be there
+        console.log("Require directive may already exist");
+    }
+    // Read the updated content
+    goModContent = fs_1.default.readFileSync(goModPath, "utf8");
+    console.log("Updated go.mod content:");
+    console.log(goModContent);
+    // Run go mod tidy to ensure dependencies are correct
+    console.log("Running go mod tidy...");
+    try {
+        const tidyOutput = (0, child_process_1.execSync)("go mod tidy -v", {
+            stdio: "pipe",
+            encoding: "utf-8",
+            cwd: exampleDir,
+        });
+        console.log("go mod tidy output:");
+        console.log(tidyOutput);
+    }
+    catch (error) {
+        console.error("go mod tidy failed:");
+        if (error.stdout)
+            console.error("stdout:", error.stdout.toString());
+        if (error.stderr)
+            console.error("stderr:", error.stderr.toString());
+        console.error("Continuing despite go mod tidy error...");
+    }
+    console.log("Example project built successfully!");
+}
+catch (error) {
+    console.error("Failed to build example project:");
+    console.error(error);
+    process.exit(1);
+}

package/dist/common/src/Init.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+exports.default = async () => {
+    [
+        `testeranto/`,
+        `testeranto/bundles/`,
+        `testeranto/bundles/node`,
+        `testeranto/bundles/web`,
+        `testeranto/bundles/pure`,
+        `testeranto/bundles/golang`,
+        `testeranto/bundles/python`,
+        `testeranto/reports/`,
+        `testeranto/features/`,
+        `testeranto/metafiles/`,
+        `testeranto/metafiles/node`,
+        `testeranto/metafiles/web`,
+        `testeranto/metafiles/pure`,
+        `testeranto/metafiles/golang`,
+        `testeranto/metafiles/python`,
+    ].forEach((f) => {
+        try {
+            fs_1.default.mkdirSync(`${process.cwd()}/${f}`);
+        }
+        catch (e) {
+            console.error(e);
+        }
+    });
+    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/Report.js`, `testeranto/Report.js`);
+    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/Report.css`, `testeranto/Report.css`);
+    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/ProcessManager.js`, `testeranto/ProcessManager.js`);
+    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/ProcessManager.css`, `testeranto/ProcessManager.css`);
+    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/Features.js`, `testeranto/ProcessManager.js`);
+    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/Features.css`, `testeranto/ProcessManager.css`);
+};

package/dist/common/src/Types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consoleDetectorPlugin = void 0;
+const fs_1 = __importDefault(require("fs"));
+exports.consoleDetectorPlugin = {
+    name: "console-detector",
+    setup(build) {
+        build.onLoad({ filter: /\.(js|ts)$/ }, async (args) => {
+            const contents = await fs_1.default.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/common/src/esbuildConfigs/eslint-formatter-testeranto.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = default_1;
+function default_1(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/common/src/esbuildConfigs/featuresPlugin.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+exports.default = {
+    name: "feature-markdown",
+    setup(build) {
+        build.onResolve({ filter: /\.md$/ }, (args) => {
+            if (args.resolveDir === "")
+                return;
+            return {
+                path: path_1.default.isAbsolute(args.path)
+                    ? args.path
+                    : path_1.default.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/common/src/esbuildConfigs/index.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// import { ITestconfig } from "../Types";
+exports.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/common/src/esbuildConfigs/inputFilesPlugin.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const otherInputs = {};
+const register = (entrypoint, sources) => {
+    if (!otherInputs[entrypoint]) {
+        otherInputs[entrypoint] = new Set();
+    }
+    sources.forEach((s) => otherInputs[entrypoint].add(s));
+};
+exports.default = (platform, testName) => {
+    const f = `${testName}`;
+    // if (!fs.existsSync(``)) {
+    //   fs.mkdirSync(``, { recursive: true });
+    // }
+    return {
+        register,
+        inputFilesPluginFactory: {
+            name: "metafileWriter",
+            setup(build) {
+                build.onEnd((result) => {
+                    fs_1.default.writeFileSync(f, JSON.stringify(result, null, 2));
+                });
+            },
+        },
+    };
+};

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nativeImportDetectorPlugin = void 0;
+const node_module_1 = require("node:module");
+exports.nativeImportDetectorPlugin = {
+    name: "native-node-import-filter",
+    setup(build) {
+        build.onResolve({ filter: /fs/ }, (args) => {
+            if ((0, node_module_1.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/common/src/esbuildConfigs/rebuildPlugin.js

@@ -0,0 +1,19 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+exports.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_1.default.writeFileSync(`./testeranto/reports${r}_build_errors`, JSON.stringify(result, null, 2));
+                }
+            });
+        },
+    };
+};

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

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Init_1 = __importDefault(require("./Init"));
+console.log("Initializing a testeranto project");
+(0, Init_1.default)();
+console.log("testeranto project initialized");

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseGiven = void 0;
+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;
+    }
+}
+exports.BaseGiven = BaseGiven;

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSuite = void 0;
+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;
+    }
+}
+exports.BaseSuite = BaseSuite;

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseThen = void 0;
+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;
+        }
+    }
+}
+exports.BaseThen = BaseThen;