testeranto.tiposkripto 0.1.4

package/dist/module/lib/tiposkripto/src/BaseGiven.js

@@ -0,0 +1,92 @@
+export class BaseGiven {
+    addArtifact(path) {
+        if (typeof path !== "string") {
+            throw new Error(`[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(path)}`);
+        }
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
+    }
+    constructor(features, whens, thens, givenCB, initialValues) {
+        this.artifacts = [];
+        this.features = features;
+        this.whens = whens;
+        this.thens = thens;
+        this.givenCB = givenCB;
+        this.initialValues = initialValues;
+        this.fails = 0; // Initialize fail count
+    }
+    beforeAll(store) {
+        return store;
+    }
+    toObj() {
+        return {
+            key: this.key,
+            whens: (this.whens || []).map((w) => {
+                if (w && w.toObj)
+                    return w.toObj();
+                console.error("When step is not as expected!", JSON.stringify(w));
+                return {};
+            }),
+            thens: (this.thens || []).map((t) => (t && t.toObj ? t.toObj() : {})),
+            error: this.error ? [this.error, this.error.stack] : null,
+            failed: this.failed,
+            features: this.features || [],
+            artifacts: this.artifacts,
+            status: this.status,
+        };
+    }
+    async afterEach(store, key, artifactory) {
+        return store;
+    }
+    async give(subject, key, testResourceConfiguration, tester, artifactory, suiteNdx) {
+        this.key = key;
+        this.fails = 0; // Initialize fail count for this given
+        const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
+        try {
+            // Ensure addArtifact is properly bound to 'this'
+            const addArtifact = this.addArtifact.bind(this);
+            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues);
+            this.status = true;
+        }
+        catch (e) {
+            this.status = false;
+            this.failed = true;
+            this.fails++; // Increment fail count
+            this.error = e.stack;
+        }
+        try {
+            const whens = this.whens || [];
+            for (const [thenNdx, thenStep] of this.thens.entries()) {
+                try {
+                    const t = await thenStep.test(this.store, testResourceConfiguration, `suite-${suiteNdx}/given-${key}/then-${thenNdx}`);
+                    // If the test doesn't throw, it passed
+                    tester(t);
+                }
+                catch (e) {
+                    // Mark the given as failed if any then step fails
+                    this.failed = true;
+                    this.fails++; // Increment fail count
+                    // Re-throw to propagate the error
+                    throw e;
+                }
+            }
+        }
+        catch (e) {
+            this.error = e.stack;
+            this.failed = true;
+        }
+        finally {
+            try {
+                const addArtifact = this.addArtifact.bind(this);
+                await this.afterEach(this.store, this.key);
+            }
+            catch (e) {
+                this.failed = true;
+                this.fails++; // Increment fail count
+                throw e;
+                // this.error = e.message;
+            }
+        }
+        return this.store;
+    }
+}

package/dist/module/lib/tiposkripto/src/BaseSuite.js

