testeranto 0.200.1 → 0.203.0

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

@@ -1,175 +0,0 @@
-import PureTesteranto from "./Pure";
-import { MockPMBase } from "./lib/pmProxy.test/mockPMBase";
-// Implementation for PureTesteranto tests
-const implementation = {
-    suites: {
-        Default: "PureTesteranto Test Suite",
-    },
-    givens: {
-        Default: () => {
-            const pm = new 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
-export default PureTesteranto(null, // No initial input
-specification, implementation, testAdapter);

package/dist/module/src/PureSidecar.js

@@ -1,9 +0,0 @@
-import { Sidecar } from "./lib/Sidecar";
-export class PureSideCar extends Sidecar {
-    start(t) {
-        throw new Error("Method not implemented.");
-    }
-    stop() {
-        throw new Error("Method not implemented.");
-    }
-}

package/dist/module/src/ReportServer.js

@@ -1,9 +0,0 @@
-import { ReportServerOfPort } from "./ReportServerLib";
-import { startDesignEditorServer } from "../design-editor/server";
-const port = process.argv[2] || 3000;
-const wssPort = Number(port) + 1; // Use next port for WebSocket
-// Start both servers
-ReportServerOfPort(port);
-startDesignEditorServer(wssPort);
-console.log(`Report server running on http://localhost:${port}`);
-console.log(`Design editor WebSocket running on ws://localhost:${wssPort}`);

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

@@ -1,73 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import testeranto from "../Node";
-import { ReportServerOfPort } from "../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.");
-    },
-};
-export default testeranto(ReportServerOfPort, specification, implementation, adapter);

package/dist/module/src/ReportServerLib.js

