testeranto 0.100.0 → 0.111.0

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

@@ -1,316 +0,0 @@
-export class BaseSuite {
-    constructor(name, index, givens = {}, checks = []) {
-        this.name = name;
-        this.index = index;
-        this.givens = givens;
-        this.checks = checks;
-        this.fails = [];
-    }
-    features() {
-        const features = Object.keys(this.givens)
-            .map((k) => this.givens[k].features)
-            .flat()
-            .filter((value, index, array) => {
-            return array.indexOf(value) === index;
-        });
-        // .reduce((mm, lm) => {
-        //   mm[lm] = lm;
-        //   return mm;
-        // }, {});
-        return features || [];
-    }
-    toObj() {
-        const givens = Object.keys(this.givens).map((k) => this.givens[k].toObj());
-        return {
-            name: this.name,
-            givens,
-            fails: this.fails,
-            features: this.features(),
-        };
-    }
-    setup(s, artifactory, tr, pm) {
-        return new Promise((res) => res(s));
-    }
-    assertThat(t) {
-        return t;
-    }
-    afterAll(store, artifactory, pm) {
-        return store;
-    }
-    async run(input, testResourceConfiguration, artifactory, tLog, pm) {
-        this.testResourceConfiguration = testResourceConfiguration;
-        tLog("test resources: ", JSON.stringify(testResourceConfiguration));
-        const suiteArtifactory = (fPath, value) => artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
-        // console.log("\nSuite:", this.index, this.name);
-        tLog("\nSuite:", this.index, this.name);
-        const sNdx = this.index;
-        const sName = this.name;
-        for (const [gKey, g] of Object.entries(this.givens)) {
-            // console.log("gKey", gKey);
-            const beforeAllProxy = new Proxy(pm, {
-                get(target, prop, receiver) {
-                    if (prop === "customScreenShot") {
-                        return (opts, p) => target.customScreenShot(Object.assign(Object.assign({}, opts), { 
-                            // path: `${filepath}/${opts.path}`,
-                            path: `suite-${sNdx}/beforeAll/${opts.path}` }), p);
-                    }
-                    if (prop === "writeFileSync") {
-                        return (fp, contents) => target[prop](`suite-${sNdx}/beforeAll/${fp}`, contents);
-                    }
-                    return Reflect.get(...arguments);
-                },
-            });
-            const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, beforeAllProxy);
-            const giver = this.givens[gKey];
-            try {
-                this.store = await giver.give(subject, gKey, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, pm, sNdx);
-            }
-            catch (e) {
-                console.error(e);
-                this.fails.push(giver);
-                // return this;
-            }
-        }
-        try {
-            this.afterAll(this.store, artifactory, 
-            // afterAllProxy
-            pm);
-        }
-        catch (e) {
-            console.error(e);
-            // this.fails.push(this);
-            // return this;
-        }
-        // for (const [ndx, thater] of this.checks.entries()) {
-        //   await thater.check(
-        //     subject,
-        //     thater.name,
-        //     testResourceConfiguration,
-        //     this.assertThat,
-        //     suiteArtifactory,
-        //     tLog,
-        //     pm
-        //   );
-        // }
-        // @TODO fix me
-        // for (const k of Object.keys(this.givens)) {
-        //   const giver = this.givens[k];
-        //   try {
-        //     giver.afterAll(this.store, artifactory, pm);
-        //   } catch (e) {
-        //     console.error(e);
-        //     this.fails.push(giver);
-        //     return this;
-        //   }
-        // }
-        ////////////////
-        return this;
-    }
-}
-export class BaseGiven {
-    constructor(name, features, whens, thens, givenCB, initialValues
-    // key: string
-    ) {
-        this.name = name;
-        this.features = features;
-        this.whens = whens;
-        this.thens = thens;
-        this.givenCB = givenCB;
-        this.initialValues = initialValues;
-    }
-    beforeAll(store, 
-    // artifactory: ITestArtifactory
-    // subject,
-    initializer, artifactory, testResource, initialValues, pm) {
-        return store;
-    }
-    toObj() {
-        return {
-            key: this.key,
-            name: this.name,
-            whens: this.whens.map((w) => w.toObj()),
-            thens: this.thens.map((t) => t.toObj()),
-            error: this.error ? [this.error, this.error.stack] : null,
-            // fail: this.fail ? [this.fail] : false,
-            features: this.features,
-        };
-    }
-    async afterEach(store, key, artifactory, pm) {
-        return store;
-    }
-    async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm, suiteNdx) {
-        this.key = key;
-        tLog(`\n ${this.key}`);
-        tLog(`\n Given: ${this.name}`);
-        const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
-        try {
-            // tLog(`\n Given this.store`, this.store);
-            const beforeEachProxy = new Proxy(pm, {
-                get(target, prop, receiver) {
-                    if (prop === "writeFileSync") {
-                        return (fp, contents) => target[prop](`suite-${suiteNdx}/given-${key}/when/beforeEach/${fp}`, contents);
-                    }
-                    if (prop === "customScreenShot") {
-                        return (opts, p) => target.customScreenShot(Object.assign(Object.assign({}, opts), { path: `suite-${suiteNdx}/given-${key}/when/beforeEach/${opts.path}` }), p);
-                    }
-                    if (prop === "screencast") {
-                        return (opts, p) => target.screencast(Object.assign(Object.assign({}, opts), { path: `suite-${suiteNdx}/given-${key}/when/beforeEach/${opts.path}` }), p);
-                    }
-                    return Reflect.get(...arguments);
-                },
-            });
-            this.uberCatcher((e) => {
-                console.error(e);
-                this.error = e.error;
-                tLog(e.stack);
-            });
-            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues, beforeEachProxy);
-            for (const [whenNdx, whenStep] of this.whens.entries()) {
-                await whenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/when/${whenNdx}`);
-            }
-            for (const [thenNdx, thenStep] of this.thens.entries()) {
-                const t = await thenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/then-${thenNdx}`);
-                tester(t);
-            }
-        }
-        catch (e) {
-            console.error(e);
-            this.error = e;
-            tLog(e.stack);
-            // tLog("\u0007"); // bell
-            // throw e;
-        }
-        finally {
-            try {
-                const afterEachProxy = new Proxy(pm, {
-                    get(target, prop, receiver) {
-                        if (prop === "customScreenShot") {
-                            return (opts, p) => target.customScreenShot(Object.assign(Object.assign({}, opts), { path: `suite-${suiteNdx}/given-${key}/afterEach/${opts.path}` }), p);
-                        }
-                        if (prop === "writeFileSync") {
-                            return (fp, contents) => target[prop](`suite-${suiteNdx}/given-${key}/afterEach/${fp}`, contents);
-                        }
-                        return Reflect.get(...arguments);
-                    },
-                });
-                await this.afterEach(this.store, this.key, givenArtifactory, 
-                // pm
-                afterEachProxy);
-            }
-            catch (e) {
-                console.error("afterEach failed! no error will be recorded!", e);
-            }
-        }
-        return this.store;
-    }
-}
-export class BaseWhen {
-    constructor(name, whenCB) {
-        this.name = name;
-        this.whenCB = whenCB;
-    }
-    toObj() {
-        return {
-            name: this.name,
-            error: this.error,
-        };
-    }
-    async test(store, testResourceConfiguration, tLog, pm, filepath) {
-        tLog(" When:", this.name);
-        const name = this.name;
-        const andWhenProxy = new Proxy(pm, {
-            get(target, prop, receiver) {
-                if (prop === "customScreenShot") {
-                    return (opts, p) => target.customScreenShot(Object.assign(Object.assign({}, opts), { path: `${filepath}/${opts.path}` }), p);
-                }
-                if (prop === "writeFileSync") {
-                    return (fp, contents) => target[prop](`${filepath}/andWhen/${fp}`, contents);
-                }
-                return Reflect.get(...arguments);
-            },
-        });
-        return await this.andWhen(store, this.whenCB, testResourceConfiguration, andWhenProxy).catch((e) => {
-            this.error = true;
-            // throw e;
-        });
-        // try {
-        //   return await this.andWhen(
-        //     store,
-        //     this.whenCB,
-        //     testResourceConfiguration,
-        //     andWhenProxy
-        //   );
-        // } catch (e) {
-        //   this.error = true;
-        //   throw e;
-        // }
-    }
-}
-export class BaseThen {
-    constructor(name, thenCB) {
-        this.name = name;
-        this.thenCB = thenCB;
-        this.error = false;
-    }
-    toObj() {
-        return {
-            name: this.name,
-            error: this.error,
-        };
-    }
-    async test(store, testResourceConfiguration, tLog, pm, filepath) {
-        tLog(" Then:", this.name);
-        try {
-            const butThenProxy = new Proxy(pm, {
-                get(target, prop, receiver) {
-                    if (prop === "customScreenShot") {
-                        return (opts, p) => target.customScreenShot(Object.assign(Object.assign({}, opts), { path: `${filepath}/${opts.path}` }), p);
-                    }
-                    if (prop === "writeFileSync") {
-                        return (fp, contents) => target[prop](`${filepath}/${fp}`, contents);
-                    }
-                    return Reflect.get(...arguments);
-                },
-            });
-            return this.butThen(store, this.thenCB, testResourceConfiguration, butThenProxy).catch((e) => {
-                this.error = true;
-                throw e;
-            });
-        }
-        catch (e) {
-            console.log("test failed", e);
-            this.error = e.message;
-            throw e;
-        }
-    }
-}
-export class BaseCheck {
-    constructor(name, features, checkCB, whens, thens) {
-        this.name = name;
-        this.features = features;
-        this.checkCB = checkCB;
-        this.whens = whens;
-        this.thens = thens;
-    }
-    async afterEach(store, key, cb, pm) {
-        return;
-    }
-    async check(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm) {
-        tLog(`\n Check: ${this.name}`);
-        const store = await this.checkThat(subject, testResourceConfiguration, artifactory);
-        await this.checkCB(Object.entries(this.whens).reduce((a, [key, when]) => {
-            a[key] = async (payload) => {
-                return await when(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, pm, "x");
-            };
-            return a;
-        }, {}), Object.entries(this.thens).reduce((a, [key, then]) => {
-            a[key] = async (payload) => {
-                const t = await then(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, pm);
-                tester(t);
-            };
-            return a;
-        }, {}));
-        await this.afterEach(store, key, () => { }, pm);
-        return;
-    }
-}

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