@@ -0,0 +1,130 @@
+export class BaseSuite {
+    addArtifact(path) {
+        if (typeof path !== "string") {
+            throw new Error(`[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(path)}`);
+        }
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
+    }
+    constructor(name, index, givens = {}) {
+        this.artifacts = [];
+        const suiteName = name || "testSuite"; // Ensure name is never undefined
+        if (!suiteName) {
+            throw new Error("BaseSuite requires a non-empty name");
+        }
+        this.name = suiteName;
+        this.index = index;
+        this.givens = givens;
+        this.fails = 0;
+    }
+    features() {
+        try {
+            const features = Object.keys(this.givens)
+                .map((k) => this.givens[k].features)
+                .flat()
+                .filter((value, index, array) => {
+                return array.indexOf(value) === index;
+            });
+            // Convert all features to strings
+            const stringFeatures = features.map((feature) => {
+                if (typeof feature === "string") {
+                    return feature;
+                }
+                else if (feature && typeof feature === "object") {
+                    return feature.name || JSON.stringify(feature);
+                }
+                else {
+                    return String(feature);
+                }
+            });
+            return stringFeatures || [];
+        }
+        catch (e) {
+            console.error("[ERROR] Failed to extract features:", JSON.stringify(e));
+            return [];
+        }
+    }
+    toObj() {
+        const givens = Object.keys(this.givens).map((k) => {
+            const givenObj = this.givens[k].toObj();
+            // Ensure given features are strings
+            // if (givenObj.features) {
+            //   givenObj.features = givenObj.features.map(feature => {
+            //     return feature;
+            //     // if (typeof feature === 'string') {
+            //     //   return feature;
+            //     // } else if (feature && typeof feature === 'object') {
+            //     //   return feature.name || JSON.stringify(feature);
+            //     // } else {
+            //     //   return String(feature);
+            //     // }
+            //   });
+            // }
+            return givenObj;
+        });
+        return {
+            name: this.name,
+            givens,
+            fails: this.fails,
+            failed: this.failed,
+            features: this.features(),
+            artifacts: this.artifacts
+                ? this.artifacts.filter((art) => typeof art === "string")
+                : [],
+        };
+    }
+    setup(s, artifactory, tr
+    // pm: IPM
+    ) {
+        console.log("mark9");
+        return new Promise((res) => res(s));
+    }
+    assertThat(t) {
+        return !!t;
+    }
+    afterAll(store, artifactory) {
+        return store;
+    }
+    async run(input, testResourceConfiguration) {
+        this.testResourceConfiguration = testResourceConfiguration;
+        const sNdx = this.index;
+        const subject = await this.setup(input, 
+        // suiteArtifactory,
+        testResourceConfiguration
+        // proxiedPm
+        );
+        for (const [gKey, g] of Object.entries(this.givens)) {
+            const giver = this.givens[gKey];
+            try {
+                this.store = await giver.give(subject, gKey, testResourceConfiguration, this.assertThat, sNdx);
+                // Add the number of failures from this given to the suite's total
+                this.fails += giver.fails || 0;
+            }
+            catch (e) {
+                this.failed = true;
+                // Add 1 to fails for the caught error
+                this.fails += 1;
+                // Also add any failures from the given itself
+                if (giver.fails) {
+                    this.fails += giver.fails;
+                }
+                console.error(`Error in given ${gKey}:`, e);
+                // Don't re-throw to continue with other givens
+            }
+        }
+        // Mark the suite as failed if there are any failures
+        if (this.fails > 0) {
+            this.failed = true;
+        }
+        try {
+            // Ensure addArtifact is properly bound to 'this'
+            this.afterAll(this.store);
+        }
+        catch (e) {
+            console.error(JSON.stringify(e));
+            // this.fails.push(this);
+            // return this;
+        }
+        return this;
+    }
+}

package/dist/module/lib/tiposkripto/src/BaseThen.js

@@ -0,0 +1,61 @@
+export class BaseThen {
+    constructor(name, thenCB) {
+        this.artifacts = [];
+        this.name = name;
+        this.thenCB = thenCB;
+        this.error = false;
+        this.artifacts = [];
+    }
+    addArtifact(path) {
+        if (typeof path !== "string") {
+            throw new Error(`[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(path)}`);
+        }
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
+    }
+    toObj() {
+        const obj = {
+            name: this.name,
+            error: this.error,
+            artifacts: this.artifacts,
+            status: this.status,
+        };
+        return obj;
+    }
+    async test(store, testResourceConfiguration, 
+    // tLog: ITLog,
+    // pm: IPM,
+    filepath) {
+        // Ensure addArtifact is properly bound to 'this'
+        const addArtifact = this.addArtifact.bind(this);
+        // const proxiedPm = butThenProxy(pm, filepath, addArtifact);
+        try {
+            const x = await this.butThen(store, async (s) => {
+                try {
+                    if (typeof this.thenCB === "function") {
+                        const result = await this.thenCB(s);
+                        return result;
+                    }
+                    else {
+                        return this.thenCB;
+                    }
+                }
+                catch (e) {
+                    // Mark this then step as failed
+                    this.error = true;
+                    // Re-throw to be caught by the outer catch block
+                    throw e;
+                }
+            }, testResourceConfiguration
+            // proxiedPm
+            );
+            this.status = true;
+            return x;
+        }
+        catch (e) {
+            this.status = false;
+            this.error = true;
+            throw e;
+        }
+    }
+}

package/dist/module/lib/tiposkripto/src/BaseTiposkripto.js