@@ -1,134 +0,0 @@
-// simple http server to preview reports
-import staticServer from "node-static";
-import http from "http";
-import path from "path";
-import fs from "fs";
-const fileServer = new staticServer.Server("./", {
-    cache: false,
-    headers: {
-        "Cache-Control": "no-cache, no-store, must-revalidate",
-        Pragma: "no-cache",
-        Expires: "0",
-    },
-});
-const server = http.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.join(process.cwd(), req.url || "");
-            // First check if file exists
-            fs.stat(filePath, (err, stats) => {
-                if (err || !stats.isFile()) {
-                    // Check if directory exists
-                    fs.stat(filePath, (dirErr, dirStats) => {
-                        if (!dirErr && dirStats.isDirectory()) {
-                            // Serve directory listing
-                            fs.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.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");
-    }
-};
-export const ReportServerOfPort = (port) => start(port);

package/dist/module/src/Types.js

@@ -1 +0,0 @@
-export {};

package/dist/module/src/Web.js

@@ -1,54 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { PM_Web } from "./PM/web";
-import Tiposkripto from "./lib/Tiposkripto";
-import { defaultTestResourceRequirement, } from "./lib/index.js";
-// let errorCallback = (e: any) => {};
-// let unhandledrejectionCallback = (event: PromiseRejectionEvent) => {
-//   console.log(
-//     "window.addEventListener unhandledrejection 1",
-//     JSON.stringify(event)
-//   );
-// };
-export class WebTesteranto extends Tiposkripto {
-    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 PM_Web(t);
-        return await this.testJobs[0].receiveTestResourceConfig(pm);
-    }
-}
-export default async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = defaultTestResourceRequirement) => {
-    return new WebTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testAdapter);
-};

package/dist/module/src/WebSidecar.js

@@ -1,10 +0,0 @@
-import { Sidecar } from "./lib/Sidecar";
-// import { PM_Node_Sidecar } from "./PM/nodeSidecar";
-export class WebSideCar extends Sidecar {
-    start(t) {
-        throw new Error("Method not implemented.");
-    }
-    stop() {
-        throw new Error("Method not implemented.");
-    }
-}

package/dist/module/src/components/DesignEditorPage.js

@@ -1,168 +0,0 @@
-import React, { useRef, useState } from 'react';
-import { DesignEditor } from '../../design-editor/DesignEditor';
-import { Button, Container, Row, Col } from 'react-bootstrap';
-import { saveAs } from 'file-saver';
-export const DesignEditorPage = () => {
-    const [projectId, setProjectId] = useState('default-project');
-    const [fileHandle, setFileHandle] = useState(null);
-    const handleSave = async () => {
-        try {
-            if (!designEditorRef.current) {
-                console.warn('Design editor ref not available');
-                return;
-            }
-            // Get and save current design state
-            const designData = designEditorRef.current.saveDesign();
-            if (!designData) {
-                console.warn('No design data to save');
-                return;
-            }
-            // Include projectId in the saved data
-            const fullDesign = Object.assign(Object.assign({}, designData), { projectId });
-            // Force immediate render after save
-            if (designEditorRef.current) {
-                designEditorRef.current.loadDesign(fullDesign);
-            }
-            let newHandle;
-            if ('showSaveFilePicker' in window && window.showSaveFilePicker) {
-                try {
-                    newHandle = await window.showSaveFilePicker({
-                        types: [{
-                                description: 'Design Files',
-                                accept: {
-                                    'application/json': ['.json'],
-                                },
-                            }],
-                        suggestedName: `${projectId}.json`
-                    });
-                }
-                catch (err) {
-                    console.warn('Error using showSaveFilePicker:', err);
-                    // Fall back to traditional download
-                    const jsonData = JSON.stringify(fullDesign, null, 2);
-                    const blob = new Blob([jsonData], { type: 'application/json' });
-                    const url = URL.createObjectURL(blob);
-                    const a = document.createElement('a');
-                    a.href = url;
-                    a.download = `${projectId}.json`;
-                    a.click();
-                    URL.revokeObjectURL(url);
-                    return;
-                }
-            }
-            else {
-                // Fall back to traditional download
-                const jsonData = JSON.stringify(fullDesign, null, 2);
-                const blob = new Blob([jsonData], { type: 'application/json' });
-                const url = URL.createObjectURL(blob);
-                const a = document.createElement('a');
-                a.href = url;
-                a.download = `${projectId}.json`;
-                a.click();
-                URL.revokeObjectURL(url);
-                return;
-            }
-            const jsonData = JSON.stringify(fullDesign, null, 2);
-            const writable = await newHandle.createWritable();
-            await writable.write(jsonData);
-            await writable.close();
-            setFileHandle(newHandle);
-            console.log('Design saved successfully:', fullDesign);
-        }
-        catch (err) {
-            console.error('Error saving file:', err);
-            if (err instanceof Error) {
-                console.error('Error details:', {
-                    name: err.name,
-                    message: err.message,
-                    stack: err.stack
-                });
-            }
-        }
-    };
-    const [design, setDesign] = useState(null);
-    const designEditorRef = useRef(null);
-    const handleOpen = async () => {
-        console.log('handleOpen triggered');
-        try {
-            if (!window.showOpenFilePicker) {
-                throw new Error('File System Access API not supported in this browser');
-            }
-            console.log('Attempting to show file picker...');
-            let handle;
-            if ('showOpenFilePicker' in window) {
-                // @ts-ignore
-                [handle] = await window.showOpenFilePicker({
-                    types: [{
-                            description: 'Design Files',
-                            accept: {
-                                'application/json': ['.json'],
-                            },
-                        }],
-                    multiple: false
-                });
-            }
-            else {
-                throw new Error('File System Access API not supported');
-            }
-            if (!handle) {
-                throw new Error('No file selected');
-            }
-            console.log('File handle obtained:', handle);
-            const file = await handle.getFile();
-            console.log('File object obtained:', file);
-            const contents = await file.text();
-            console.log('File contents loaded, length:', contents.length);
-            let loadedDesign = JSON.parse(contents);
-            console.log('Design parsed successfully:', loadedDesign);
-            // Ensure design has proper structure
-            if (!loadedDesign.objects || !loadedDesign.version) {
-                loadedDesign = Object.assign({ version: '1.0', background: '#ffffff', objects: [] }, loadedDesign);
-            }
-            // Validate objects array exists
-            if (!Array.isArray(loadedDesign.objects)) {
-                loadedDesign.objects = [];
-            }
-            const newProjectId = loadedDesign.projectId || 'default-project';
-            console.log('Setting projectId to:', newProjectId);
-            setProjectId(newProjectId);
-            console.log('Setting design state...');
-            setDesign(loadedDesign);
-            setFileHandle(handle);
-            // Load the design into the editor
-            if (designEditorRef.current) {
-                console.log('Calling loadDesign on editor ref with:', loadedDesign);
-                designEditorRef.current.loadDesign(loadedDesign);
-            }
-            else {
-                console.warn('designEditorRef.current is null');
-            }
-        }
-        catch (err) {
-            console.error('Error opening file:', err);
-            if (err instanceof Error) {
-                console.error('Error details:', {
-                    name: err.name,
-                    message: err.message,
-                    stack: err.stack
-                });
-            }
-        }
-    };
-    const handleExport = () => {
-        const designData = JSON.stringify({ projectId }, null, 2);
-        const blob = new Blob([designData], { type: 'application/json' });
-        saveAs(blob, `${projectId}.json`);
-    };
-    return (React.createElement(Container, { fluid: true },
-        React.createElement(Row, { className: "mb-3" },
-            React.createElement(Col, null,
-                React.createElement("h1", null, "Design Editor"),
-                React.createElement("div", { className: "d-flex gap-2" },
-                    React.createElement(Button, { variant: "primary", onClick: handleOpen }, "Open"),
-                    React.createElement(Button, { variant: "success", onClick: handleSave }, "Save"),
-                    React.createElement(Button, { variant: "secondary", onClick: handleExport }, "Export")))),
-        React.createElement(Row, null,
-            React.createElement(Col, null,
-                React.createElement(DesignEditor, { projectId: projectId, ref: designEditorRef })))));
-};