testeranto 0.200.1 → 0.203.0

package/dist/common/src/Pure.js

@@ -1,52 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PureTesteranto = void 0;
-const index_js_1 = require("./lib/index.js");
-const Tiposkripto_js_1 = __importDefault(require("./lib/Tiposkripto.js"));
-const pure_js_1 = require("./PM/pure.js");
-class PureTesteranto extends Tiposkripto_js_1.default {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
-        super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, () => {
-            // no-op
-        });
-    }
-    async receiveTestResourceConfig(partialTestResource) {
-        const t = JSON.parse(partialTestResource);
-        const pm = new pure_js_1.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;
-        }
-        catch (e) {
-            console.error("[ERROR] Test job failed:", e);
-            return {
-                failed: true,
-                fails: -1,
-                artifacts: [],
-                // logPromise: Promise.resolve(),
-                features: [],
-            };
-        }
-    }
-}
-exports.PureTesteranto = PureTesteranto;
-exports.default = async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = index_js_1.defaultTestResourceRequirement) => {
-    return new PureTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testAdapter);
-};

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

@@ -1,180 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Pure_1 = __importDefault(require("./Pure"));
-const mockPMBase_1 = require("./lib/pmProxy.test/mockPMBase");
-// Implementation for PureTesteranto tests
-const implementation = {
-    suites: {
-        Default: "PureTesteranto Test Suite",
-    },
-    givens: {
-        Default: () => {
-            const pm = new mockPMBase_1.MockPMBase();
-            return {
-                pm,
-                config: {},
-                proxies: {
-                    butThenProxy: (pm, path) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => {
-                            return pm.writeFileSync(`${path}/butThen/${p}`, c);
-                        } })),
-                    andWhenProxy: (pm, path) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => {
-                            return pm.writeFileSync(`${path}/andWhen/${p}`, c);
-                        } })),
-                    beforeEachProxy: (pm, suite) => (Object.assign(Object.assign({}, pm), { writeFileSync: (p, c) => {
-                            return pm.writeFileSync(`suite-${suite}/beforeEach/${p}`, c);
-                        } })),
-                },
-            };
-        },
-    },
-    whens: {
-        applyProxy: (proxyType) => async (store, tr, utils) => {
-            switch (proxyType) {
-                case "invalidConfig":
-                    throw new Error("Invalid configuration");
-                case "missingProxy":
-                    return Object.assign(Object.assign({}, store), { pm: {} }); // Break proxy chain
-                case "largePayload":
-                    return Object.assign(Object.assign({}, store), { largePayload: true, pm: Object.assign(Object.assign({}, store.pm), { writeFileSync: async (p, c) => {
-                                if (c.length > 1e6) {
-                                    return true;
-                                }
-                                throw new Error("Payload too small");
-                            } }) });
-                case "resourceConfig":
-                    return Object.assign(Object.assign({}, store), { pm: Object.assign(Object.assign({}, store.pm), { testResourceConfiguration: { name: "test-resource" } }) });
-                default:
-                    return store;
-            }
-        },
-        addArtifact: (artifact) => async (store) => {
-            return Object.assign(Object.assign({}, store), { artifacts: [...(store.artifacts || []), artifact] });
-        },
-        setTestJobs: (jobs) => async (store) => {
-            return Object.assign(Object.assign({}, store), { testJobs: jobs });
-        },
-        modifySpecs: (modifier) => async (store) => {
-            return Object.assign(Object.assign({}, store), { specs: modifier(store.specs || []) });
-        },
-    },
-    thens: {
-        initializedProperly: () => async (store, tr, utils) => {
-            if (!store.pm) {
-                throw new Error("PM not initialized");
-            }
-            return store;
-        },
-        specsGenerated: () => async (store, tr, utils) => {
-            return store;
-        },
-        jobsCreated: () => async (store, tr, utils) => {
-            return store;
-        },
-        artifactsTracked: () => async (store, tr, utils) => {
-            return store;
-        },
-        testRunSuccessful: () => async (store, tr, utils) => {
-            return store;
-        },
-        specsModified: (expectedCount) => async (store, tr, utils) => {
-            return store;
-        },
-        verifyProxy: (expectedPath) => async (store, tr, utils) => {
-            return store;
-        },
-        verifyNoProxy: () => async (store, tr, utils) => {
-            return store;
-        },
-        verifyError: (expectedError) => async (store, tr, utils) => {
-            return store;
-        },
-        verifyResourceConfig: () => async (store, tr, utils) => {
-            return store;
-        },
-        verifyLargePayload: () => async (store, tr, utils) => {
-            return store;
-        },
-        verifyTypeSafety: () => async (store, tr, utils) => {
-            return store;
-        },
-    },
-};
-// Specification for PureTesteranto tests
-const specification = (Suite, Given, When, Then) => [
-    Suite.Default("Core Functionality", {
-        initializationTest: Given.Default(["Should initialize with default configuration"], [], [Then.verifyNoProxy()]),
-        resourceConfigTest: Given.Default(["Should handle test resource configuration"], [When.applyProxy("resourceConfig")], [Then.verifyResourceConfig()]),
-    }),
-    Suite.Default("Proxy Integration", {
-        butThenProxyTest: Given.Default(["Should integrate with butThenProxy"], [When.applyProxy("butThenProxy")], [Then.verifyProxy("test/path/butThen/expected")]),
-        andWhenProxyTest: Given.Default(["Should integrate with andWhenProxy"], [When.applyProxy("andWhenProxy")], [Then.verifyProxy("test/path/andWhen/expected")]),
-        beforeEachProxyTest: Given.Default(["Should integrate with beforeEachProxy"], [When.applyProxy("beforeEachProxy")], [Then.verifyProxy("suite-1/beforeEach/expected")]),
-    }),
-    Suite.Default("Error Handling", {
-        invalidConfigTest: Given.Default(["Should handle invalid configuration"], [When.applyProxy("invalidConfig")], [Then.verifyError("Invalid configuration")]),
-        missingProxyTest: Given.Default(["Should handle missing proxy"], [When.applyProxy("missingProxy")], [Then.verifyError("Proxy not found")]),
-    }),
-    Suite.Default("Performance", {
-        multipleProxiesTest: Given.Default(["Should handle multiple proxies efficiently"], [
-            When.applyProxy("butThenProxy"),
-            When.applyProxy("andWhenProxy"),
-            When.applyProxy("beforeEachProxy"),
-        ], [
-            Then.verifyProxy("test/path/butThen/expected"),
-            Then.verifyProxy("test/path/andWhen/expected"),
-            Then.verifyProxy("suite-1/beforeEach/expected"),
-        ]),
-        largePayloadTest: Given.Default(["Should handle large payloads"], [When.applyProxy("largePayload")], [Then.verifyLargePayload()]),
-    }),
-    Suite.Default("Cross-Component Verification", {
-        proxyChainTest: Given.Default(["Proxies should chain correctly"], [When.applyProxy("butThenProxy"), When.applyProxy("andWhenProxy")], [Then.verifyProxy("test/path/andWhen/butThen/expected")]),
-        errorPropagationTest: Given.Default(["Errors should propagate across components"], [When.applyProxy("invalidConfig")], [Then.verifyError("Invalid configuration")]),
-        resourceSharingTest: Given.Default(["Resources should be shared correctly"], [When.applyProxy("resourceConfig")], [Then.verifyResourceConfig()]),
-    }),
-    Suite.Default("Type Safety", {
-        strictTypeTest: Given.Default(["Should enforce type safety"], [When.applyProxy("typeSafe")], [Then.verifyTypeSafety()]),
-        invalidTypeTest: Given.Default(["Should reject invalid types"], [When.applyProxy("invalidType")], [Then.verifyError("Type mismatch")]),
-    }),
-    Suite.Default("Integration Tests", {
-        // Verify builders work together
-        builderIntegration: Given.Default(["BaseBuilder and ClassBuilder should integrate properly"], [], [
-            Then.initializedProperly(),
-            Then.specsGenerated(),
-            Then.jobsCreated(),
-            Then.artifactsTracked(),
-        ]),
-        // Verify PM proxy integration
-        pmProxyIntegration: Given.Default(["PM proxies should work with test runners"], [When.applyProxy("butThenProxy")], [Then.verifyProxy("test/path/butThen/expected")]),
-        // Verify full test lifecycle
-        fullLifecycle: Given.Default(["Should complete full test lifecycle"], [
-            When.addArtifact(Promise.resolve("test")),
-            When.setTestJobs([]),
-            When.modifySpecs((specs) => [...specs]),
-        ], [Then.testRunSuccessful(), Then.artifactsTracked(), Then.specsModified(0)]),
-    }),
-];
-// Test adapter for PureTesteranto
-const testAdapter = {
-    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-        const initialized = initializer();
-        return { pm: initialized.pm };
-    },
-    andWhen: async (store, whenCB, testResource, pm) => {
-        const result = await whenCB(store, testResource, pm);
-        return result;
-    },
-    butThen: async (store, thenCB, testResource, pm) => {
-        const result = await thenCB(store, testResource, pm);
-        return result;
-    },
-    afterEach: async (store, key, pm) => store,
-    afterAll: async (store, pm) => { },
-    beforeAll: async (input, testResource, pm) => ({}),
-    assertThis: (x) => x,
-};
-// Export the test suite
-exports.default = (0, Pure_1.default)(null, // No initial input
-specification, implementation, testAdapter);

