testeranto 0.200.1 → 0.202.0

package/testeranto/bundles/node/core/src/lib/pmProxy.test/index.mjs

@@ -0,0 +1,482 @@
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+import {
+  assert
+} from "../../../chunk-VXVF7WFO.mjs";
+import {
+  Node_default,
+  andWhenProxy,
+  butThenProxy
+} from "../../../chunk-RIM6RECA.mjs";
+
+// src/lib/pmProxy.test/mockPMBase.ts
+var MockPMBase = class {
+  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) {
+    return this.calls[method]?.length || 0;
+  }
+  getLastCall(method) {
+    const calls = this.calls[method];
+    return calls ? calls[calls.length - 1] : null;
+  }
+  // Add missing methods used in tests
+  // writeFileSync(path: string, content: string): Promise<boolean> {
+  //   this.trackCall('writeFileSync', { path, content });
+  //   return Promise.resolve(true);
+  // }
+  // end(uid: number): Promise<boolean> {
+  //   this.trackCall('end', { uid });
+  //   return Promise.resolve(true);
+  // }
+  // Minimal implementations of required methods
+  launchSideCar(n, testName, projectName) {
+    this.trackCall("launchSideCar", { n, testName, projectName });
+    return Promise.resolve();
+  }
+  end(uid) {
+    this.trackCall("end", { uid });
+    console.debug(`Ending test with uid ${uid}`);
+    return Promise.resolve(true);
+  }
+  // Add debug method
+  debug(message) {
+    console.debug(`[MockPMBase] ${message}`);
+    this.trackCall("debug", { message });
+  }
+  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();
+  }
+};
+
+// src/lib/pmProxy.test/implementation.ts
+var implementation = {
+  suites: {
+    Default: "PM Proxy Tests"
+  },
+  givens: {
+    SomeBaseString: (s) => s
+  },
+  whens: {
+    // functions have no mutations
+  },
+  thens: {
+    theButTheProxyReturns: (method, expectedPath) => async (store) => {
+      const mockPm = new MockPMBase();
+      const filepath = "test/path";
+      let actualPath;
+      const originalWriteFileSync = mockPm.writeFileSync;
+      mockPm.writeFileSync = async (path, content, testName) => {
+        actualPath = path;
+        return originalWriteFileSync.call(mockPm, path, content, testName);
+      };
+      const originalCreateWriteStream = mockPm.createWriteStream;
+      mockPm.createWriteStream = async (path, testName) => {
+        actualPath = path;
+        return originalCreateWriteStream.call(mockPm, path, testName);
+      };
+      const originalScreencast = mockPm.screencast;
+      mockPm.screencast = async (opts, testName, page) => {
+        actualPath = opts.path;
+        return originalScreencast.call(mockPm, opts, testName, page);
+      };
+      const originalCustomScreenShot = mockPm.customScreenShot;
+      mockPm.customScreenShot = async (opts, testName, pageUid) => {
+        actualPath = opts.path;
+        return originalCustomScreenShot.call(mockPm, opts, testName, pageUid);
+      };
+      try {
+        switch (method) {
+          case "writeFileSync":
+            await butThenProxy(mockPm, filepath, {}).writeFileSync(
+              "test.txt",
+              "content",
+              "test"
+            );
+            break;
+          case "createWriteStream":
+            await butThenProxy(mockPm, filepath, {}).createWriteStream(
+              "stream.txt",
+              "test"
+            );
+            break;
+          case "screencast":
+            await butThenProxy(mockPm, filepath, {}).screencast(
+              { path: "screen.png" },
+              "test"
+            );
+            break;
+          case "customScreenShot":
+            await butThenProxy(mockPm, filepath, {}).customScreenShot(
+              { path: "shot.png" },
+              "test"
+            );
+            break;
+          default:
+            throw new Error(`Unknown method: ${method}`);
+        }
+        return actualPath;
+      } catch (error) {
+        throw error;
+      }
+    },
+    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;
+    },
+    // Test to verify tests.json is written correctly
+    verifyTestsJsonWrite: () => async (store) => {
+      const mockPm = new MockPMBase();
+      let actualArgs;
+      const originalWriteFileSync = mockPm.writeFileSync;
+      mockPm.writeFileSync = async (...args) => {
+        actualArgs = args;
+        if (args[0] && typeof args[0] === "string") {
+          console.log(
+            `[TESTS.JSON DEBUG] First argument length: ${args[0].length}, value: "${args[0]}"`
+          );
+        }
+        return originalWriteFileSync.apply(mockPm, args);
+      };
+      const testData = { test: "data" };
+      if (actualArgs && actualArgs[0] === "test/path/butThen/tests.json" && actualArgs[1] === JSON.stringify(testData, null, 2) && actualArgs[2] === "test") {
+        return "PASS";
+      } else {
+        return `FAIL: args=${JSON.stringify(actualArgs)}`;
+      }
+    }
+  }
+};
+
+// src/lib/pmProxy.test/specification.ts
+console.log("wtf");
+var specification = (Suite, Given, When, Then) => [
+  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"
+    // ),
+    // testsJsonTest: Given.SomeBaseString(
+    //   ["butThenProxy should handle tests.json correctly"],
+    //   [],
+    //   [
+    //     Then.theButTheProxyReturns(
+    //       "writeFileSync",
+    //       "test/path/butThen/tests.json"
+    //     ),
+    //   ],
+    //   "tests.json 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"
+  //   ),
+  // }),
+];
+
+// src/lib/pmProxy.test/adapter.ts
+var testAdapter = {
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    return subject;
+  },
+  andWhen: async (store, whenCB, testResource, pm) => {
+    const proxiedPM = andWhenProxy(pm, "some/path", (path) => {
+      console.log("Artifact added:", path);
+      return path;
+    });
+    return whenCB(store, proxiedPM);
+  },
+  butThen: async (store, thenCB, testResource, pm) => {
+    const proxiedPM = butThenProxy(pm, "some/path", (path) => {
+      console.log("Artifact added:", path);
+      return 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(),
+        theGivenString
+      )
+    };
+  },
+  assertThis: (actualResult, expectedResult) => {
+    if (typeof actualResult === "string" && actualResult.startsWith("PASS")) {
+      assert.equal(actualResult, "PASS", "tests.json should be written with correct path and content");
+    } else if (typeof actualResult === "string" && actualResult.startsWith("FAIL")) {
+      assert.fail(`Test failed: ${actualResult}`);
+    } else {
+      assert.equal(actualResult, expectedResult);
+    }
+  }
+};
+
+// src/lib/pmProxy.test/index.ts
+var pmProxy_default = Node_default(
+  // because of the nature of testeranto, we must add all the testable items here
+  {
+    butThenProxy
+  },
+  specification,
+  implementation,
+  testAdapter
+);
+export {
+  pmProxy_default as default
+};