testeranto 0.202.0 → 0.205.0

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

@@ -1,482 +0,0 @@
-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
-};