@@ -1,81 +0,0 @@
-export class BaseBuilder {
-    constructor(input, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides, testResourceRequirement, testSpecification) {
-        this.input = input;
-        this.artifacts = [];
-        this.artifacts = [];
-        this.testResourceRequirement = testResourceRequirement;
-        this.suitesOverrides = suitesOverrides;
-        this.givenOverides = givenOverides;
-        this.whenOverides = whenOverides;
-        this.thenOverides = thenOverides;
-        this.checkOverides = checkOverides;
-        this.testSpecification = testSpecification;
-        this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then(), this.Check());
-        this.testJobs = this.specs.map((suite) => {
-            const suiteRunner = (suite) => async (puppetMaster, tLog) => {
-                const x = await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
-                    this.artifacts.push(p);
-                })(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value), tLog, puppetMaster);
-                return x;
-            };
-            const runner = suiteRunner(suite);
-            return {
-                test: suite,
-                toObj: () => {
-                    return suite.toObj();
-                },
-                runner,
-                receiveTestResourceConfig: async function (puppetMaster) {
-                    const logFilePath = "log.txt";
-                    const access = await puppetMaster.createWriteStream(logFilePath);
-                    const tLog = (...l) => {
-                        puppetMaster.write(access, `${l.toString()}\n`);
-                    };
-                    const suiteDone = await runner(puppetMaster, tLog);
-                    const logPromise = new Promise((res, rej) => {
-                        puppetMaster.end(access);
-                        res(true);
-                    });
-                    const numberOfFailures = Object.keys(suiteDone.givens).filter((k) => {
-                        return suiteDone.givens[k].error;
-                    }).length;
-                    puppetMaster.writeFileSync(`exitcode`, numberOfFailures.toString());
-                    // if (numberOfFailures > 0) {
-                    //   puppetMaster.writeFileSync(
-                    //     `prompt`,
-                    //     `
-                    //     aider --message "make a script that prints hello" hello.js
-                    //     `
-                    //   );
-                    // }
-                    puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2));
-                    // console.log(`exiting gracefully with ${numberOfFailures} failures.`);
-                    return {
-                        failed: numberOfFailures,
-                        artifacts: this.artifacts || [],
-                        logPromise,
-                        features: suiteDone.features(),
-                    };
-                },
-            };
-        });
-    }
-    Specs() {
-        return this.specs;
-    }
-    Suites() {
-        return this.suitesOverrides;
-    }
-    Given() {
-        return this.givenOverides;
-    }
-    When() {
-        return this.whenOverides;
-    }
-    Then() {
-        return this.thenOverides;
-    }
-    Check() {
-        return this.checkOverides;
-    }
-}