package/dist/common/src/PureSidecar.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PureSideCar = void 0;
-const Sidecar_1 = require("./lib/Sidecar");
-class PureSideCar extends Sidecar_1.Sidecar {
-    start(t) {
-        throw new Error("Method not implemented.");
-    }
-    stop() {
-        throw new Error("Method not implemented.");
-    }
-}
-exports.PureSideCar = PureSideCar;

package/dist/common/src/ReportServer.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ReportServerLib_1 = require("./ReportServerLib");
-const server_1 = require("../design-editor/server");
-const port = process.argv[2] || 3000;
-const wssPort = Number(port) + 1; // Use next port for WebSocket
-// Start both servers
-(0, ReportServerLib_1.ReportServerOfPort)(port);
-(0, server_1.startDesignEditorServer)(wssPort);
-console.log(`Report server running on http://localhost:${port}`);
-console.log(`Design editor WebSocket running on ws://localhost:${wssPort}`);

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

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

@@ -1,141 +0,0 @@
-"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/Types.js

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

package/dist/common/src/Web.js

@@ -1,61 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebTesteranto = void 0;
-const web_1 = require("./PM/web");
-const Tiposkripto_1 = __importDefault(require("./lib/Tiposkripto"));
-const index_js_1 = require("./lib/index.js");
-// let errorCallback = (e: any) => {};
-// let unhandledrejectionCallback = (event: PromiseRejectionEvent) => {
-//   console.log(
-//     "window.addEventListener unhandledrejection 1",
-//     JSON.stringify(event)
-//   );
-// };
-class WebTesteranto extends Tiposkripto_1.default {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
-        super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, (cb) => {
-            // window.removeEventListener("error", errorCallback);
-            // errorCallback = (e) => {
-            //   console.log("window.addEventListener error 2", JSON.stringify(e));
-            //   cb(e);
-            //   // throw e;
-            // };
-            // window.addEventListener("error", errorCallback);
-            // window.removeEventListener(
-            //   "unhandledrejection",
-            //   unhandledrejectionCallback
-            // );
-            // /////////////////////
-            // window.removeEventListener(
-            //   "unhandledrejection",
-            //   unhandledrejectionCallback
-            // );
-            // unhandledrejectionCallback = (event: PromiseRejectionEvent) => {
-            //   console.log(
-            //     "window.addEventListener unhandledrejection 3",
-            //     JSON.stringify(event)
-            //   );
-            //   cb({ error: event.reason.message });
-            //   // throw event;
-            // };
-            // window.addEventListener(
-            //   "unhandledrejection",
-            //   unhandledrejectionCallback
-            // );
-        });
-    }
-    async receiveTestResourceConfig(partialTestResource) {
-        const t = partialTestResource; //JSON.parse(partialTestResource);
-        const pm = new web_1.PM_Web(t);
-        return await this.testJobs[0].receiveTestResourceConfig(pm);
-    }
-}
-exports.WebTesteranto = WebTesteranto;
-exports.default = async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = index_js_1.defaultTestResourceRequirement) => {
-    return new WebTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testAdapter);
-};

package/dist/common/src/WebSidecar.js

@@ -1,14 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebSideCar = void 0;
-const Sidecar_1 = require("./lib/Sidecar");
-// import { PM_Node_Sidecar } from "./PM/nodeSidecar";
-class WebSideCar extends Sidecar_1.Sidecar {
-    start(t) {
-        throw new Error("Method not implemented.");
-    }
-    stop() {
-        throw new Error("Method not implemented.");
-    }
-}
-exports.WebSideCar = WebSideCar;