testeranto 0.146.2 → 0.146.5

package/dist/common/src/lib/pmProxy.js

@@ -1,7 +1,9 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.afterAllProxy = exports.beforeAllProxy = exports.beforeEachProxy = exports.afterEachProxy = exports.andWhenProxy = exports.butThenProxy = void 0;
-const prxy = function (pm, mappings) {
+const baseProxy = function (pm, mappings) {
     return new Proxy(pm, {
         get: (target, prop, receiver) => {
             for (const mapping of mappings) {
@@ -15,7 +17,7 @@ const prxy = function (pm, mappings) {
         },
     });
 };
-const butThenProxy = (pm, filepath) => prxy(pm, [
+const butThenProxy = (pm, filepath) => baseProxy(pm, [
     [
         "screencast",
         (opts, p) => [
@@ -37,7 +39,7 @@ const butThenProxy = (pm, filepath) => prxy(pm, [
     ],
 ]);
 exports.butThenProxy = butThenProxy;
-const andWhenProxy = (pm, filepath) => prxy(pm, [
+const andWhenProxy = (pm, filepath) => baseProxy(pm, [
     [
         "screencast",
         (opts, p) => [
@@ -56,7 +58,7 @@ const andWhenProxy = (pm, filepath) => prxy(pm, [
     ],
 ]);
 exports.andWhenProxy = andWhenProxy;
-const afterEachProxy = (pm, suite, given) => prxy(pm, [
+const afterEachProxy = (pm, suite, given) => baseProxy(pm, [
     [
         "screencast",
         (opts, p) => [
@@ -81,7 +83,7 @@ const afterEachProxy = (pm, suite, given) => prxy(pm, [
     ],
 ]);
 exports.afterEachProxy = afterEachProxy;
-const beforeEachProxy = (pm, suite) => prxy(pm, [
+const beforeEachProxy = (pm, suite) => baseProxy(pm, [
     [
         "screencast",
         (opts, p) => [
@@ -103,7 +105,7 @@ const beforeEachProxy = (pm, suite) => prxy(pm, [
     ["createWriteStream", (fp) => [`suite-${suite}/beforeEach/${fp}`]],
 ]);
 exports.beforeEachProxy = beforeEachProxy;
-const beforeAllProxy = (pm, suite) => prxy(pm, [
+const beforeAllProxy = (pm, suite) => baseProxy(pm, [
     [
         "writeFileSync",
         (fp, contents) => [`suite-${suite}/beforeAll/${fp}`, contents],
@@ -118,7 +120,7 @@ const beforeAllProxy = (pm, suite) => prxy(pm, [
     ["createWriteStream", (fp) => [`suite-${suite}/beforeAll/${fp}`]],
 ]);
 exports.beforeAllProxy = beforeAllProxy;
-const afterAllProxy = (pm, suite) => prxy(pm, [
+const afterAllProxy = (pm, suite) => baseProxy(pm, [
     ["createWriteStream", (fp) => [`suite-${suite}/afterAll/${fp}`]],
     [
         "writeFileSync",
@@ -133,162 +135,3 @@ const afterAllProxy = (pm, suite) => prxy(pm, [
     ],
 ]);
 exports.afterAllProxy = afterAllProxy;
-/////////////////////////////////////////////////
-// export const butThenProxy = (pm: IPM, filepath: string) => {
-//   return new Proxy(pm, {
-//     get: (target, prop, receiver) => {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               path: `${filepath}/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) => target[prop](`${filepath}/${fp}`, contents);
-//       }
-//     },
-//   });
-// };
-// export const andWhenProxy = (pm: IPM, filepath: string) => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               path: `${filepath}/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](`${filepath}/andWhen/${fp}`, contents);
-//       }
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };
-// export const afterEachProxy = (pm: IPM, suite: string, given: string): IPM => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               path: `suite-${suite}/given-${given}/afterEach/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](
-//             `suite-${suite}/given-${given}/afterEach/${fp}`,
-//             contents
-//           );
-//       }
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };
-// export const beforeAllProxy = (pm: IPM, suite: string): IPM => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               // path: `${filepath}/${opts.path}`,
-//               path: `suite-${suite}/beforeAll/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](`suite-${suite}/beforeAll/${fp}`, contents);
-//       }
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };
-// export const beforeEachProxy = (pm: IPM, suite: string, given: string): IPM => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       // if (prop === "write") {
-//       //   return (handle, contents) =>
-//       //     target[prop](
-//       //       `suite-${suiteNdx}/given-${key}/when/beforeEach/${fp}`,
-//       //       contents
-//       //     );
-//       // }
-//       if (prop === "createWriteStream") {
-//         return (fp) =>
-//           target[prop](`suite-${suite}/given-${given}/when/beforeEach/${fp}`);
-//       }
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](
-//             `suite-${suite}/given-${given}/when/beforeEach/${fp}`,
-//             contents
-//           );
-//       }
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               path: `suite-${suite}/given-${given}/when/beforeEach/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       if (prop === "screencast") {
-//         return (opts, p) =>
-//           target.screencast(
-//             {
-//               ...opts,
-//               path: `suite-${suite}/given-${given}/when/beforeEach/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };
-// export const afterAllProxy = (pm: IPM, suite: string): IPM => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               // path: `${filepath}/${opts.path}`,
-//               path: `suite-${suite}/afterAll/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](`suite-${suite}/afterAll/${fp}`, contents);
-//       }
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };

package/dist/common/src/lib/pmProxy.test/implementation.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.implementation = void 0;
+const mockPMBase_1 = require("./mockPMBase");
+exports.implementation = {
+    suites: {
+        Default: "PM Proxy Tests",
+    },
+    givens: {
+        SomeBaseString: (s) => s,
+    },
+    whens: {
+    // functions have no mutations
+    },
+    thens: {
+        theButTheProxyReturns: (method, expectedPath) => (store) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const mockPm = new mockPMBase_1.MockPMBase();
+            const filepath = "test/path";
+            const proxiedPm = store.butThenProxy(mockPm, filepath);
+            let actualPath;
+            let actualContent;
+            try {
+                switch (method) {
+                    case "writeFileSync":
+                        const content = expectedPath.includes('content') ?
+                            "test content" : "default content";
+                        proxiedPm.writeFileSync(expectedPath.includes('empty') ? "" :
+                            expectedPath.includes('nested') ? "nested/folder/test.txt" :
+                                expectedPath.includes('spaces') ? "file with spaces.txt" :
+                                    expectedPath.includes('invalid') ? "../invalid.txt" :
+                                        "test.txt", content);
+                        actualPath = (_a = mockPm.getLastCall("writeFileSync")) === null || _a === void 0 ? void 0 : _a.path;
+                        actualContent = (_b = mockPm.getLastCall("writeFileSync")) === null || _b === void 0 ? void 0 : _b.content;
+                        break;
+                    case "createWriteStream":
+                        proxiedPm.createWriteStream(expectedPath.includes('empty') ? "" : "stream.txt");
+                        actualPath = (_c = mockPm.getLastCall("createWriteStream")) === null || _c === void 0 ? void 0 : _c.path;
+                        break;
+                    case "screencast":
+                        proxiedPm.screencast({
+                            path: "screen.png",
+                            quality: 80,
+                            fullPage: true
+                        }, "test");
+                        actualPath = (_e = (_d = mockPm.getLastCall("screencast")) === null || _d === void 0 ? void 0 : _d.opts) === null || _e === void 0 ? void 0 : _e.path;
+                        actualContent = (_f = mockPm.getLastCall("screencast")) === null || _f === void 0 ? void 0 : _f.opts;
+                        break;
+                    case "customScreenShot":
+                        proxiedPm.customScreenShot({ path: "shot.png" }, "test");
+                        actualPath = (_h = (_g = mockPm.getLastCall("customScreenShot")) === null || _g === void 0 ? void 0 : _g.opts) === null || _h === void 0 ? void 0 : _h.path;
+                        break;
+                    default:
+                        throw new Error(`Unknown method: ${method}`);
+                }
+                if (expectedPath === undefined) {
+                    return [undefined, undefined];
+                }
+                return [actualPath, expectedPath, actualContent];
+            }
+            catch (error) {
+                return [error.message, expectedPath];
+            }
+        },
+        verifyContent: (expectedContent) => (result) => {
+            const actualContent = result[2];
+            if (JSON.stringify(actualContent) !== JSON.stringify(expectedContent)) {
+                throw new Error(`Content mismatch. Expected: ${JSON.stringify(expectedContent)}, Got: ${JSON.stringify(actualContent)}`);
+            }
+            return result;
+        },
+    },
+    checks: {
+        Default: (s) => s,
+    },
+};

package/dist/common/src/lib/pmProxy.test/index.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Node_1 = __importDefault(require("../../Node"));
+const implementation_1 = require("./implementation");
+const specification_1 = require("./specification");
+const interface_1 = require("./interface");
+const pmProxy_1 = require("../pmProxy");
+exports.default = (0, Node_1.default)(
+// because of the nature of testeranto, we must add all the testable items here
+{
+    butThenProxy: pmProxy_1.butThenProxy,
+}, specification_1.specification, implementation_1.implementation, interface_1.testInterface);

package/dist/common/src/lib/pmProxy.test/interface.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testInterface = void 0;
+const chai_1 = require("chai");
+const pmProxy_1 = require("../pmProxy");
+const mockPMBase_1 = require("./mockPMBase");
+// import { butThenProxy, andWhenProxy, beforeEachProxy } from "../pmProxy";
+exports.testInterface = {
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        return subject;
+        // const mockPM = MockPMBase();
+        // return {
+        //   beforeEachProxy: subject.butThenProxy(
+        //     new MockPMBase() as unknown as IPM,
+        //     initializer
+        //   ),
+        // };
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        const proxiedPM = (0, pmProxy_1.andWhenProxy)(pm, "some/path");
+        return whenCB(store, proxiedPM);
+    },
+    butThen: async (store, thenCB, testResource, pm) => {
+        const proxiedPM = (0, pmProxy_1.butThenProxy)(pm, "some/path");
+        return thenCB(store, proxiedPM);
+    },
+    afterEach: async (store, key, pm) => store,
+    afterAll: async (store, pm) => { },
+    beforeAll: async (input, testResource, pm, theGivenString) => {
+        return {
+            beforeEachProxy: input.butThenProxy(new mockPMBase_1.MockPMBase(), theGivenString),
+        };
+    },
+    assertThis: (returnedFilePath, expectation) => {
+        chai_1.assert.equal(returnedFilePath, expectation);
+    },
+};

package/dist/common/src/lib/pmProxy.test/mockPM.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockPM = void 0;
+const mockPMBase_1 = require("./mockPMBase");
+class MockPM extends mockPMBase_1.MockPMBase {
+    constructor(configs) {
+        super(configs);
+        this.server = {};
+        this.testResourceConfiguration = {};
+    }
+    // PM-specific methods
+    start() {
+        this.trackCall("start", {});
+        return Promise.resolve();
+    }
+    stop() {
+        this.trackCall("stop", {});
+        return Promise.resolve();
+    }
+    launchSideCar(n) {
+        this.trackCall("launchSideCar", { n });
+        return Promise.resolve([n, this.testResourceConfiguration]);
+    }
+    stopSideCar(n) {
+        this.trackCall("stopSideCar", { n });
+        return Promise.resolve();
+    }
+    // Override any methods that need different behavior from MockPMBase
+    // For example:
+    writeFileSync(path, content) {
+        return super.writeFileSync(path, content, "default-test-name");
+    }
+}
+exports.MockPM = MockPM;

package/dist/common/src/lib/pmProxy.test/mockPMBase.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockPMBase = void 0;
+class MockPMBase {
+    constructor(configs) {
+        this.calls = {};
+        this.testResourceConfiguration = {};
+        this.configs = configs || {};
+    }
+    // Common tracking functionality
+    trackCall(method, args) {
+        if (!this.calls[method]) {
+            this.calls[method] = [];
+        }
+        this.calls[method].push(args);
+    }
+    getCallCount(method) {
+        var _a;
+        return ((_a = this.calls[method]) === null || _a === void 0 ? void 0 : _a.length) || 0;
+    }
+    getLastCall(method) {
+        const calls = this.calls[method];
+        return calls ? calls[calls.length - 1] : null;
+    }
+    // Minimal implementations of required methods
+    launchSideCar(n, testName, projectName) {
+        this.trackCall("launchSideCar", { n, testName, projectName });
+        return Promise.resolve();
+    }
+    end(uid) {
+        this.trackCall("end", { uid });
+        return Promise.resolve(true);
+    }
+    writeFileSync(path, content, testName) {
+        this.trackCall("writeFileSync", { path, content, testName });
+        return Promise.resolve(true);
+    }
+    createWriteStream(path, testName) {
+        this.trackCall("createWriteStream", { path, testName });
+        return Promise.resolve(0);
+    }
+    screencast(opts, testName, page) {
+        this.trackCall("screencast", { opts, testName, page });
+        return Promise.resolve({});
+    }
+    customScreenShot(opts, testName, pageUid) {
+        this.trackCall("customScreenShot", { opts, testName, pageUid });
+        return Promise.resolve({});
+    }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            this.trackCall("testArtiFactoryfileWriter", { fPath, value });
+            callback(Promise.resolve());
+        };
+    }
+    // Other required PM_Base methods with minimal implementations
+    closePage(p) {
+        return Promise.resolve();
+    }
+    $(selector, p) {
+        return Promise.resolve();
+    }
+    click(selector, page) {
+        return Promise.resolve();
+    }
+    goto(p, url) {
+        return Promise.resolve();
+    }
+    newPage() {
+        return Promise.resolve("mock-page");
+    }
+    pages() {
+        return Promise.resolve(["mock-page"]);
+    }
+    waitForSelector(p, s) {
+        return Promise.resolve(true);
+    }
+    focusOn(selector, p) {
+        return Promise.resolve();
+    }
+    typeInto(value, p) {
+        return Promise.resolve();
+    }
+    getAttribute(selector, attribute, p) {
+        return Promise.resolve();
+    }
+    getInnerHtml(selector, p) {
+        return Promise.resolve();
+    }
+    isDisabled(selector, p) {
+        return Promise.resolve(false);
+    }
+    screencastStop(s) {
+        return Promise.resolve();
+    }
+    existsSync(destFolder) {
+        return false;
+    }
+    mkdirSync(fp) {
+        return Promise.resolve();
+    }
+    write(uid, contents) {
+        return Promise.resolve(true);
+    }
+    page(p) {
+        return "mock-page";
+    }
+    doInPage(p, cb) {
+        return Promise.resolve();
+    }
+    customclose() {
+        return Promise.resolve();
+    }
+}
+exports.MockPMBase = MockPMBase;

package/dist/common/src/lib/pmProxy.test/specification.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specification = void 0;
+const specification = (Suite, Given, When, Then, Check) => [
+    Suite.Default("PM Proxy Functionality", {
+        // Basic path rewriting tests
+        writeFileProxyTest: Given.SomeBaseString(["butThenProxy should rewrite writeFileSync paths"], [], [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/test.txt")], "writeFileSync test"),
+        createWriteStreamProxyTest: Given.SomeBaseString(["butThenProxy should rewrite createWriteStream paths"], [], [Then.theButTheProxyReturns("createWriteStream", "test/path/butThen/stream.txt")], "createWriteStream test"),
+        screencastProxyTest: Given.SomeBaseString(["butThenProxy should rewrite screencast paths"], [], [Then.theButTheProxyReturns("screencast", "test/path/butThen/screen.png")], "screencast test"),
+        customScreenShotProxyTest: Given.SomeBaseString(["butThenProxy should rewrite customScreenShot paths"], [], [Then.theButTheProxyReturns("customScreenShot", "test/path/butThen/shot.png")], "customScreenShot test"),
+        // Edge cases
+        emptyPathTest: Given.SomeBaseString(["butThenProxy should handle empty paths"], [], [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/")], "empty path test"),
+        nestedPathTest: Given.SomeBaseString(["butThenProxy should handle nested paths"], [], [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/nested/folder/test.txt")], "nested path test"),
+        specialCharsTest: Given.SomeBaseString(["butThenProxy should handle special characters in paths"], [], [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/file with spaces.txt")], "special chars test"),
+    }),
+    Suite.Default("Proxy Type Coverage", {
+        // Test all proxy types
+        butThenProxyTest: Given.SomeBaseString(["butThenProxy should work correctly"], [], [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/test.txt")], "butThenProxy test"),
+        andWhenProxyTest: Given.SomeBaseString(["andWhenProxy should work correctly"], [], [Then.theButTheProxyReturns("writeFileSync", "test/path/andWhen/test.txt")], "andWhenProxy test"),
+        beforeEachProxyTest: Given.SomeBaseString(["beforeEachProxy should work correctly"], [], [Then.theButTheProxyReturns("writeFileSync", "suite-1/beforeEach/test.txt")], "beforeEachProxy test"),
+        afterEachProxyTest: Given.SomeBaseString(["afterEachProxy should work correctly"], [], [Then.theButTheProxyReturns("writeFileSync", "suite-1/given-1/afterEach/test.txt")], "afterEachProxy test"),
+    }),
+    Suite.Default("Content Preservation", {
+        // Verify content is preserved
+        contentPreservationTest: Given.SomeBaseString(["Proxies should preserve file content"], [], [
+            Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/test.txt"),
+            Then.verifyContent("test content")
+        ], "content preservation test"),
+        objectContentTest: Given.SomeBaseString(["Proxies should preserve object content"], [], [
+            Then.theButTheProxyReturns("screencast", "test/path/butThen/screen.png"),
+            Then.verifyContent({ quality: 80, fullPage: true })
+        ], "object content test"),
+    }),
+    Suite.Default("Error Cases", {
+        invalidPathTest: Given.SomeBaseString(["Proxies should handle invalid paths"], [], [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/../invalid.txt")], "invalid path test"),
+        undefinedInputTest: Given.SomeBaseString(["Proxies should handle undefined inputs"], [], [Then.theButTheProxyReturns("writeFileSync", undefined)], "undefined input test"),
+    }),
+];
+exports.specification = specification;

package/dist/common/src/lib/pmProxy.test/types.js

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

package/dist/common/src/run.js

@@ -42,25 +42,25 @@ const main_1 = require("./PM/main");
 readline_1.default.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
-console.log(ansi_colors_1.default.inverse("Press 'x' to shutdown forcefully."));
+console.log(ansi_colors_1.default.inverse("Press 'q' to initiate a graceful shutdown."));
+console.log(ansi_colors_1.default.inverse("Press 'x' to quit forcefully."));
 process.stdin.on("keypress", (str, key) => {
     if (key.name === "x") {
         console.log(ansi_colors_1.default.inverse("Shutting down forcefully..."));
         process.exit(-1);
     }
 });
-const testName = process.argv[2];
+const projectName = process.argv[2];
 const mode = process.argv[3];
 if (mode !== "once" && mode !== "dev") {
     console.error("the 2nd argument should be 'dev' or 'once' ");
     process.exit(-1);
 }
-console.log("testeranto is running", testName, mode);
 Promise.resolve(`${process.cwd() + "/" + "testeranto.config.ts"}`).then(s => __importStar(require(s))).then(async (module) => {
     const bigConfig = module.default;
-    const rawConfig = bigConfig.projects[testName];
-    const config = Object.assign(Object.assign({}, rawConfig), { buildDir: process.cwd() + "/" + `testeranto/${testName}.json` });
-    const pm = new main_1.PM_Main(config, testName, mode);
+    const rawConfig = bigConfig.projects[projectName];
+    const config = Object.assign(Object.assign({}, rawConfig), { buildDir: process.cwd() + "/" + `testeranto/${projectName}.json` });
+    const pm = new main_1.PM_Main(config, projectName, mode);
     pm.start();
     process.stdin.on("keypress", (str, key) => {
         if (key.name === "q") {

package/dist/common/testeranto.config.js

@@ -1,43 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-// import redux from "testeranto_with_reduxjs_toolkit/testeranto.config";
-// import solidity from "testeranto-solidity/testeranto.config";
 const config = {
     projects: {
-        // redux: {
-        //   ...redux.projects.allTests,
-        //   src: "node_modules/testeranto_with_reduxjs_toolkit",
-        // },
-        // solidity: {
-        //   ...solidity.projects.solidity,
-        //   src: "node_modules/testeranto-solidity",
-        // },
-        mothership: {
+        allTests: {
             tests: [
-                // ["./src/mothership/test.ts", "node", { ports: 1 }, []],
+                ["src/lib/BaseSuite.test/node.test.ts", "node", { ports: 0 }, []],
+                ["src/lib/BaseSuite.test/pure.test.ts", "pure", { ports: 0 }, []],
+                ["src/lib/BaseSuite.test/web.test.ts", "web", { ports: 0 }, []],
+                ["src/Pure.test.ts", "pure", { ports: 0 }, []],
+                ["src/lib/pmProxy.test/index.ts", "node", { ports: 0 }, []],
+                ["src/lib/core.test/core.test.ts", "node", { ports: 0 }, []],
                 [
-                    "./src/PM/__tests__/nodeSidecar.testeranto.ts",
+                    "src/lib/classBuilder.test/classBuilder.test.ts",
                     "node",
-                    { ports: 1 },
+                    { ports: 0 },
+                    [],
+                ],
+                [
+                    "src/lib/baseBuilder.test/baseBuilder.test.node.ts",
+                    "node",
+                    { ports: 0 },
+                    [],
+                ],
+                [
+                    "src/lib/baseBuilder.test/baseBuilder.test.pure.ts",
+                    "pure",
+                    { ports: 0 },
+                    [],
+                ],
+                [
+                    "src/lib/baseBuilder.test/baseBuilder.test.web.ts",
+                    "web",
+                    { ports: 0 },
                     [],
                 ],
+                // ["src/mothership/test.ts", "node", { ports: 0 }, []],
+                // ["./src/lib/abstractBase/index.ts", "node", { ports: 0 }, []],
                 // [
-                //   "./src/PM/__tests__/pureSidecar.testeranto.ts",
+                //   "src/PM/__tests__/nodeSidecar.testeranto.ts",
                 //   "node",
                 //   { ports: 1 },
                 //   [],
                 // ],
                 // [
-                //   "./src/PM/__tests__/webSidecar.testeranto.ts",
+                //   "src/PM/__tests__/pureSidecar.testeranto.ts",
                 //   "node",
                 //   { ports: 1 },
                 //   [],
                 // ],
+                // ["src/PM/__tests__/webSidecar.testeranto.ts", "node", { ports: 1 }, []],
             ],
             clearScreen: false,
             debugger: false,
             externals: [],
-            externalTests: {},
             featureIngestor: function (s) {
                 throw new Error("Function not implemented.");
             },
@@ -81,8 +96,8 @@ const config = {
             webPlugins: [],
             nodePlugins: [],
             importPlugins: [],
-            externalTests: {},
         },
     },
+    reportDomain: "https://adamwong246.github.io/testeranto/testeranto",
 };
 exports.default = config;