package/dist/module/src/lib/classBuilder.js

@@ -1,38 +0,0 @@
-import { BaseBuilder } from "./basebuilder.js";
-export class ClassBuilder extends BaseBuilder {
-    constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, checkKlasser, testResourceRequirement) {
-        const classySuites = Object.entries(testImplementation.suites).reduce((a, [key], index) => {
-            a[key] = (somestring, givens, checks) => {
-                return new suiteKlasser.prototype.constructor(somestring, index, givens, checks);
-            };
-            return a;
-        }, {});
-        const classyGivens = Object.entries(testImplementation.givens).reduce((a, [key, g]) => {
-            a[key] = (features, whens, thens, givEn) => {
-                return new givenKlasser.prototype.constructor(key, features, whens, thens, testImplementation.givens[key], givEn);
-            };
-            return a;
-        }, {});
-        const classyWhens = Object.entries(testImplementation.whens).reduce((a, [key, whEn]) => {
-            a[key] = (payload) => {
-                return new whenKlasser.prototype.constructor(`${whEn.name}: ${payload && payload.toString()}`, whEn(payload));
-            };
-            return a;
-        }, {});
-        const classyThens = Object.entries(testImplementation.thens).reduce((a, [key, thEn]) => {
-            a[key] = (expected, x) => {
-                return new thenKlasser.prototype.constructor(`${thEn.name}: ${expected && expected.toString()}`, thEn(expected));
-            };
-            return a;
-        }, {});
-        const classyChecks = Object.entries(testImplementation.checks).reduce((a, [key, z]) => {
-            a[key] = (somestring, features, callback) => {
-                return new checkKlasser.prototype.constructor(somestring, features, callback, classyWhens, classyThens);
-            };
-            return a;
-        }, {});
-        super(input, classySuites, classyGivens, classyWhens, classyThens, classyChecks, testResourceRequirement, testSpecification
-        // puppetMaster
-        );
-    }
-}

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

