testeranto 0.146.2 → 0.146.5

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

@@ -0,0 +1,111 @@
+export 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();
+    }
+}

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

@@ -0,0 +1,35 @@
+export 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"),
+    }),
+];

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

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

package/dist/module/src/run.js

@@ -4,25 +4,25 @@ import { PM_Main } from "./PM/main";
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
-console.log(ansiC.inverse("Press 'x' to shutdown forcefully."));
+console.log(ansiC.inverse("Press 'q' to initiate a graceful shutdown."));
+console.log(ansiC.inverse("Press 'x' to quit forcefully."));
 process.stdin.on("keypress", (str, key) => {
     if (key.name === "x") {
         console.log(ansiC.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);
 import(process.cwd() + "/" + "testeranto.config.ts").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 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 PM_Main(config, projectName, mode);
     pm.start();
     process.stdin.on("keypress", (str, key) => {
         if (key.name === "q") {

package/dist/module/testeranto.config.js

@@ -1,41 +1,56 @@
-// 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.");
             },
@@ -79,8 +94,8 @@ const config = {
             webPlugins: [],
             nodePlugins: [],
             importPlugins: [],
-            externalTests: {},
         },
     },
+    reportDomain: "https://adamwong246.github.io/testeranto/testeranto",
 };
 export default config;