@@ -0,0 +1,189 @@
+import { DefaultAdapter } from "./index.js";
+import { BaseGiven } from "./BaseGiven";
+import { BaseSuite } from "./BaseSuite";
+import { BaseThen } from "./BaseThen";
+import { BaseWhen } from "./BaseWhen";
+import { defaultTestResourceRequirement } from "./types.js";
+export default class BaseTiposkripto {
+    constructor(webOrNode, input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testAdapter = {}, testResourceConfiguration, wsPort = "3456", wsHost = "localhost") {
+        this.totalTests = 0;
+        this.artifacts = [];
+        this.testResourceConfiguration = testResourceConfiguration;
+        const fullAdapter = DefaultAdapter(testAdapter);
+        if (!testImplementation.suites ||
+            typeof testImplementation.suites !== "object") {
+            throw new Error(`testImplementation.suites must be an object, got ${typeof testImplementation.suites}: ${JSON.stringify(testImplementation.suites)}`);
+        }
+        const classySuites = Object.entries(testImplementation.suites).reduce((a, [key], index) => {
+            a[key] = (somestring, givens) => {
+                return new (class extends BaseSuite {
+                    afterAll(store) {
+                        return fullAdapter.afterAll(store);
+                    }
+                    assertThat(t) {
+                        return fullAdapter.assertThis(t);
+                    }
+                    async setup(s, tr) {
+                        var _a, _b;
+                        return ((_b = (_a = fullAdapter.beforeAll) === null || _a === void 0 ? void 0 : _a.call(fullAdapter, s, tr)) !== null && _b !== void 0 ? _b : s);
+                    }
+                })(somestring, index, givens);
+            };
+            return a;
+        }, {});
+        const classyGivens = Object.entries(testImplementation.givens).reduce((a, [key, g]) => {
+            a[key] = (features, whens, thens, gcb, initialValues) => {
+                // WTF
+                // Ensure parameters are arrays and create copies to avoid reference issues
+                const safeFeatures = Array.isArray(features) ? [...features] : [];
+                const safeWhens = Array.isArray(whens) ? [...whens] : [];
+                const safeThens = Array.isArray(thens) ? [...thens] : [];
+                return new (class extends BaseGiven {
+                    async givenThat(subject, testResource, initializer, initialValues) {
+                        return fullAdapter.beforeEach(subject, initializer, testResource, initialValues);
+                    }
+                    afterEach(store, key) {
+                        return Promise.resolve(fullAdapter.afterEach(store, key));
+                    }
+                })(safeFeatures, safeWhens, safeThens, testImplementation.givens[key], initialValues);
+            };
+            return a;
+        }, {});
+        const classyWhens = Object.entries(testImplementation.whens).reduce((a, [key, whEn]) => {
+            a[key] = (...payload) => {
+                const whenInstance = new (class extends BaseWhen {
+                    async andWhen(store, whenCB, testResource) {
+                        return await fullAdapter.andWhen(store, whenCB, testResource);
+                    }
+                })(`${key}: ${payload && payload.toString()}`, whEn(...payload));
+                return whenInstance;
+            };
+            return a;
+        }, {});
+        const classyThens = Object.entries(testImplementation.thens).reduce((a, [key, thEn]) => {
+            a[key] = (...args) => {
+                const thenInstance = new (class extends BaseThen {
+                    async butThen(store, thenCB, testResource) {
+                        return await fullAdapter.butThen(store, thenCB, testResource);
+                    }
+                })(`${key}: ${args && args.toString()}`, thEn(...args));
+                return thenInstance;
+            };
+            return a;
+        }, {});
+        this.suitesOverrides = classySuites;
+        this.givenOverrides = classyGivens;
+        this.whenOverrides = classyWhens;
+        this.thenOverrides = classyThens;
+        this.testResourceRequirement = testResourceRequirement;
+        this.testSpecification = testSpecification;
+        this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then());
+        this.totalTests = this.calculateTotalTests();
+        this.testJobs = this.specs.map((suite) => {
+            const suiteRunner = (suite) => async (testResourceConfiguration) => {
+                try {
+                    const x = await suite.run(input, testResourceConfiguration || {
+                        name: suite.name,
+                        fs: process.cwd(),
+                        ports: [],
+                        timeout: 30000,
+                        retries: 3,
+                        environment: {},
+                        files: []
+                    });
+                    return x;
+                }
+                catch (e) {
+                    console.error(e.stack);
+                    throw e;
+                }
+            };
+            const runner = suiteRunner(suite);
+            const totalTests = this.totalTests;
+            const testJob = {
+                test: suite,
+                toObj: () => {
+                    return suite.toObj();
+                },
+                runner,
+                receiveTestResourceConfig: async (testResourceConfiguration) => {
+                    try {
+                        const suiteDone = await runner(testResourceConfiguration);
+                        const fails = suiteDone.fails;
+                        return {
+                            failed: fails > 0,
+                            fails,
+                            artifacts: [], // this.artifacts is not accessible here
+                            features: suiteDone.features(),
+                            tests: 0,
+                            runTimeTests: totalTests,
+                            testJob: testJob.toObj(),
+                        };
+                    }
+                    catch (e) {
+                        console.error(e.stack);
+                        return {
+                            failed: true,
+                            fails: -1,
+                            artifacts: [],
+                            features: [],
+                            tests: 0,
+                            runTimeTests: -1,
+                            testJob: testJob.toObj(),
+                        };
+                    }
+                },
+            };
+            return testJob;
+        });
+        this.testJobs[0].receiveTestResourceConfig(testResourceConfiguration).then((results) => {
+            this.writeFileSync(`testeranto/reports/${this.testResourceConfiguration.fs}`, JSON.stringify(results));
+        });
+    }
+    async receiveTestResourceConfig(testResourceConfig) {
+        if (this.testJobs && this.testJobs.length > 0) {
+            return this.testJobs[0].receiveTestResourceConfig(testResourceConfig);
+        }
+        else {
+            throw new Error("No test jobs available");
+        }
+    }
+    Specs() {
+        return this.specs;
+    }
+    Suites() {
+        if (!this.suitesOverrides) {
+            throw new Error(`suitesOverrides is undefined. classySuites: ${JSON.stringify(Object.keys(this.suitesOverrides || {}))}`);
+        }
+        return this.suitesOverrides;
+    }
+    Given() {
+        return this.givenOverrides;
+    }
+    When() {
+        return this.whenOverrides;
+    }
+    Then() {
+        return this.thenOverrides;
+    }
+    // Add a method to access test jobs which can be used by receiveTestResourceConfig
+    getTestJobs() {
+        return this.testJobs;
+    }
+    calculateTotalTests() {
+        let total = 0;
+        for (const suite of this.specs) {
+            if (suite && typeof suite === "object") {
+                // Access the givens property which should be a record of test names to BaseGiven instances
+                // The givens property is typically on the suite instance
+                if ("givens" in suite) {
+                    const givens = suite.givens;
+                    if (givens && typeof givens === "object") {
+                        total += Object.keys(givens).length;
+                    }
+                }
+            }
+        }
+        return total;
+    }
+}

