testeranto 0.202.0 → 0.205.0

package/dist/module/example/Calculator.js

@@ -0,0 +1,101 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export class Calculator {
+    constructor() {
+        this.display = "";
+        this.values = {};
+        this.id = Math.random(); // Add a unique ID to track instances
+    }
+    press(button) {
+        this.display = this.display + button;
+        return this;
+    }
+    enter() {
+        try {
+            // Simple expression evaluation
+            // Note: Using eval is not recommended for production code
+            // This is just for testing purposes
+            const result = eval(this.display);
+            this.display = result.toString();
+        }
+        catch (error) {
+            this.display = "Error";
+            throw error;
+        }
+    }
+    memoryStore() {
+        this.setValue("memory", parseFloat(this.display) || 0);
+        this.clear();
+    }
+    memoryRecall() {
+        const memoryValue = this.getValue("memory") || 0;
+        this.display = memoryValue.toString();
+    }
+    memoryClear() {
+        this.setValue("memory", 0);
+    }
+    memoryAdd() {
+        const currentValue = parseFloat(this.display) || 0;
+        const memoryValue = this.getValue("memory") || 0;
+        this.setValue("memory", memoryValue + currentValue);
+        this.clear();
+    }
+    handleSpecialButton(button) {
+        switch (button) {
+            case "C":
+                this.clear();
+                return true;
+            case "MS":
+                this.memoryStore();
+                return true;
+            case "MR":
+                this.memoryRecall();
+                return true;
+            case "MC":
+                this.memoryClear();
+                return true;
+            case "M+":
+                this.memoryAdd();
+                return true;
+            default:
+                return false;
+        }
+    }
+    press(button) {
+        // Handle special buttons first
+        if (this.handleSpecialButton(button)) {
+            return this;
+        }
+        // For regular buttons, append to display
+        this.display = this.display + button;
+        return this;
+    }
+    getDisplay() {
+        return this.display;
+    }
+    clear() {
+        this.display = "";
+    }
+    // Keep these methods for backward compatibility if needed
+    add(a, b) {
+        return a + b;
+    }
+    subtract(a, b) {
+        return a - b;
+    }
+    multiply(a, b) {
+        return a * b;
+    }
+    divide(a, b) {
+        if (b === 0) {
+            throw new Error("Cannot divide by zero");
+        }
+        return a / b;
+    }
+    setValue(identifier, value) {
+        this.values[identifier] = value;
+    }
+    getValue(identifier) {
+        var _a;
+        return (_a = this.values[identifier]) !== null && _a !== void 0 ? _a : null;
+    }
+}

package/dist/module/example/Calculator.test.adapter.js

@@ -0,0 +1,36 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+export const adapter = {
+    beforeAll: async (input, testResource, pm) => {
+        return input;
+    },
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const result = await initializer();
+        return result;
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        // The whenCB should be a function that returns a function which takes the store
+        // For press("2"), whenCB is (calculator) => { calculator.press("2"); return calculator; }
+        const transform = whenCB;
+        const result = transform(store);
+        return result;
+    },
+    butThen: async (store, thenCB, testResource, pm) => {
+        thenCB(store);
+        const display = store.getDisplay();
+        return display;
+    },
+    afterEach: async (store, key, pm) => {
+        // Clean up if needed
+        return store;
+    },
+    afterAll: async (store, pm) => {
+        // Clean up if needed
+        return store;
+    },
+    assertThis: (actual) => {
+        // The actual value comes from butThen which returns the display
+        // We don't need to do anything here as assertions are done in thenCB
+        return actual;
+    },
+};

package/dist/module/example/Calculator.test.implementation.js

@@ -0,0 +1,47 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// import { ITestImplementation } from "testeranto/src/CoreTypes";
+import { Calculator } from "./Calculator";
+import { assert } from "chai";
+export const implementation = {
+    suites: {
+        Default: "Default test suite for Calculator",
+    },
+    givens: {
+        Default: () => {
+            const calc = new Calculator();
+            return calc;
+        },
+    },
+    whens: {
+        press: (button) => (calculator) => {
+            const result = calculator.press(button);
+            return result;
+        },
+        enter: () => (calculator) => {
+            calculator.enter();
+            return calculator;
+        },
+        memoryStore: () => (calculator) => {
+            calculator.memoryStore();
+            return calculator;
+        },
+        memoryRecall: () => (calculator) => {
+            calculator.memoryRecall();
+            return calculator;
+        },
+        memoryClear: () => (calculator) => {
+            calculator.memoryClear();
+            return calculator;
+        },
+        memoryAdd: () => (calculator) => {
+            calculator.memoryAdd();
+            return calculator;
+        },
+    },
+    thens: {
+        result: (expected) => (calculator) => {
+            assert.equal(calculator.getDisplay(), expected);
+        },
+    },
+};

