testeranto 0.171.0 → 0.173.0

package/README.md

@@ -34,6 +34,8 @@
 
 ## Quick Start
 
+0. Install Aider and signup for a LLM service.
+
 1. Install testeranto:
 
 ```bash
@@ -92,7 +94,6 @@ yarn t-build rectangle.test.ts yourProject once && yarn t-run rectangle.test.ts
 | `yarn t-build <YOUR_TESTS> dev\|once` | Build test bundles (watch or single-run mode) |
 | `yarn t-run <YOUR_TESTS> dev\|once`   | Run tests (watch or single-run mode)          |
 | `yarn t-report`                       | Launch test report server                     |
-| `yarn t-aider`                        | Fix failing tests with AI                     |
 
 ## Example workflow:
 
@@ -111,9 +112,6 @@ yarn t-run test/rectangle.test.ts dev
 # Or for single-run mode:
 yarn t-build test/rectangle.test.ts once
 yarn t-run test/rectangle.test.ts once
-
-# Get AI help with failures
-yarn t-aider
 ```
 
 ## Aider

package/dist/common/src/PM/base.js

@@ -119,6 +119,10 @@ class PM_Base {
         return false;
     }
     async writeFileSync(filepath, contents, testName) {
+        console.log("writeFileSync");
+        console.log("filepath", filepath);
+        console.log("contents", contents);
+        console.log("testName", testName);
         return new Promise(async (res) => {
             fs_1.default.mkdirSync(path_1.default.dirname(filepath), {
                 recursive: true,

package/dist/common/src/PM/main.js

@@ -108,10 +108,12 @@ function isValidUrl(string) {
 }
 // Wait for file to exist, checks every 2 seconds by default
 async function pollForFile(path, timeout = 2000) {
+    console.log(`pollForFile: ${path}...`);
     const intervalObj = setInterval(function () {
         const file = path;
         const fileExists = fs_1.default.existsSync(file);
         if (fileExists) {
+            console.log(`metafile found: ${path}!`);
             clearInterval(intervalObj);
         }
     }, timeout);
@@ -320,7 +322,12 @@ class PM_Main extends PM_WithEslintAndTsc_js_1.PM_WithEslintAndTsc {
             const ipcfile = "/tmp/tpipe_" + Math.random();
             const child = (0, node_child_process_1.spawn)("node", 
             // "node",
-            ["--inspect-brk", builtfile, testResources, ipcfile], {
+            [
+                // "--inspect-brk",
+                builtfile,
+                testResources,
+                ipcfile,
+            ], {
                 stdio: ["pipe", "pipe", "pipe", "ipc"],
             });
             let buffer = new Buffer("");
@@ -797,7 +804,7 @@ class PM_Main extends PM_WithEslintAndTsc_js_1.PM_WithEslintAndTsc {
                     close();
                 });
                 page.on("console", (log) => {
-                    console.log("console message: ", log.text());
+                    // console.log("console message: ", log.text());
                     if (oStream.closed) {
                         console.log("missed console message: ", log.text());
                         return;
@@ -1034,9 +1041,9 @@ class PM_Main extends PM_WithEslintAndTsc_js_1.PM_WithEslintAndTsc {
                 slowMo: 1,
                 waitForInitialPage: false,
                 executablePath,
-                headless: false,
+                headless: true,
                 dumpio: false,
-                devtools: true,
+                devtools: false,
                 args: [
                     "--disable-features=site-per-process",
                     "--allow-file-access-from-files",

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

@@ -114,7 +114,7 @@ class PM_Node extends _1.PM {
     async write(uid, contents) {
         return await this.send("write", ...arguments);
     }
-    async writeFileSync(filepath, contents) {
+    async writeFileSync([filepath, contents]) {
         return await this.send("writeFileSync", this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
     }
     async createWriteStream(filepath) {

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

@@ -70,8 +70,8 @@ class PM_Web extends _1.PM {
     customScreenShot(x, y) {
         const opts = x[0];
         const page = x[1];
-        console.log("customScreenShot 2 opts", opts);
-        console.log("customScreenShot 2 page", page);
+        // 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) {
@@ -83,7 +83,7 @@ class PM_Web extends _1.PM {
     write(uid, contents) {
         return window["write"](uid, contents);
     }
-    writeFileSync(filepath, contents) {
+    writeFileSync([filepath, contents]) {
         return window["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
     }
     createWriteStream(filepath) {

package/dist/common/src/ReportServer.js

@@ -1,129 +1,5 @@
 "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 });
-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.listen(8080, () => {
-    console.log('Server running on http://localhost:8080');
-    console.log('Serving files from:', process.cwd());
-});
-server.on('error', (err) => {
-    console.error('Server error:', err);
-});
-process.on('uncaughtException', (err) => {
-    console.error('Uncaught exception:', err);
-});
+const ReportServerLib_1 = require("./ReportServerLib");
+(0, ReportServerLib_1.ReportServerOfPort)(process.argv[2]);

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,135 @@
+"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) => server.listen(port, () => {
+    console.log(`Server running on http://localhost:${port}`);
+    console.log("Serving files from:", process.cwd());
+});
+const ReportServerOfPort = (port) => start(port);
+exports.ReportServerOfPort = ReportServerOfPort;
+// export default () => start(process.argv[2]);

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/lib/abstractBase.js

@@ -7,6 +7,8 @@ const pmProxy_js_1 = require("./pmProxy.js");
 class BaseGiven {
     addArtifact(path) {
         console.log(`[Artifact] Adding to ${this.constructor.name}:`, path);
+        // console.log("mark111");
+        // process.exit();
         this.artifacts.push(path);
     }
     constructor(name, features, whens, thens, givenCB, initialValues) {

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

@@ -45,8 +45,14 @@ class BaseBuilder {
                     //   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),
+                    ]);
                     return {
                         failed: fails > 0,
                         fails,