package/dist/module/lib/tiposkripto/src/BaseWhen.js

@@ -0,0 +1,42 @@
+export class BaseWhen {
+    addArtifact(path) {
+        if (typeof path !== "string") {
+            throw new Error(`[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(path)}`);
+        }
+        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
+        this.artifacts.push(normalizedPath);
+    }
+    constructor(name, whenCB) {
+        this.artifacts = [];
+        this.name = name;
+        this.whenCB = whenCB;
+    }
+    toObj() {
+        const obj = {
+            name: this.name,
+            status: this.status,
+            error: this.error
+                ? `${this.error.name}: ${this.error.message}\n${this.error.stack}`
+                : null,
+            artifacts: this.artifacts,
+        };
+        return obj;
+    }
+    async test(store, testResourceConfiguration) {
+        try {
+            // Ensure addArtifact is properly bound to 'this'
+            // const addArtifact = this.addArtifact.bind(this);
+            // const proxiedPm = andWhenProxy(pm, filepath, addArtifact);
+            const result = await this.andWhen(store, this.whenCB, testResourceConfiguration
+            // proxiedPm
+            );
+            this.status = true;
+            return result;
+        }
+        catch (e) {
+            this.status = false;
+            this.error = e;
+            throw e;
+        }
+    }
+}

package/dist/module/lib/tiposkripto/src/CoreTypes.js

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

package/dist/module/lib/tiposkripto/src/Node.js

@@ -0,0 +1,30 @@
+import fs from "fs";
+import BaseTiposkripto from "./BaseTiposkripto";
+import { defaultTestResourceRequirement } from "./types";
+console.log(`[NodeTiposkripto] ${process.argv}`);
+const config = process.argv0[2];
+export class NodeTiposkripto extends BaseTiposkripto {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
+        super("node", input, testSpecification, testImplementation, testResourceRequirement, testAdapter, config);
+    }
+    writeFileSync(filename, payload) {
+        // console.log('writeFileSync', filename)
+        // const dir = `testeranto/reports/${this.testResourceConfiguration.fs}`;
+        // if (!fs.existsSync(dir)) {
+        //   fs.mkdirSync(dir, { recursive: true });
+        // }
+        fs.writeFileSync(filename, payload);
+    }
+}
+const tiposkripto = async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = defaultTestResourceRequirement) => {
+    try {
+        const t = new NodeTiposkripto(input, testSpecification, testImplementation, testResourceRequirement, testAdapter);
+        return t;
+    }
+    catch (e) {
+        console.error(`[Node] Error creating Tiposkripto:`, e);
+        console.error(e.stack);
+        process.exit(-1);
+    }
+};
+export default tiposkripto;

package/dist/module/lib/tiposkripto/src/Web.js