package/dist/module/example/Calculator.test.js

@@ -0,0 +1,6 @@
+import Testeranto from "testeranto/src/Node";
+import { specification } from "./Calculator.test.specification";
+import { implementation } from "./Calculator.test.implementation";
+import { adapter } from "./Calculator.test.adapter";
+import { Calculator } from "./Calculator";
+export default Testeranto(Calculator, specification, implementation, adapter);

package/dist/module/example/Calculator.test.specification.js

@@ -0,0 +1,88 @@
+export const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.Default("Testing Calculator operations", {
+            // Basic number input
+            testEmptyDisplay: Given.Default(["pressing nothing, the display is empty"], [], [Then.result("")]),
+            testSingleDigit: Given.Default(["entering a number puts it on the display"], [When.press("2")], [Then.result("2")]),
+            testMultipleDigits: Given.Default(["entering multiple digits concatenates them"], [When.press("2"), When.press("2")], [Then.result("22")]),
+            testLargeNumber: Given.Default(["entering a large number works correctly"], [When.press("1"), When.press("2"), When.press("3"), When.press("4"), When.press("5")], [Then.result("12345")]),
+            // Basic operations
+            testAdditionExpression: Given.Default(["addition expression is displayed correctly"], [When.press("2"), When.press("+"), When.press("3")], [Then.result("2+3")]),
+            testIncompleteAddition: Given.Default(["incomplete addition expression is displayed correctly"], [When.press("2"), When.press("+")], [Then.result("2+")]),
+            testSubtractionExpression: Given.Default(["subtraction expression is displayed correctly"], [When.press("7"), When.press("-"), When.press("3")], [Then.result("7-3")]),
+            testMultiplicationExpression: Given.Default(["multiplication expression is displayed correctly"], [When.press("4"), When.press("*"), When.press("5")], [Then.result("4*5")]),
+            testDivisionExpression: Given.Default(["division expression is displayed correctly"], [When.press("8"), When.press("/"), When.press("2")], [Then.result("8/2")]),
+            // Complex expressions
+            testMixedOperations: Given.Default(["mixed operations are displayed correctly"], [When.press("2"), When.press("+"), When.press("3"), When.press("*"), When.press("4")], [Then.result("2+3*4")]),
+            testLongExpression: Given.Default(["long complex expression is displayed correctly"], [
+                When.press("1"), When.press("+"), When.press("2"),
+                When.press("*"), When.press("3"), When.press("-"),
+                When.press("4"), When.press("/"), When.press("5")
+            ], [Then.result("1+2*3-4/5")]),
+            // Calculation tests
+            testSimpleAddition: Given.Default(["simple addition calculation"], [
+                When.press("2"), When.press("3"), When.press("+"),
+                When.press("4"), When.press("5"), When.enter()
+            ], [Then.result("68")]),
+            testSimpleSubtraction: Given.Default(["simple subtraction calculation"], [
+                When.press("9"), When.press("5"), When.press("-"),
+                When.press("3"), When.press("2"), When.enter()
+            ], [Then.result("63")]),
+            testSimpleMultiplication: Given.Default(["simple multiplication calculation"], [
+                When.press("6"), When.press("*"), When.press("7"),
+                When.enter()
+            ], [Then.result("42")]),
+            testSimpleDivision: Given.Default(["simple division calculation"], [
+                When.press("8"), When.press("4"), When.press("/"),
+                When.press("2"), When.enter()
+            ], [Then.result("42")]),
+            // Edge cases
+            testClearOperation: Given.Default(["clear operation resets the display"], [
+                When.press("1"), When.press("2"), When.press("3"),
+                When.press("C"), When.press("4")
+            ], [Then.result("4")]),
+            testStartingWithOperator: Given.Default(["starting with operator should work"], [When.press("+"), When.press("5")], [Then.result("+5")]),
+            testMultipleOperators: Given.Default(["multiple operators in sequence"], [When.press("5"), When.press("+"), When.press("-"), When.press("3")], [Then.result("5+-3")]),
+            // Decimal numbers
+            testDecimalInput: Given.Default(["decimal number input"], [When.press("3"), When.press("."), When.press("1"), When.press("4")], [Then.result("3.14")]),
+            testDecimalCalculation: Given.Default(["decimal calculation"], [
+                When.press("3"), When.press("."), When.press("1"), When.press("+"),
+                When.press("1"), When.press("."), When.press("8"), When.press("6"),
+                When.enter()
+            ], [Then.result("4.96")]),
+            // Complex calculations
+            testOrderOfOperations: Given.Default(["order of operations is respected"], [
+                When.press("2"), When.press("+"), When.press("3"),
+                When.press("*"), When.press("4"), When.enter()
+            ], [Then.result("14")]),
+            testParenthesesExpression: Given.Default(["parentheses in expression"], [
+                When.press("("), When.press("2"), When.press("+"),
+                When.press("3"), When.press(")"), When.press("*"),
+                When.press("4"), When.enter()
+            ], [Then.result("20")]),
+            // Error cases
+            testDivisionByZero: Given.Default(["division by zero shows error"], [
+                When.press("5"), When.press("/"), When.press("0"),
+                When.enter()
+            ], [Then.result("Error")]),
+            testInvalidExpression: Given.Default(["invalid expression shows error"], [
+                When.press("2"), When.press("+"), When.press("+"),
+                When.press("3"), When.enter()
+            ], [Then.result("Error")]),
+            // Memory functions
+            testMemoryStoreRecall: Given.Default(["memory store and recall"], [
+                When.press("1"), When.press("2"), When.press("3"),
+                When.press("MS"), When.press("C"), When.press("MR")
+            ], [Then.result("123")]),
+            testMemoryClear: Given.Default(["memory clear"], [
+                When.press("4"), When.press("5"), When.press("6"),
+                When.press("MS"), When.press("MC"), When.press("MR")
+            ], [Then.result("0")]),
+            testMemoryAddition: Given.Default(["memory addition"], [
+                When.press("1"), When.press("0"), When.press("M+"),
+                When.press("2"), When.press("0"), When.press("M+"),
+                When.press("MR")
+            ], [Then.result("30")])
+        }),
+    ];
+};