@@ -1,98 +0,0 @@
-import { DefaultTestInterface, defaultTestResourceRequirement, } from "./index.js";
-import { BaseSuite, BaseGiven, BaseWhen, BaseThen, BaseCheck, } from "./abstractBase.js";
-import { ClassBuilder } from "./classBuilder.js";
-export default class Testeranto extends ClassBuilder {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testInterface, uberCatcher) {
-        const fullTestInterface = DefaultTestInterface(testInterface);
-        super(testImplementation, testSpecification, input, class extends BaseSuite {
-            afterAll(store, artifactory, pm) {
-                return fullTestInterface.afterAll(store, (fPath, value) => {
-                    artifactory(`afterAll4-${this.name}/${fPath}`, value);
-                }, pm);
-            }
-            assertThat(t) {
-                fullTestInterface.assertThis(t);
-            }
-            async setup(s, artifactory, tr, pm) {
-                return (fullTestInterface.beforeAll ||
-                    (async (input, artifactory, tr, pm) => input))(s, this.testResourceConfiguration, artifactory, pm);
-            }
-        }, class Given extends BaseGiven {
-            constructor() {
-                super(...arguments);
-                this.uberCatcher = uberCatcher;
-            }
-            async givenThat(subject, testResource, artifactory, initializer, initialValues, pm) {
-                return fullTestInterface.beforeEach(subject, initializer, artifactory, testResource, initialValues, pm);
-            }
-            afterEach(store, key, artifactory, pm) {
-                return new Promise((res) => res(fullTestInterface.afterEach(store, key, (fPath, value) => artifactory(`after/${fPath}`, value), pm)));
-            }
-        }, class When extends BaseWhen {
-            async andWhen(store, whenCB, testResource, pm) {
-                try {
-                    return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
-                }
-                catch (e) {
-                    throw e;
-                }
-                // return fullTestInterface
-                //   .andWhen(store, whenCB, testResource, pm)
-                //   .catch((e) => {
-                //     throw e;
-                //   });
-                // return new Promise((res, rej) => {
-                //   fullTestInterface.andWhen(store, whenCB, testResource, pm);
-                // });
-                // return await fullTestInterface.andWhen(
-                //   store,
-                //   whenCB,
-                //   testResource,
-                //   pm
-                // );
-            }
-        }, class Then extends BaseThen {
-            async butThen(store, thenCB, testResource, pm) {
-                return await fullTestInterface
-                    .butThen(store, thenCB, testResource, pm)
-                    .then((v) => {
-                    return v;
-                }, (e) => {
-                    console.log(" ERROR ", e);
-                    throw e;
-                });
-                // try {
-                //   console.log("mark 4");
-                //   return await fullTestInterface.butThen(
-                //     store,
-                //     thenCB,
-                //     testResource,
-                //     pm
-                //   );
-                // } catch (e) {
-                //   console.log("mar123");
-                //   throw e;
-                // }
-                // return await fullTestInterface.butThen(
-                //   store,
-                //   thenCB,
-                //   testResourceConfiguration,
-                //   pm
-                // );
-            }
-        }, class Check extends BaseCheck {
-            constructor(name, features, checkCallback, whens, thens, initialValues) {
-                super(name, features, checkCallback, whens, thens);
-                this.initialValues = initialValues;
-            }
-            async checkThat(subject, testResourceConfiguration, artifactory, pm) {
-                return fullTestInterface.beforeEach(subject, this.initialValues, (fPath, value) => artifactory(`before/${fPath}`, value), testResourceConfiguration, this.initialValues, pm);
-            }
-            afterEach(store, key, artifactory, pm) {
-                return new Promise((res) => res(fullTestInterface.afterEach(store, key, (fPath, value) => 
-                // TODO does not work?
-                artifactory(`afterEach2-${this.name}/${fPath}`, value), pm)));
-            }
-        }, testResourceRequirement);
-    }
-}

