testeranto 0.172.0 → 0.177.0

package/dist/common/src/ReportServer.test.ts/index.js

@@ -0,0 +1,78 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Node_1 = __importDefault(require("../Node"));
+const ReportServerLib_1 = require("../ReportServerLib");
+const specification = (Suite, Given, When, Then) => [
+    Suite.Default("the http server which is used in development", {
+        initialization: Given["the http server which is used in development"](["It should serve the front page", "It should serve the ReportApp"], [], [
+            Then["the frontpage looks good"](),
+            // Then["the projects page looks good"](),
+            // Then["a project page looks good"](),
+            // Then["a test page looks good"](),
+        ]),
+    }),
+];
+const implementation = {
+    suites: {
+        Default: "the http server which is used in  development",
+    },
+    givens: {
+        "the http server which is used in development": function (subject) {
+            // throw new Error("Function not implemented.");
+            return subject;
+        },
+    },
+    // There are no "whens", it is a stateless server.
+    whens: {},
+    thens: {
+        "the frontpage looks good": async (port, utils) => {
+            // throw new Error("Function not implemented.");
+            // utils.newPage(`localhost:${port}`);
+            debugger;
+            const page = await utils.newPage();
+            utils.goto(page, `localhost:${port}`);
+            utils.customScreenShot({ path: `frontpage.png` }, page);
+            return;
+        },
+        "the projects page looks good": function () {
+            throw new Error("Function not implemented.");
+        },
+        "a project page looks good": function () {
+            throw new Error("Function not implemented.");
+        },
+        "a test page looks good": function () {
+            throw new Error("Function not implemented.");
+        },
+    },
+};
+const adapter = {
+    assertThis: function (x) {
+        throw new Error("Function not implemented.");
+    },
+    andWhen: function (store, whenCB, testResource, pm) {
+        throw new Error("Function not implemented.");
+    },
+    butThen: function (store, thenCB, testResource, pm) {
+        throw new Error("Function not implemented.");
+    },
+    afterAll: function (store, pm) {
+        throw new Error("Function not implemented.");
+    },
+    afterEach: function (store, key, pm) {
+        throw new Error("Function not implemented.");
+    },
+    beforeAll: async function (input, testResource, pm) {
+        await new Promise((res, rej) => input(testResource.ports[0]));
+        return testResource.ports[0];
+    },
+    beforeEach: function (subject, initializer, testResource, initialValues, pm) {
+        throw new Error("Function not implemented.");
+    },
+};
+exports.default = (0, Node_1.default)(ReportServerLib_1.ReportServerOfPort, specification, implementation, adapter);

package/dist/common/src/ReportServerLib.js