@@ -0,0 +1,55 @@
+import BaseTiposkripto from "./BaseTiposkripto.js";
+import { defaultTestResourceRequirement } from "./types.js";
+const config = process.argv0[2];
+export class WebTiposkripto extends BaseTiposkripto {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
+        const urlParams = new URLSearchParams(window.location.search);
+        const encodedConfig = urlParams.get("config");
+        const testResourceConfig = encodedConfig
+            ? decodeURIComponent(encodedConfig)
+            : "{}";
+        super("web", input, testSpecification, testImplementation, testResourceRequirement, testAdapter, 
+        // JSON.parse(testResourceConfig)
+        config);
+    }
+    writeFileSync(filename, payload) {
+        // Store files in a global object that can be accessed via Puppeteer
+        if (!window.__testeranto_files__) {
+            window.__testeranto_files__ = {};
+        }
+        window.__testeranto_files__[filename] = payload;
+        // Also try to use the File System Access API if available
+        if (navigator.storage && navigator.storage.getDirectory) {
+            (async () => {
+                try {
+                    const root = await navigator.storage.getDirectory();
+                    const fileHandle = await root.getFileHandle(filename, { create: true });
+                    const writable = await fileHandle.createWritable();
+                    await writable.write(payload);
+                    await writable.close();
+                }
+                catch (e) {
+                    console.warn('Could not write to browser storage:', e);
+                }
+            })();
+        }
+    }
+}
+const tiposkripto = async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = defaultTestResourceRequirement) => {
+    try {
+        const t = new WebTiposkripto(input, testSpecification, testImplementation, testResourceRequirement, testAdapter);
+        // const data = navigator.storage.
+        const root = await navigator.storage.getDirectory();
+        // 1. Create (or get) a file handle
+        const fileHandle = await root.getFileHandle(`${config.fs}/tests.json`);
+        return t;
+    }
+    catch (e) {
+        console.error(e);
+        // Dispatch an error event
+        const errorEvent = new CustomEvent("test-error", { detail: e });
+        window.dispatchEvent(errorEvent);
+        throw e;
+    }
+};
+export default tiposkripto;

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

@@ -0,0 +1,48 @@
+import { defaultTestResourceRequirement } from "./types";
+// let tpskrt;
+// // Use esbuild define to distinguish environments
+// declare const ENV: "node" | "web";
+// if (ENV === "node") {
+//   tpskrt = await import("./Node");
+// } else if (ENV === "web") {
+//   tpskrt = await import("./Web");
+// } else {
+//   throw `Unknown ENV ${ENV}`;
+// }
+let tpskrt;
+const tpskrtNode = await import("./Node");
+// const tpskrtWeb = await import("./Web");
+tpskrt = tpskrtNode;
+// Use esbuild define to distinguish environments
+// declare const ENV: "node" | "web";
+// if (ENV === "node") {
+//   tpskrt = tpskrtNode
+// } else if (ENV === "web") {
+//   tpskrt = tpskrtWeb
+// } else {
+//   throw `Unknown ENV ${ENV}`;
+// }
+export default async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = defaultTestResourceRequirement, testResourceConfiguration) => {
+    return (await tpskrt.default)(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, testResourceConfiguration);
+};
+export const BaseAdapter = () => ({
+    beforeAll: async (input, testResource) => {
+        return input;
+    },
+    beforeEach: async function (subject, initializer, testResource, initialValues) {
+        return subject;
+    },
+    afterEach: async (store, key) => Promise.resolve(store),
+    afterAll: (store) => undefined,
+    butThen: async (store, thenCb, testResource) => {
+        return thenCb(store);
+    },
+    andWhen: async (store, whenCB, testResource) => {
+        return whenCB(store);
+    },
+    assertThis: (x) => x,
+});
+export const DefaultAdapter = (p) => {
+    const base = BaseAdapter();
+    return Object.assign(Object.assign({}, base), p);
+};

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

@@ -0,0 +1,3 @@
+export const defaultTestResourceRequirement = {
+    ports: 0,
+};

package/dist/module/lib/tiposkripto/tests/abstractBase.test/MockGiven.js

@@ -0,0 +1,18 @@
+import { BaseGiven } from "../BaseGiven";
+export class MockGiven extends BaseGiven {
+    constructor(name, features, whens, thens, givenCB, initialValues) {
+        super(name, features, whens, thens, givenCB, initialValues);
+    }
+    async givenThat(subject, testResourceConfiguration, artifactory, givenCB, initialValues) {
+        // Call the givenCB which is a function that returns the store
+        const result = givenCB();
+        if (typeof result === "function") {
+            return result();
+        }
+        return result;
+    }
+    uberCatcher(e) {
+        console.error("MockGiven error:", e);
+        this.error = e;
+    }
+}