package/dist/module/src/lib/index.js

@@ -1,18 +0,0 @@
-// import { INodeUtils, ITestInterface, IUtils, IWebUtils } from "./types.js";
-export const BaseTestInterface = {
-    beforeAll: async (s) => s,
-    beforeEach: async function (subject, initialValues, x, testResource, pm) {
-        return subject;
-    },
-    afterEach: async (s) => s,
-    afterAll: (store) => undefined,
-    butThen: async (store, thenCb) => thenCb(store),
-    andWhen: (a) => a,
-    assertThis: () => null,
-};
-export const DefaultTestInterface = (p) => {
-    return Object.assign(Object.assign({}, BaseTestInterface), p);
-};
-export const defaultTestResourceRequirement = {
-    ports: 0,
-};

package/dist/module/src/lib/types.js

@@ -1,2 +0,0 @@
-// import { IBaseTest } from "../Types";
-export {};

package/dist/module/src/puppeteerConfiger.js

@@ -1,19 +0,0 @@
-import http from "http";
-export default async (port) => new Promise((resolve, reject) => {
-    let json = "";
-    const request = http.request({
-        host: "127.0.0.1",
-        path: "/json/version",
-        port,
-    }, (response) => {
-        response.on("error", reject);
-        response.on("data", (chunk) => {
-            json += chunk.toString();
-        });
-        response.on("end", () => {
-            resolve(JSON.parse(json));
-        });
-    });
-    request.on("error", reject);
-    request.end();
-});

package/dist/module/src/utils.js

@@ -1,9 +0,0 @@
-// import { configs } from "eslint-plugin-react";
-import path from "path";
-export const destinationOfRuntime = (f, r, configs) => {
-    return path
-        .normalize(`${configs.buildDir}/${r}/${f}`)
-        .split(".")
-        .slice(0, -1)
-        .join(".");
-};

package/dist/module/src/web.html.js

@@ -1,20 +0,0 @@
-export default (jsfilePath, htmlFilePath) => `
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-  <script type="module" src="${jsfilePath}"></script>
-
-</head>
-
-<body>
-  <h1>${htmlFilePath}</h1>
-  <div id="root">
-
-  </div>
-</body>
-
-<footer></footer>
-
-</html>
-`;

package/dist/module/testeranto.js

@@ -1,13 +0,0 @@
-export default {
-    botEmail: "adamwong246@gmail.com",
-    taskman: "adamwong246/kokomobay-taskman",
-    outdir: "docs",
-    tests: [["./src/LoginButton.test.tsx", "web", { ports: 0 }, []]],
-    debugger: true,
-    clearScreen: false,
-    devMode: true,
-    minify: false,
-    outbase: ".",
-    ports: [],
-    externals: [],
-};