@@ -0,0 +1,141 @@
+"use strict";
+// simple http server to preview reports
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReportServerOfPort = void 0;
+const node_static_1 = __importDefault(require("node-static"));
+const http_1 = __importDefault(require("http"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const fileServer = new node_static_1.default.Server("./", {
+    cache: false,
+    headers: {
+        "Cache-Control": "no-cache, no-store, must-revalidate",
+        Pragma: "no-cache",
+        Expires: "0",
+    },
+});
+const server = http_1.default.createServer((req, res) => {
+    // Handle potential double responses
+    let responded = false;
+    const safeResponse = (handler) => {
+        if (responded)
+            return;
+        responded = true;
+        try {
+            handler();
+        }
+        catch (err) {
+            console.error("Error handling request:", err);
+            if (!res.headersSent) {
+                res.writeHead(500);
+            }
+            res.end("Internal Server Error");
+        }
+    };
+    req.on("error", (err) => {
+        console.error("Request error:", err);
+        safeResponse(() => {
+            if (!res.headersSent) {
+                res.writeHead(400);
+            }
+            res.end("Bad Request");
+        });
+    });
+    req.on("end", () => {
+        safeResponse(() => {
+            const filePath = path_1.default.join(process.cwd(), req.url || "");
+            // First check if file exists
+            fs_1.default.stat(filePath, (err, stats) => {
+                if (err || !stats.isFile()) {
+                    // Check if directory exists
+                    fs_1.default.stat(filePath, (dirErr, dirStats) => {
+                        if (!dirErr && dirStats.isDirectory()) {
+                            // Serve directory listing
+                            fs_1.default.readdir(filePath, (readErr, files) => {
+                                if (readErr) {
+                                    res.writeHead(500);
+                                    return res.end("Error reading directory");
+                                }
+                                res.writeHead(200, { "Content-Type": "text/html" });
+                                res.write(`
+                  <html>
+                    <head>
+                      <title>Directory Listing: ${req.url}</title>
+                      <style>
+                        body { font-family: sans-serif; margin: 2rem; }
+                        h1 { color: #333; }
+                        ul { list-style: none; padding: 0; }
+                        li { padding: 0.5rem; }
+                        li a { color: #0366d6; text-decoration: none; }
+                        li a:hover { text-decoration: underline; }
+                      </style>
+                    </head>
+                    <body>
+                      <h1>Directory: ${req.url}</h1>
+                      <ul>
+                        ${files
+                                    .map((file) => `
+                          <li>
+                            <a href="${path_1.default.join(req.url || "", file)}">
+                              ${file}${file.endsWith("/") ? "/" : ""}
+                            </a>
+                          </li>
+                        `)
+                                    .join("")}
+                      </ul>
+                    </body>
+                  </html>
+                `);
+                                res.end();
+                            });
+                        }
+                        else {
+                            // Neither file nor directory exists - send 404
+                            if (!res.headersSent) {
+                                res.writeHead(404, { "Content-Type": "text/plain" });
+                                res.end("File not found");
+                            }
+                        }
+                    });
+                    return;
+                }
+                // File exists - serve it through node-static
+                const serve = () => {
+                    fileServer.serve(req, res, (err) => {
+                        if (err && !res.headersSent) {
+                            res.writeHead(err.status || 500);
+                            res.end(err.message);
+                        }
+                    });
+                };
+                // Ensure we don't double-serve
+                if (!res.headersSent) {
+                    serve();
+                }
+            });
+        });
+    });
+    req.resume();
+});
+server.on("error", (err) => {
+    console.error("Server error:", err);
+});
+process.on("uncaughtException", (err) => {
+    console.error("Uncaught exception:", err);
+});
+const start = (port) => {
+    if (port) {
+        server.listen(port, () => {
+            console.log(`Server running on http://localhost:${port}`);
+            console.log("Serving files from:", process.cwd());
+        });
+    }
+    else {
+        console.log("you need to specify a port");
+    }
+};
+const ReportServerOfPort = (port) => start(port);
+exports.ReportServerOfPort = ReportServerOfPort;

package/dist/common/src/components/pure/ProjectPageView.test/implementation.js

@@ -38,7 +38,7 @@ exports.implementation = {
     thens: {
         happyPath: () => async ({ container, html }, pm) => {
             console.group('[Test] Verifying render output');
-            debugger;
+            // debugger
             const p = await pm.page();
             await pm.customScreenShot({ path: "happyPath.png" }, p);
             chai_1.assert.equal(1, 1);

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

@@ -9,9 +9,7 @@ const featuresPlugin_1 = __importDefault(require("./featuresPlugin"));
 const rebuildPlugin_js_1 = __importDefault(require("./rebuildPlugin.js"));
 exports.default = (config, entryPoints, testName) => {
     const { inputFilesPluginFactory, register } = (0, inputFilesPlugin_js_1.default)("node", testName);
-    return Object.assign(Object.assign({}, (0, index_js_1.default)(config)), { splitting: true, outdir: `testeranto/bundles/node/${testName}/`, 
-        // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
-        metafile: true, supported: {
+    return Object.assign(Object.assign({}, (0, index_js_1.default)(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",

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

@@ -3,18 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseSuite = void 0;
 const pmProxy_1 = require("./pmProxy");
 class BaseSuite {
+    addArtifact(path) {
+        console.log("Suite addArtifact", 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");
         }
-        console.log("[DEBUG] BaseSuite constructor - name:", suiteName, "index:", index);
         this.name = suiteName;
         this.index = index;
         this.givens = givens;
         this.fails = 0;
-        console.log("[DEBUG] BaseSuite initialized:", this.name, this.index);
-        console.log("[DEBUG] BaseSuite givens:", Object.keys(givens).toString());
     }
     features() {
         try {
@@ -24,11 +27,10 @@ class BaseSuite {
                 .filter((value, index, array) => {
                 return array.indexOf(value) === index;
             });
-            console.debug("[DEBUG] Features extracted:", features.toString());
             return features || [];
         }
         catch (e) {
-            console.error("[ERROR] Failed to extract features:", e);
+            console.error("[ERROR] Failed to extract features:", JSON.stringify(e));
             return [];
         }
     }
@@ -56,10 +58,10 @@ class BaseSuite {
         // 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);
+        // tLog("\nSuite:", this.index, this.name);
         const sNdx = this.index;
-        // const sName = this.name;
-        const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, (0, pmProxy_1.beforeAllProxy)(pm, sNdx.toString()));
+        const proxiedPm = (0, pmProxy_1.beforeAllProxy)(pm, sNdx.toString(), this);
+        const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, proxiedPm);
         for (const [gKey, g] of Object.entries(this.givens)) {
             const giver = this.givens[gKey];
             this.store = await giver
@@ -67,15 +69,15 @@ class BaseSuite {
                 .catch((e) => {
                 this.failed = true;
                 this.fails = this.fails + 1;
-                // console.error("Given error 1:", e.toString());
                 throw e;
             });
         }
         try {
-            this.afterAll(this.store, artifactory, (0, pmProxy_1.afterAllProxy)(pm, sNdx.toString()));
+            const afterAllPm = (0, pmProxy_1.afterAllProxy)(pm, sNdx.toString(), this);
+            this.afterAll(this.store, artifactory, afterAllPm);
         }
         catch (e) {
-            console.error(e);
+            console.error(JSON.stringify(e));
             // this.fails.push(this);
             // return this;
         }

package/dist/common/src/lib/abstractBase.js

@@ -6,8 +6,9 @@ exports.BaseThen = exports.BaseWhen = exports.BaseGiven = void 0;
 const pmProxy_js_1 = require("./pmProxy.js");
 class BaseGiven {
     addArtifact(path) {
-        console.log(`[Artifact] Adding to ${this.constructor.name}:`, path);
-        this.artifacts.push(path);
+        console.log("Given addArtifact", path);
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
     }
     constructor(name, features, whens, thens, givenCB, initialValues) {
         this.artifacts = [];
@@ -28,7 +29,7 @@ class BaseGiven {
             whens: this.whens.map((w) => {
                 if (w && w.toObj)
                     return w.toObj();
-                console.error("w is not as expected!", w.toString());
+                console.error("w is not as expected!", JSON.stringify(w));
                 return {};
             }),
             thens: this.thens.map((t) => t.toObj()),
@@ -52,15 +53,13 @@ class BaseGiven {
             tLog(e.stack);
         });
         try {
-            const proxiedPm = (0, pmProxy_js_1.beforeEachProxy)(pm, suiteNdx.toString());
-            console.log(`[Given] Setting currentStep for beforeEach:`, this.name);
-            proxiedPm.currentStep = this;
+            const proxiedPm = (0, pmProxy_js_1.beforeEachProxy)(pm, suiteNdx.toString(), this.addArtifact.bind(this));
             this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues, proxiedPm);
         }
         catch (e) {
-            console.error("Given failure: ", e.toString());
-            this.error = e;
-            throw e;
+            // console.error("Given failure: ", e.stack);
+            this.error = e.stack;
+            // throw e;
         }
         try {
             // tLog(`\n Given this.store`, this.store);
@@ -70,9 +69,6 @@ class BaseGiven {
             for (const [thenNdx, thenStep] of this.thens.entries()) {
                 const t = await thenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/then-${thenNdx}`);
                 tester(t);
-                // ((t) => {
-                //   return tester(t);
-                // })();
             }
         }
         catch (e) {
@@ -82,10 +78,11 @@ class BaseGiven {
         }
         finally {
             try {
-                await this.afterEach(this.store, this.key, givenArtifactory, (0, pmProxy_js_1.afterEachProxy)(pm, suiteNdx.toString(), key));
+                const proxiedPm = (0, pmProxy_js_1.afterEachProxy)(pm, suiteNdx.toString(), key, this.addArtifact.bind(this));
+                // (proxiedPm as any).currentStep = this;
+                await this.afterEach(this.store, this.key, givenArtifactory, proxiedPm);
             }
             catch (e) {
-                console.error("afterEach failed!", e.toString());
                 this.failed = e;
                 throw e;
                 // this.error = e.message;
@@ -96,36 +93,33 @@ class BaseGiven {
 }
 exports.BaseGiven = BaseGiven;
 class BaseWhen {
+    addArtifact(path) {
+        console.log("When addArtifact", path);
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
+    }
     constructor(name, whenCB) {
         this.artifacts = [];
         this.name = name;
         this.whenCB = whenCB;
     }
     toObj() {
-        console.log("toObj error", this.error);
-        if (this.error) {
-            return {
-                name: this.name,
-                error: this.error && this.error.name + this.error.stack,
-                artifacts: this.artifacts,
-            };
-        }
-        else {
-            return {
-                name: this.name,
-                artifacts: this.artifacts,
-            };
-        }
+        const obj = {
+            name: this.name,
+            error: this.error
+                ? `${this.error.name}: ${this.error.message}\n${this.error.stack}`
+                : null,
+            artifacts: this.artifacts || [],
+        };
+        console.log(`[TOOBJ] Serializing ${this.constructor.name} with artifacts:`, obj.artifacts);
+        return obj;
     }
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
         try {
-            tLog(" When:", this.name);
-            console.debug("[DEBUG] Executing When step:", this.name.toString());
-            const proxiedPm = (0, pmProxy_js_1.andWhenProxy)(pm, filepath);
-            console.log(`[When] Setting currentStep for andWhen:`, this.name);
-            proxiedPm.currentStep = this;
+            // tLog(" When:", this.name);
+            const proxiedPm = (0, pmProxy_js_1.andWhenProxy)(pm, filepath, this.addArtifact.bind(this));
+            // (proxiedPm as any).currentStep = this;
             const result = await this.andWhen(store, this.whenCB, testResourceConfiguration, proxiedPm);
-            console.debug("[DEBUG] When step completed:", this.name.toString());
             return result;
         }
         catch (e) {
@@ -142,18 +136,23 @@ class BaseThen {
         this.name = name;
         this.thenCB = thenCB;
         this.error = false;
+        this.artifacts = [];
+    }
+    addArtifact(path) {
+        console.log("Then addArtifact", path);
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
     }
     toObj() {
-        return {
+        const obj = {
             name: this.name,
             error: this.error,
             artifacts: this.artifacts,
         };
+        return obj;
     }
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
-        const proxiedPm = (0, pmProxy_js_1.butThenProxy)(pm, filepath);
-        console.log(`[Then] Setting currentStep for butThen:`, this.name);
-        proxiedPm.currentStep = this;
+        const proxiedPm = (0, pmProxy_js_1.butThenProxy)(pm, filepath, this.addArtifact.bind(this));
         return this.butThen(store, async (s) => {
             if (typeof this.thenCB === "function") {
                 return await this.thenCB(s, proxiedPm);
@@ -161,8 +160,8 @@ class BaseThen {
             else {
                 return this.thenCB;
             }
-        }, testResourceConfiguration, (0, pmProxy_js_1.butThenProxy)(pm, filepath)).catch((e) => {
-            this.error = e.toString();
+        }, testResourceConfiguration, proxiedPm).catch((e) => {
+            this.error = e.stack;
             // throw e;
         });
     }

package/dist/common/src/lib/baseBuilder.test/baseBuilder.test.implementation.js

@@ -8,7 +8,7 @@ exports.implementation = {
         Default: "BaseBuilder test suite",
     },
     givens: {
-        Default: () => {
+        "the default BaseBuilder": () => {
             return new baseBuilder_test_mock_1.MockBaseBuilder({}, // input
             {}, // suitesOverrides
             {}, // givenOverrides
@@ -18,11 +18,11 @@ exports.implementation = {
             () => [] // testSpecification
             );
         },
-        WithCustomInput: (input) => {
-            return new baseBuilder_test_mock_1.MockBaseBuilder(input, {}, {}, {}, {}, {}, { ports: [] });
+        "a BaseBuilder with TestInput": (input) => {
+            return new baseBuilder_test_mock_1.MockBaseBuilder(input, {}, {}, {}, {}, { ports: [] }, () => []);
         },
-        WithResourceRequirements: (requirements) => {
-            return new baseBuilder_test_mock_1.MockBaseBuilder({}, {}, {}, {}, {}, {}, requirements);
+        "a BaseBuilder with Test Resource Requirements": (requirements) => {
+            return new baseBuilder_test_mock_1.MockBaseBuilder({}, {}, {}, {}, {}, requirements, () => []);
         },
     },
     whens: {
@@ -36,8 +36,9 @@ exports.implementation = {
         },
     },
     thens: {
-        initializedProperly: () => (builder) => {
+        "it is initialized": () => (builder, utils) => {
             var _a;
+            utils.writeFileSync("hello.txt", "world");
             if (!(builder instanceof basebuilder_1.BaseBuilder)) {
                 console.error("Builder instance:", builder);
                 throw new Error(`Builder was not properly initialized - expected BaseBuilder instance but got ${(_a = builder === null || builder === void 0 ? void 0 : builder.constructor) === null || _a === void 0 ? void 0 : _a.name}`);
@@ -58,19 +59,19 @@ exports.implementation = {
             });
             return builder;
         },
-        specsGenerated: () => (builder) => {
+        "it generates TestSpecifications": () => (builder) => {
             if (!Array.isArray(builder.specs)) {
                 throw new Error("Specs were not generated");
             }
             return builder;
         },
-        jobsCreated: () => (builder) => {
+        "it creates jobs": () => (builder) => {
             if (!Array.isArray(builder.testJobs)) {
                 throw new Error("Test jobs were not created");
             }
             return builder;
         },
-        artifactsTracked: () => (builder) => {
+        "it tracks artifacts": () => (builder) => {
             if (!Array.isArray(builder.artifacts)) {
                 throw new Error("Artifacts array not initialized");
             }

package/dist/common/src/lib/baseBuilder.test/baseBuilder.test.specification.js

@@ -4,14 +4,14 @@ exports.specification = void 0;
 const specification = (Suite, Given, When, Then) => {
     return [
         Suite.Default("Testing BaseBuilder functionality", {
-            testInitialization: Given.Default(["BaseBuilder should initialize correctly"], [], [
-                Then.initializedProperly(),
-                Then.artifactsTracked(),
-                Then.jobsCreated(),
-                Then.specsGenerated(),
+            testInitialization: Given["the default BaseBuilder"](["BaseBuilder should initialize correctly"], [], [
+                Then["it is initialized"](),
+                Then["it tracks artifacts"](),
+                // Then["it creates jobs"](),
+                // Then["it generates TestSpecifications"](),
             ]),
-            testSpecsGeneration: Given.Default(["BaseBuilder should generate specs from test specification"], [], [Then.specsGenerated()]),
-            testJobsCreation: Given.Default(["BaseBuilder should create test jobs"], [], [Then.jobsCreated()]),
+            testSpecsGeneration: Given["the default BaseBuilder"](["BaseBuilder should generate specs from test specification"], [], [Then["it generates TestSpecifications"]()]),
+            testJobsCreation: Given["the default BaseBuilder"](["BaseBuilder should create test jobs"], [], [Then["it creates jobs"]()]),
         }),
     ];
 };

package/dist/common/src/lib/basebuilder.js

@@ -18,9 +18,11 @@ class BaseBuilder {
         this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then());
         this.testJobs = this.specs.map((suite) => {
             const suiteRunner = (suite) => async (puppetMaster, tLog) => {
+                console.log("mark17");
                 const x = await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
                     this.artifacts.push(p);
                 })(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value), tLog, puppetMaster);
+                console.log("mark18");
                 return x;
             };
             const runner = suiteRunner(suite);
@@ -39,14 +41,23 @@ class BaseBuilder {
                     const tLog = async (...l) => {
                         //
                     };
+                    console.log("mark14");
                     const suiteDone = await runner(puppetMaster, tLog);
+                    console.log("mark15");
                     // const logPromise = new Promise(async (res) => {
                     //   await puppetMaster.end(access);
                     //   res(true);
                     // });
                     const fails = suiteDone.fails;
-                    await puppetMaster.writeFileSync(`bdd_errors.txt`, fails.toString());
-                    await puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2));
+                    await puppetMaster.writeFileSync([
+                        `bdd_errors.txt`,
+                        fails.toString(),
+                    ]);
+                    await puppetMaster.writeFileSync([
+                        `tests.json`,
+                        JSON.stringify(this.toObj(), null, 2),
+                    ]);
+                    console.log("mark13");
                     return {
                         failed: fails > 0,
                         fails,

package/dist/common/src/lib/core.js

@@ -28,6 +28,7 @@ class TesterantoCore extends classBuilder_js_1.ClassBuilder {
                 this.uberCatcher = uberCatcher;
             }
             async givenThat(subject, testResource, artifactory, initializer, initialValues, pm) {
+                console.log("mark800");
                 return fullAdapter.beforeEach(subject, initializer, testResource, initialValues, pm);
             }
             afterEach(store, key, artifactory, pm) {