testeranto.tiposkripto 0.1.4

package/dist/common/Types.js

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

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseGiven = void 0;
+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;
+    }
+}
+exports.BaseGiven = BaseGiven;

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

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSuite = void 0;
+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;
+    }
+}
+exports.BaseSuite = BaseSuite;

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseThen = void 0;
+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;
+        }
+    }
+}
+exports.BaseThen = BaseThen;

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

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./index.js");
+const BaseGiven_1 = require("./BaseGiven");
+const BaseSuite_1 = require("./BaseSuite");
+const BaseThen_1 = require("./BaseThen");
+const BaseWhen_1 = require("./BaseWhen");
+const types_js_1 = require("./types.js");
+class BaseTiposkripto {
+    constructor(webOrNode, input, testSpecification, testImplementation, testResourceRequirement = types_js_1.defaultTestResourceRequirement, testAdapter = {}, testResourceConfiguration, wsPort = "3456", wsHost = "localhost") {
+        this.totalTests = 0;
+        this.artifacts = [];
+        this.testResourceConfiguration = testResourceConfiguration;
+        const fullAdapter = (0, index_js_1.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_1.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_1.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_1.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_1.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;
+    }
+}
+exports.default = BaseTiposkripto;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseWhen = void 0;
+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;
+        }
+    }
+}
+exports.BaseWhen = BaseWhen;

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

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

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

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeTiposkripto = void 0;
+const fs_1 = __importDefault(require("fs"));
+const BaseTiposkripto_1 = __importDefault(require("./BaseTiposkripto"));
+const types_1 = require("./types");
+console.log(`[NodeTiposkripto] ${process.argv}`);
+const config = process.argv0[2];
+class NodeTiposkripto extends BaseTiposkripto_1.default {
+    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_1.default.writeFileSync(filename, payload);
+    }
+}
+exports.NodeTiposkripto = NodeTiposkripto;
+const tiposkripto = async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = types_1.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);
+    }
+};
+exports.default = tiposkripto;

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

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebTiposkripto = void 0;
+const BaseTiposkripto_js_1 = __importDefault(require("./BaseTiposkripto.js"));
+const types_js_1 = require("./types.js");
+const config = process.argv0[2];
+class WebTiposkripto extends BaseTiposkripto_js_1.default {
+    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);
+                }
+            })();
+        }
+    }
+}
+exports.WebTiposkripto = WebTiposkripto;
+const tiposkripto = async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = types_js_1.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;
+    }
+};
+exports.default = tiposkripto;