testeranto 0.203.0 → 0.205.0

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

@@ -0,0 +1,170 @@
+import PureTesteranto from "./Pure";
+import { MockPMBase } from "./lib/pmProxy.test/mockPMBase";
+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;
+        },
+    },
+};
+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)]),
+    }),
+];
+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 default PureTesteranto(null, specification, implementation, testAdapter);

package/dist/module/src/PureSidecar.js

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

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

package/dist/module/src/Web.js

@@ -0,0 +1,20 @@
+/* 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";
+export class WebTesteranto extends Tiposkripto {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
+        super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, (cb) => {
+            // todo
+        });
+    }
+    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

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

package/dist/module/src/app/FileService.js

@@ -0,0 +1,21 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export const FileService_methods = [
+    "writeFile_send",
+    "writeFile_receive",
+    "readFile_receive",
+    "readFile_send",
+    "createDirectory_receive",
+    "createDirectory_send",
+    "deleteFile_receive",
+    "deleteFile_send",
+    "files_send",
+    "files_receive",
+    "projects_send",
+    "projects_receive",
+    "tests_send",
+    "tests_receive",
+    "report_send",
+    "report_receive",
+];
+export class FileService {
+}

package/dist/module/src/app/api.js

@@ -0,0 +1,70 @@
+// import testeranto from "../Node";
+export var ApiFilename;
+(function (ApiFilename) {
+    ApiFilename["root"] = "./testeranto/index.html";
+    ApiFilename["style"] = "./testeranto/App.css";
+    ApiFilename["script"] = "./testeranto/App.js";
+})(ApiFilename || (ApiFilename = {}));
+export const Api = {
+    // ... other files
+    testeranto: {
+        api: {
+            tests: "/api/projects/tests",
+            report: "/api/projects/",
+            files: "/api/files/",
+        },
+        app: {
+            projects: {
+                urls: "/api/projects",
+                files: "./testeranto/projects.json",
+            },
+            root: {
+                url: "/",
+                file: "./testeranto/index.html",
+            },
+            css: {
+                url: "/",
+                file: "./testeranto/App.css",
+            },
+            script: {
+                url: "/",
+                file: "./testeranto/App.js",
+            },
+        },
+    },
+    // api: {
+    //   projects: "/api/projects/",
+    //   tests: "/api/projects/tests",
+    //   report: "/api/projects/",
+    //   files: "/api/files/",
+    // },
+    // testeranto: {
+    //   root: {
+    //     url: "/",
+    //     file: "./testeranto/index.html",
+    //   },
+    //   css: {
+    //     url: "/",
+    //     file: "./testeranto/App.css",
+    //   },
+    //   css: {
+    //     url: "/",
+    //     file: "./testeranto/App.css",
+    //   },
+    // },
+};
+export var ApiEndpoint;
+(function (ApiEndpoint) {
+    ApiEndpoint["root"] = "/testeranto/index.html";
+    ApiEndpoint["style"] = "/testeranto/App.css";
+    ApiEndpoint["script"] = "/testeranto/App.js";
+})(ApiEndpoint || (ApiEndpoint = {}));
+//
+//
+// files = "/api/files/",
+// projects = "/api/projects/",
+// tests = "/api/projects/tests",
+// report = "/api/report",
+// health = "/api/health",
+// write = "/api/files/write",
+// read = "/api/files/read",

package/dist/module/src/app/backend/PM_0.js

@@ -0,0 +1,310 @@
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import fs from "fs";
+import path from "path";
+const fileStreams3 = [];
+const fPaths = [];
+const files = {};
+const recorders = {};
+const screenshots = {};
+export class PM_0 {
+    constructor(configs, projectName, mode) {
+        this.configs = configs;
+        this.mode = mode;
+        this.projectName = projectName;
+    }
+    mapping() {
+        return [
+            ["$", this.$],
+            ["click", this.click],
+            ["closePage", this.closePage],
+            ["createWriteStream", this.createWriteStream],
+            ["customclose", this.customclose],
+            ["customScreenShot", this.customScreenShot.bind(this)],
+            ["end", this.end],
+            ["existsSync", this.existsSync],
+            ["focusOn", this.focusOn],
+            ["getAttribute", this.getAttribute],
+            ["getInnerHtml", this.getInnerHtml],
+            // ["setValue", this.setValue],
+            ["goto", this.goto.bind(this)],
+            ["isDisabled", this.isDisabled],
+            // ["launchSideCar", this.launchSideCar.bind(this)],
+            ["mkdirSync", this.mkdirSync],
+            ["newPage", this.newPage],
+            ["page", this.page],
+            ["pages", this.pages],
+            ["screencast", this.screencast],
+            ["screencastStop", this.screencastStop],
+            // ["stopSideCar", this.stopSideCar.bind(this)],
+            ["typeInto", this.typeInto],
+            ["waitForSelector", this.waitForSelector],
+            ["write", this.write],
+            ["writeFileSync", this.writeFileSync],
+        ];
+    }
+    customclose() {
+        throw new Error("customclose not implemented.");
+    }
+    waitForSelector(p, s) {
+        return new Promise((res) => {
+            this.doInPage(p, async (page) => {
+                const x = page.$(s);
+                const y = await x;
+                res(y !== null);
+            });
+        });
+    }
+    closePage(p) {
+        return new Promise((res) => {
+            this.doInPage(p, async (page) => {
+                page.close();
+                res({});
+            });
+        });
+    }
+    async newPage() {
+        return (await this.browser.newPage()).mainFrame()._id;
+    }
+    goto(p, url) {
+        return new Promise((res) => {
+            this.doInPage(p, async (page) => {
+                await (page === null || page === void 0 ? void 0 : page.goto(url));
+                res({});
+            });
+        });
+    }
+    $(selector, p) {
+        return new Promise((res) => {
+            this.doInPage(p, async (page) => {
+                const x = await page.$(selector);
+                const y = await (x === null || x === void 0 ? void 0 : x.jsonValue());
+                res(y);
+            });
+        });
+    }
+    async pages() {
+        return (await this.browser.pages()).map((p) => {
+            return p.mainFrame()._id;
+        });
+    }
+    async screencast(ssOpts, testName, page) {
+        const p = ssOpts.path;
+        const dir = path.dirname(p);
+        fs.mkdirSync(dir, {
+            recursive: true,
+        });
+        if (!files[testName]) {
+            files[testName] = new Set();
+        }
+        files[testName].add(ssOpts.path);
+        const sPromise = page.screenshot(Object.assign(Object.assign({}, ssOpts), { path: p }));
+        if (!screenshots[testName]) {
+            screenshots[testName] = [];
+        }
+        screenshots[testName].push(sPromise);
+        await sPromise;
+        return sPromise;
+    }
+    async customScreenShot(ssOpts, testName, pageUid) {
+        const p = ssOpts.path;
+        const dir = path.dirname(p);
+        fs.mkdirSync(dir, {
+            recursive: true,
+        });
+        if (!files[testName]) {
+            files[testName] = new Set();
+        }
+        files[testName].add(ssOpts.path);
+        const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageUid);
+        const sPromise = page.screenshot(Object.assign(Object.assign({}, ssOpts), { path: p }));
+        if (!screenshots[testName]) {
+            screenshots[testName] = [];
+        }
+        screenshots[testName].push(sPromise);
+        await sPromise;
+        return sPromise;
+    }
+    async end(uid) {
+        await fileStreams3[uid].end();
+        return true;
+    }
+    existsSync(destFolder) {
+        return fs.existsSync(destFolder);
+    }
+    async mkdirSync(fp) {
+        if (!fs.existsSync(fp)) {
+            return fs.mkdirSync(fp, {
+                recursive: true,
+            });
+        }
+        return false;
+    }
+    async writeFileSync(...x) {
+        const filepath = x[0];
+        const contents = x[1];
+        const testName = x[2];
+        return new Promise(async (res) => {
+            fs.mkdirSync(path.dirname(filepath), {
+                recursive: true,
+            });
+            if (!files[testName]) {
+                files[testName] = new Set();
+            }
+            files[testName].add(filepath);
+            await fs.writeFileSync(filepath, contents);
+            res(true);
+        });
+    }
+    async createWriteStream(filepath, testName) {
+        const folder = filepath.split("/").slice(0, -1).join("/");
+        return new Promise((res) => {
+            if (!fs.existsSync(folder)) {
+                return fs.mkdirSync(folder, {
+                    recursive: true,
+                });
+            }
+            const f = fs.createWriteStream(filepath);
+            fileStreams3.push(f);
+            if (!files[testName]) {
+                files[testName] = new Set();
+            }
+            files[testName].add(filepath);
+            res(fileStreams3.length - 1);
+        });
+    }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            callback(new Promise((res, rej) => {
+                tLog("testArtiFactory =>", fPath);
+                const cleanPath = path.resolve(fPath);
+                fPaths.push(cleanPath.replace(process.cwd(), ``));
+                const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+                fs.mkdir(targetDir, { recursive: true }, async (error) => {
+                    if (error) {
+                        // TODO
+                    }
+                    fs.writeFileSync(path.resolve(targetDir.split("/").slice(0, -1).join("/"), "manifest"), fPaths.join(`\n`), {
+                        encoding: "utf-8",
+                    });
+                    if (Buffer.isBuffer(value)) {
+                        fs.writeFileSync(fPath, value, "binary");
+                        res();
+                    }
+                    else if (`string` === typeof value) {
+                        fs.writeFileSync(fPath, value.toString(), {
+                            encoding: "utf-8",
+                        });
+                        res();
+                    }
+                    else {
+                        const pipeStream = value;
+                        const myFile = fs.createWriteStream(fPath);
+                        pipeStream.pipe(myFile);
+                        pipeStream.on("close", () => {
+                            myFile.close();
+                            res();
+                        });
+                    }
+                });
+            }));
+        };
+    }
+    async write(uid, contents) {
+        return new Promise((res) => {
+            const x = fileStreams3[uid].write(contents);
+            res(x);
+        });
+    }
+    page(p) {
+        return p;
+    }
+    click(selector, page) {
+        return page.click(selector);
+    }
+    async focusOn(selector, p) {
+        this.doInPage(p, (page) => {
+            return page.focus(selector);
+        });
+    }
+    async typeInto(value, p) {
+        this.doInPage(p, (page) => {
+            return page.keyboard.type(value);
+        });
+    }
+    getAttribute(selector, attribute, p) {
+        this.doInPage(p, (page) => {
+            return page.$eval(selector, (input) => input.getAttribute(attribute));
+        });
+    }
+    async getInnerHtml(selector, p) {
+        return new Promise((res, rej) => {
+            this.doInPage(p, async (page) => {
+                const e = await page.$(selector);
+                if (!e) {
+                    rej();
+                }
+                else {
+                    const text = await (await e.getProperty("textContent")).jsonValue();
+                    res(text);
+                }
+            });
+        });
+    }
+    isDisabled(selector, p) {
+        this.doInPage(p, async (page) => {
+            return await page.$eval(selector, (input) => {
+                return input.disabled;
+            });
+        });
+    }
+    screencastStop(s) {
+        return recorders[s].stop();
+    }
+    async doInPage(p, cb) {
+        (await this.browser.pages()).forEach((page) => {
+            const frame = page.mainFrame();
+            if (frame._id === p) {
+                return cb(page);
+            }
+        });
+    }
+}
+// keep this forever. do not delete
+// mapping(): [string, (...a) => any][] {
+//   return [
+//     ["$", (...args) => this.$(...args)],
+//     ["click", (...args) => this.click(...args)],
+//     ["closePage", (...args) => this.closePage(...args)],
+//     ["createWriteStream", (...args) => this.createWriteStream(...args)],
+//     ["customclose", (...args) => this.customclose(...args)],
+//     ["customScreenShot", (...args) => this.customScreenShot(...args)],
+//     ["end", (...args) => this.end(...args)],
+//     ["existsSync", (...args) => this.existsSync(...args)],
+//     ["focusOn", (...args) => this.focusOn(...args)],
+//     ["getAttribute", (...args) => this.getAttribute(...args)],
+//     ["getInnerHtml", (...args) => this.getInnerHtml(...args)],
+//     // ["setValue", (...args) => this.setValue(...args)],
+//     ["goto", (...args) => this.goto(...args)],
+//     ["isDisabled", (...args) => this.isDisabled(...args)],
+//     // ["launchSideCar", (...args) => this.launchSideCar(...args)],
+//     ["mkdirSync", (...args) => this.mkdirSync(...args)],
+//     ["newPage", (...args) => this.newPage(...args)],
+//     ["page", (...args) => this.page(...args)],
+//     ["pages", (...args) => this.pages(...args)],
+//     ["screencast", (...args) => this.screencast(...args)],
+//     ["screencastStop", (...args) => this.screencastStop(...args)],
+//     // ["stopSideCar", (...args) => this.stopSideCar(...args)],
+//     ["typeInto", (...args) => this.typeInto(...args)],
+//     ["waitForSelector", (...args) => this.waitForSelector(...args)],
+//     ["write", (...args) => this.write(...args)],
+//     ["writeFileSync", (...args) => this.writeFileSync(...args)],
+//   ];
+// }
+// abstract launchSideCar(n: number, testName: string, projectName: string);
+// setValue(value: string, p: string) {
+//   this.doInPage(p, (page) => {
+//     return page.keyboard.type(value);
+//   });
+// }