package/dist/module/example/Calculator.test.types.js

@@ -0,0 +1,2 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export {};

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

@@ -0,0 +1,100 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+console.log("Building example project (ES module version)...");
+try {
+    // Always work from the project root
+    const projectRoot = path.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.join(projectRoot, "example");
+    console.log(`Example directory: ${exampleDir}`);
+    // Ensure go.mod exists - create one if it doesn't
+    const goModPath = path.join(exampleDir, "go.mod");
+    if (!fs.existsSync(goModPath)) {
+        console.log("go.mod not found, creating a new one...");
+        const defaultGoMod = `module example
+
+go 1.19
+`;
+        fs.writeFileSync(goModPath, defaultGoMod);
+        console.log("Created default go.mod");
+    }
+    else {
+        // Read the existing go.mod and remove any replace directives
+        let goModContent = fs.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.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.readFileSync(goModPath, "utf8");
+    // Ensure the module is properly set up
+    if (!goModContent.includes("module ")) {
+        console.log("Initializing go module...");
+        execSync("go mod init example", {
+            stdio: "pipe",
+            cwd: exampleDir,
+        });
+        // Re-read the content
+        goModContent = fs.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...");
+        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 {
+        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.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 = 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/module/src/Helpo.js

@@ -0,0 +1,48 @@
+import React from "react";
+export const Helpo = () => (React.createElement("div", { className: "d-flex flex-column h-100" },
+    React.createElement("div", { className: "border-bottom p-3" }),
+    React.createElement("div", { className: "flex-grow-1 p-3", style: { overflowY: "auto" } },
+        React.createElement("div", { className: "d-flex mb-3" },
+            React.createElement("div", { className: "me-2" },
+                React.createElement("div", { className: "rounded-circle d-flex align-items-center justify-content-center bg-primary text-white", style: { width: "40px", height: "40px" } }, "\uD83E\uDD16")),
+            React.createElement("div", { className: "flex-grow-1" },
+                React.createElement("div", { className: "fw-bold" }, "Helpo"),
+                React.createElement("div", { className: "bg-light p-3 rounded" },
+                    React.createElement("p", null, "Hello! I'm Helpo, your helpful robot assistant. How can I assist you today?")))),
+        React.createElement("div", { className: "d-flex mb-3 justify-content-end" },
+            React.createElement("div", { className: "flex-grow-1 me-2 text-end" },
+                React.createElement("div", { className: "fw-bold" }, "You"),
+                React.createElement("div", { className: "bg-primary text-white p-3 rounded" },
+                    React.createElement("p", null,
+                        "Can you show me how to format text with ",
+                        React.createElement("strong", null, "bold"),
+                        " and",
+                        " ",
+                        React.createElement("em", null, "italic"),
+                        "?"))),
+            React.createElement("div", null,
+                React.createElement("div", { className: "rounded-circle d-flex align-items-center justify-content-center bg-secondary text-white", style: { width: "40px", height: "40px" } }, "\uD83D\uDC64"))),
+        React.createElement("div", { className: "d-flex mb-3" },
+            React.createElement("div", { className: "me-2" },
+                React.createElement("div", { className: "rounded-circle d-flex align-items-center justify-content-center bg-primary text-white", style: { width: "40px", height: "40px" } }, "\uD83E\uDD16")),
+            React.createElement("div", { className: "flex-grow-1" },
+                React.createElement("div", { className: "fw-bold" }, "Helpo"),
+                React.createElement("div", { className: "bg-light p-3 rounded" },
+                    React.createElement("p", null, "Sure! Here's an example:"),
+                    React.createElement("ul", null,
+                        React.createElement("li", null,
+                            "Use ",
+                            React.createElement("code", null, "<strong>"),
+                            " for ",
+                            React.createElement("strong", null, "bold text")),
+                        React.createElement("li", null,
+                            "Use ",
+                            React.createElement("code", null, "<em>"),
+                            " for ",
+                            React.createElement("em", null, "italic text")),
+                        React.createElement("li", null, "You can even include lists and other HTML elements")),
+                    React.createElement("p", null, "Let me know if you need help with anything else!"))))),
+    React.createElement("div", { className: "border-top p-3" },
+        React.createElement("div", { className: "input-group" },
+            React.createElement("input", { type: "text", className: "form-control", placeholder: "Type your message...", disabled: true }),
+            React.createElement("button", { className: "btn btn-primary", type: "button", disabled: true }, "Send")))));

package/dist/module/src/Init.js

@@ -7,9 +7,17 @@ export default async () => {
         `testeranto/bundles/node`,
         `testeranto/bundles/web`,
         `testeranto/bundles/pure`,
+        `testeranto/bundles/golang`,
+        `testeranto/bundles/python`,
         `testeranto/reports/`,
         `testeranto/features/`,
-        `testeranto/externalTests/`,
+        // `testeranto/externalTests/`,
+        `testeranto/metafiles/`,
+        `testeranto/metafiles/node`,
+        `testeranto/metafiles/web`,
+        `testeranto/metafiles/pure`,
+        `testeranto/metafiles/golang`,
+        `testeranto/metafiles/python`,
     ].forEach((f) => {
         try {
             fs.mkdirSync(`${process.cwd()}/${f}`);

package/dist/module/src/Node.js

@@ -1,4 +1,3 @@
-// import Testeranto from "./lib/core.js";
 import { defaultTestResourceRequirement, } from "./lib/index.js";
 import { PM_Node } from "./PM/node.js";
 import Tiposkripto from "./lib/Tiposkripto.js";

package/dist/module/src/PM/golingvuBuild.js

@@ -0,0 +1,42 @@
+import { generateGolingvuMetafile, writeGolingvuMetafile } from "../utils/golingvuMetafile";
+import { GolingvuWatcher } from "../utils/golingvuWatcher";
+export class GolingvuBuild {
+    constructor(config, testName) {
+        this.watcher = null;
+        this.config = config;
+        this.testName = testName;
+    }
+    async build() {
+        // Filter golang tests
+        const golangTests = this.config.tests.filter((test) => test[1] === "golang");
+        const hasGolangTests = golangTests.length > 0;
+        if (hasGolangTests) {
+            // Get the entry points
+            const golangEntryPoints = golangTests.map((test) => test[0]);
+            // Generate and write metafile
+            const metafile = await generateGolingvuMetafile(this.testName, golangEntryPoints);
+            writeGolingvuMetafile(this.testName, metafile);
+            // Start watching for changes
+            this.watcher = new GolingvuWatcher(this.testName, golangEntryPoints);
+            await this.watcher.start();
+            return golangEntryPoints;
+        }
+        return [];
+    }
+    async rebuild() {
+        if (this.watcher) {
+            await this.watcher.regenerateMetafile();
+        }
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.stop();
+            this.watcher = null;
+        }
+    }
+    onBundleChange(callback) {
+        if (this.watcher) {
+            this.watcher.onMetafileChange(callback);
+        }
+    }
+}

package/dist/module/src/PM/pitonoBuild.js

@@ -0,0 +1,42 @@
+import { generatePitonoMetafile, writePitonoMetafile } from "../utils/pitonoMetafile";
+import { PitonoWatcher } from "../utils/pitonoWatcher";
+export class PitonoBuild {
+    constructor(config, testName) {
+        this.watcher = null;
+        this.config = config;
+        this.testName = testName;
+    }
+    async build() {
+        // Filter python tests
+        const pythonTests = this.config.tests.filter((test) => test[1] === "python");
+        const hasPythonTests = pythonTests.length > 0;
+        if (hasPythonTests) {
+            // Get the entry points
+            const pythonEntryPoints = pythonTests.map((test) => test[0]);
+            // Generate and write metafile
+            const metafile = await generatePitonoMetafile(this.testName, pythonEntryPoints);
+            writePitonoMetafile(this.testName, metafile);
+            // Start watching for changes
+            this.watcher = new PitonoWatcher(this.testName, pythonEntryPoints);
+            await this.watcher.start();
+            return pythonEntryPoints;
+        }
+        return [];
+    }
+    async rebuild() {
+        if (this.watcher) {
+            await this.watcher.regenerateMetafile();
+        }
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.stop();
+            this.watcher = null;
+        }
+    }
+    onBundleChange(callback) {
+        if (this.watcher) {
+            this.watcher.onMetafileChange(callback);
+        }
+    }
+}

package/dist/module/src/PM/utils.js

@@ -30,7 +30,14 @@ export function runtimeLogs(runtime, reportDest) {
                 exit: fs.createWriteStream(`${safeDest}/exit.log`),
             };
         }
-        else if (runtime === "pitono") {
+        else if (runtime === "python") {
+            return {
+                stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
+                stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
+                exit: fs.createWriteStream(`${safeDest}/exit.log`),
+            };
+        }
+        else if (runtime === "golang") {
             return {
                 stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
                 stderr: fs.createWriteStream(`${safeDest}/stderr.log`),

package/dist/module/src/PM/web.js

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { PM } from ".";
 export class PM_Web extends PM {
     constructor(t) {
@@ -61,8 +63,6 @@ export class PM_Web extends PM {
     customScreenShot(x, y) {
         const opts = x[0];
         const page = x[1];
-        // console.log("customScreenShot 2 opts", opts);
-        // console.log("customScreenShot 2 page", page);
         return window["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), this.testResourceConfiguration.name, page);
     }
     existsSync(destFolder) {
@@ -75,12 +75,8 @@ export class PM_Web extends PM {
         return window["write"](uid, contents);
     }
     writeFileSync(x) {
-        // eslint-disable-next-line prefer-rest-params
-        // const z = arguments["0"];
-        // const filepath = z[0];
-        // const contents = z[1];
-        const filepath = arguments[0];
-        const contents = arguments[1];
+        const filepath = x[0];
+        const contents = x[1];
         return window["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
     }
     createWriteStream(filepath) {

package/dist/module/src/Pure.js

@@ -10,20 +10,6 @@ export class PureTesteranto extends Tiposkripto {
     async receiveTestResourceConfig(partialTestResource) {
         const t = JSON.parse(partialTestResource);
         const pm = new PM_Pure(t);
-        // if (!this.testJobs || this.testJobs.length === 0) {
-        //   console.error(
-        //     "[ERROR] No test jobs available - checking specs:",
-        //     this.specs?.length
-        //   );
-        //   console.error("[ERROR] Test implementation:", this.testImplementation);
-        //   return {
-        //     failed: true,
-        //     fails: 1,
-        //     artifacts: [],
-        //     // logPromise: Promise.resolve(),
-        //     features: [],
-        //   };
-        // }
         try {
             const result = this.testJobs[0].receiveTestResourceConfig(pm);
             return result;

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

@@ -1,6 +1,5 @@
 import PureTesteranto from "./Pure";
 import { MockPMBase } from "./lib/pmProxy.test/mockPMBase";
-// Implementation for PureTesteranto tests
 const implementation = {
     suites: {
         Default: "PureTesteranto Test Suite",
@@ -97,7 +96,6 @@ const implementation = {
         },
     },
 };
-// Specification for PureTesteranto tests
 const specification = (Suite, Given, When, Then) => [
     Suite.Default("Core Functionality", {
         initializationTest: Given.Default(["Should initialize with default configuration"], [], [Then.verifyNoProxy()]),
@@ -151,7 +149,6 @@ const specification = (Suite, Given, When, Then) => [
         ], [Then.testRunSuccessful(), Then.artifactsTracked(), Then.specsModified(0)]),
     }),
 ];
-// Test adapter for PureTesteranto
 const testAdapter = {
     beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
         const initialized = initializer();
@@ -170,6 +167,4 @@ const testAdapter = {
     beforeAll: async (input, testResource, pm) => ({}),
     assertThis: (x) => x,
 };
-// Export the test suite
-export default PureTesteranto(null, // No initial input
-specification, implementation, testAdapter);
+export default PureTesteranto(null, specification, implementation, testAdapter);