testeranto 0.143.0 → 0.146.0

package/testeranto/bundles/node/allTests/chunk-YI3EGRMQ.mjs

@@ -1,167 +0,0 @@
-import { createRequire } from 'module';const require = createRequire(import.meta.url);
-import {
-  PM,
-  Testeranto,
-  defaultTestResourceRequirement
-} from "./chunk-6CGAD2FD.mjs";
-
-// src/PM/pure.ts
-var PM_Pure = class extends PM {
-  constructor(t) {
-    super();
-    this.server = {};
-    this.testResourceConfiguration = t;
-  }
-  getInnerHtml(selector, page) {
-    throw new Error("pure.ts getInnHtml not implemented");
-    return Promise.resolve("");
-  }
-  stopSideCar(uid) {
-    throw new Error("pure.ts getInnHtml not implemented");
-    return Promise.resolve(true);
-  }
-  start() {
-    return new Promise((r) => r());
-  }
-  stop() {
-    return new Promise((r) => r());
-  }
-  launchSideCar(n) {
-    return globalThis["launchSideCar"](n, this.testResourceConfiguration.name);
-  }
-  pages() {
-    return globalThis["pages"]();
-  }
-  waitForSelector(p, s) {
-    return globalThis["waitForSelector"](p, s);
-  }
-  closePage(p) {
-    return globalThis["closePage"](p);
-  }
-  goto(cdpPage, url) {
-    return globalThis["goto"](cdpPage.mainFrame()._id, url);
-  }
-  newPage() {
-    return globalThis["newPage"]();
-  }
-  $(selector) {
-    return globalThis["$"](selector);
-  }
-  isDisabled(selector) {
-    return globalThis["isDisabled"](selector);
-  }
-  getAttribute(selector, attribute) {
-    return globalThis["getAttribute"](selector, attribute);
-  }
-  getValue(selector) {
-    return globalThis["getValue"](selector);
-  }
-  focusOn(selector) {
-    return globalThis["focusOn"](selector);
-  }
-  typeInto(selector, value) {
-    return globalThis["typeInto"](selector, value);
-  }
-  page() {
-    return globalThis["page"]();
-  }
-  click(selector) {
-    return globalThis["click"](selector);
-  }
-  screencast(opts, page) {
-    return globalThis["screencast"](
-      {
-        ...opts,
-        path: this.testResourceConfiguration.fs + "/" + opts.path
-      },
-      page,
-      this.testResourceConfiguration.name
-    );
-  }
-  screencastStop(p) {
-    return globalThis["screencastStop"](p);
-  }
-  customScreenShot(opts, page) {
-    return globalThis["customScreenShot"](
-      {
-        ...opts,
-        path: this.testResourceConfiguration.fs + "/" + opts.path
-      },
-      page,
-      this.testResourceConfiguration.name
-    );
-  }
-  existsSync(destFolder) {
-    return globalThis["existsSync"](
-      this.testResourceConfiguration.fs + "/" + destFolder
-    );
-  }
-  mkdirSync() {
-    return globalThis["mkdirSync"](this.testResourceConfiguration.fs + "/");
-  }
-  write(uid, contents) {
-    return globalThis["write"](uid, contents);
-  }
-  writeFileSync(filepath, contents) {
-    return globalThis["writeFileSync"](
-      this.testResourceConfiguration.fs + "/" + filepath,
-      contents,
-      this.testResourceConfiguration.name
-    );
-  }
-  createWriteStream(filepath) {
-    return globalThis["createWriteStream"](
-      this.testResourceConfiguration.fs + "/" + filepath,
-      this.testResourceConfiguration.name
-    );
-  }
-  end(uid) {
-    return globalThis["end"](uid);
-  }
-  customclose() {
-    globalThis["customclose"](
-      this.testResourceConfiguration.fs,
-      this.testResourceConfiguration.name
-    );
-  }
-  testArtiFactoryfileWriter(tLog, callback) {
-  }
-  // startPuppeteer(options?: any): any {
-  //   // return puppeteer.connect(options).then((b) => {
-  //   //   this.browser = b;
-  //   // });
-  // }
-};
-
-// src/Pure.ts
-var PureTesteranto = class extends Testeranto {
-  constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
-    super(
-      input,
-      testSpecification,
-      testImplementation,
-      testResourceRequirement,
-      testInterface,
-      () => {
-      }
-    );
-  }
-  async receiveTestResourceConfig(partialTestResource) {
-    const t = JSON.parse(partialTestResource);
-    const pm = new PM_Pure(t);
-    return await this.testJobs[0].receiveTestResourceConfig(pm);
-  }
-};
-var Pure_default = async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {
-  return new PureTesteranto(
-    input,
-    testSpecification,
-    testImplementation,
-    testResourceRequirement,
-    testInterface
-  );
-};
-
-export {
-  Pure_default
-};

package/testeranto/bundles/node/allTests/src/PM/__tests__/nodeSidecar.testeranto.mjs

@@ -1,188 +0,0 @@
-import { createRequire } from 'module';const require = createRequire(import.meta.url);
-import {
-  PM_sidecar
-} from "../../../chunk-PG6KUKNP.mjs";
-import {
-  Node_default
-} from "../../../chunk-W44DUDBK.mjs";
-import "../../../chunk-UED26IMH.mjs";
-
-// src/PM/nodeSidecar.ts
-import net from "net";
-var PM_Node_Sidecar = class extends PM_sidecar {
-  constructor(t) {
-    super();
-    this.testResourceConfiguration = t;
-    this.client = {};
-  }
-  start(stopper) {
-    return new Promise((res) => {
-      process.on("message", async (message) => {
-        if (message === "stop") {
-          console.log("STOP!", stopper.toString());
-          await stopper();
-          process.exit();
-        } else if (message.path) {
-          this.client = net.createConnection(message.path, () => {
-            res();
-          });
-        }
-      });
-    });
-  }
-  stop() {
-    return new Promise((resolve) => {
-      if (this.client) {
-        this.client.end(() => resolve());
-      } else {
-        resolve();
-      }
-    });
-  }
-  testArtiFactoryfileWriter(tLog, callback) {
-    return (fPath, value) => {
-      callback(Promise.resolve());
-    };
-  }
-  send(command, ...argz) {
-    return new Promise((res) => {
-      const key = Math.random().toString();
-      const myListener = (event) => {
-        const x = JSON.parse(event);
-        if (x.key === key) {
-          process.removeListener("message", myListener);
-          res(x.payload);
-        }
-      };
-      process.addListener("message", myListener);
-      this.client.write(JSON.stringify([command, ...argz, key]));
-    });
-  }
-};
-
-// src/PM/__tests__/nodeSidecar.testeranto.ts
-var specification = (Suite, Given, When, Then) => {
-  return [
-    Suite.SidecarInitialized(
-      "Sidecar message passing works correctly",
-      {
-        basicSend: Given.SidecarReady(
-          ["can send and receive messages"],
-          [When.SendTestMessage("test-message")],
-          [Then.MessageReceived("test-message")]
-        ),
-        cleanup: Given.SidecarReady(
-          ["cleans up listeners after message"],
-          [When.VerifyCleanup()],
-          [Then.ListenersCleaned()]
-        )
-      },
-      []
-    )
-  ];
-};
-var implementation = {
-  suites: { SidecarInitialized: (x) => x },
-  givens: {
-    SidecarReady: () => {
-      const config = {
-        name: "test-sidecar",
-        fs: "/tmp",
-        ports: [3001],
-        browserWSEndpoint: ""
-      };
-      return new PM_Node_Sidecar(config);
-    }
-  },
-  whens: {
-    SendTestMessage: (message) => async (sidecar) => {
-      let callbackFn;
-      const mockProcess = {
-        on: (event, callback) => {
-          if (event === "message") {
-            callbackFn = callback;
-            callback(
-              JSON.stringify({
-                key: "mock-key",
-                payload: message
-              })
-            );
-          }
-          return mockProcess;
-        },
-        addListener: () => mockProcess,
-        removeListener: () => mockProcess
-      };
-      process = mockProcess;
-      let writeCalled = false;
-      sidecar.client.write = (data) => {
-        writeCalled = true;
-        return true;
-      };
-      await sidecar.send("test-command", message);
-      return { writeCalled, callbackFn };
-    },
-    VerifyCleanup: () => async (sidecar) => {
-      let addListenerCalled = false;
-      let removeListenerCalled = false;
-      const mockProcess = {
-        addListener: () => {
-          addListenerCalled = true;
-          return mockProcess;
-        },
-        removeListener: () => {
-          removeListenerCalled = true;
-          return mockProcess;
-        }
-      };
-      process = mockProcess;
-      await sidecar.send("test-command", "test");
-      return { addListenerCalled, removeListenerCalled };
-    }
-  },
-  thens: {
-    MessageReceived: (expected) => (actual) => {
-      if (actual !== expected) {
-        throw new Error(`Expected "${expected}" but got "${actual}"`);
-      }
-      return actual;
-    },
-    ListenersCleaned: () => (result, { removeListenerCalled }) => {
-      if (!removeListenerCalled) {
-        throw new Error("Expected removeListener to be called");
-      }
-      return result;
-    }
-  },
-  checks: { SidecarState: () => "unknown" }
-};
-var testInterface = {
-  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-    const sidecar = initializer();
-    sidecar.client = {
-      write: () => true,
-      end: () => {
-      },
-      on: () => {
-      }
-    };
-    return sidecar;
-  },
-  andWhen: async (store, whenCB, testResource, pm) => {
-    try {
-      await whenCB(store, testResource, pm);
-    } catch (e) {
-      console.error("Error in andWhen:", e);
-      throw e;
-    }
-  }
-};
-var nodeSidecar_testeranto_default = Node_default(
-  () => new PM_Node_Sidecar({}),
-  specification,
-  implementation,
-  testInterface
-);
-export {
-  nodeSidecar_testeranto_default as default
-};

package/testeranto/bundles/node/allTests/src/PM/__tests__/pureSidecar.testeranto.mjs

@@ -1,157 +0,0 @@
-import { createRequire } from 'module';const require = createRequire(import.meta.url);
-import {
-  PM_sidecar
-} from "../../../chunk-PG6KUKNP.mjs";
-import {
-  Node_default
-} from "../../../chunk-W44DUDBK.mjs";
-import "../../../chunk-UED26IMH.mjs";
-
-// src/PM/pureSidecar.ts
-import net from "net";
-var PM_Pure_Sidecar = class extends PM_sidecar {
-  constructor(t) {
-    super();
-    this.testResourceConfiguration = t;
-  }
-  start() {
-    return new Promise((res) => {
-      process.on("message", (message) => {
-        if (message.path) {
-          this.client = net.createConnection(message.path, () => {
-            res();
-          });
-        }
-      });
-    });
-  }
-  stop() {
-    throw new Error("stop not implemented.");
-  }
-  send(command, ...argz) {
-    return new Promise((res) => {
-      const key = Math.random().toString();
-      const myListener = (event) => {
-        const x = JSON.parse(event);
-        if (x.key === key) {
-          process.removeListener("message", myListener);
-          res(x.payload);
-        }
-      };
-      process.addListener("message", myListener);
-      this.client.write(JSON.stringify([command, ...argz, key]));
-    });
-  }
-};
-
-// src/PM/__tests__/pureSidecar.testeranto.ts
-var specification = (Suite, Given, When, Then) => {
-  return [
-    Suite.SidecarInitialized(
-      "Pure Sidecar message passing works correctly",
-      {
-        basicSend: Given.SidecarReady(
-          ["can send and receive messages"],
-          [When.SendTestMessage("test-message")],
-          [Then.MessageReceived("test-message")]
-        ),
-        cleanup: Given.SidecarReady(
-          ["cleans up listeners after message"],
-          [When.VerifyCleanup()],
-          [Then.ListenersCleaned()]
-        )
-      },
-      []
-    )
-  ];
-};
-var implementation = {
-  suites: { SidecarInitialized: (x) => x },
-  givens: {
-    SidecarReady: () => {
-      const config = {
-        name: "test-pure-sidecar",
-        fs: "/tmp",
-        ports: [3001],
-        browserWSEndpoint: ""
-      };
-      return new PM_Pure_Sidecar(config);
-    }
-  },
-  whens: {
-    SendTestMessage: (message) => async (sidecar) => {
-      let callbackFn;
-      process.on = (event, callback) => {
-        if (event === "message") {
-          callbackFn = callback;
-          callback(
-            JSON.stringify({
-              key: "mock-key",
-              payload: message
-            })
-          );
-        }
-      };
-      let writeCalled = false;
-      sidecar.client.write = (data) => {
-        writeCalled = true;
-        return true;
-      };
-      await sidecar.send("test-command", message);
-      return { writeCalled, callbackFn };
-    },
-    VerifyCleanup: () => async (sidecar) => {
-      let addListenerCalled = false;
-      let removeListenerCalled = false;
-      process.addListener = () => addListenerCalled = true;
-      process.removeListener = () => removeListenerCalled = true;
-      await sidecar.send("test-command", "test");
-      return { addListenerCalled, removeListenerCalled };
-    }
-  },
-  thens: {
-    MessageReceived: (expected) => (actual) => {
-      if (actual !== expected) {
-        throw new Error(`Expected "${expected}" but got "${actual}"`);
-      }
-      return actual;
-    },
-    ListenersCleaned: () => (result, { removeListenerCalled }) => {
-      if (!removeListenerCalled) {
-        throw new Error("Expected removeListener to be called");
-      }
-      return result;
-    }
-  },
-  checks: { SidecarState: () => "unknown" }
-};
-var testInterface = {
-  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-    const sidecar = initializer();
-    sidecar.client = {
-      write: () => true,
-      end: () => {
-      },
-      on: () => {
-      }
-    };
-    return sidecar;
-  },
-  andWhen: async (store, whenCB, testResource, pm) => {
-    try {
-      await whenCB(store, testResource, pm);
-    } catch (e) {
-      console.error("Error in andWhen:", e);
-      throw e;
-    }
-  }
-};
-var pureSidecar_testeranto_default = Node_default(
-  () => new PM_Pure_Sidecar({}),
-  specification,
-  implementation,
-  testInterface
-);
-export {
-  pureSidecar_testeranto_default as default
-};

package/testeranto/bundles/node/allTests/src/PM/__tests__/webSidecar.testeranto.mjs

@@ -1,157 +0,0 @@
-import { createRequire } from 'module';const require = createRequire(import.meta.url);
-import {
-  PM_sidecar
-} from "../../../chunk-PG6KUKNP.mjs";
-import {
-  Node_default
-} from "../../../chunk-W44DUDBK.mjs";
-import "../../../chunk-UED26IMH.mjs";
-
-// src/PM/webSidecar.ts
-import net from "net";
-var PM_Web_Sidecar = class extends PM_sidecar {
-  constructor(t) {
-    super();
-    this.testResourceConfiguration = t;
-  }
-  start() {
-    return new Promise((res) => {
-      process.on("message", (message) => {
-        if (message.path) {
-          this.client = net.createConnection(message.path, () => {
-            res();
-          });
-        }
-      });
-    });
-  }
-  stop() {
-    throw new Error("stop not implemented.");
-  }
-  send(command, ...argz) {
-    return new Promise((res) => {
-      const key = Math.random().toString();
-      const myListener = (event) => {
-        const x = JSON.parse(event);
-        if (x.key === key) {
-          process.removeListener("message", myListener);
-          res(x.payload);
-        }
-      };
-      process.addListener("message", myListener);
-      this.client.write(JSON.stringify([command, ...argz, key]));
-    });
-  }
-};
-
-// src/PM/__tests__/webSidecar.testeranto.ts
-var specification = (Suite, Given, When, Then) => {
-  return [
-    Suite.SidecarInitialized(
-      "Web Sidecar message passing works correctly",
-      {
-        basicSend: Given.SidecarReady(
-          ["can send and receive messages"],
-          [When.SendTestMessage("test-message")],
-          [Then.MessageReceived("test-message")]
-        ),
-        cleanup: Given.SidecarReady(
-          ["cleans up listeners after message"],
-          [When.VerifyCleanup()],
-          [Then.ListenersCleaned()]
-        )
-      },
-      []
-    )
-  ];
-};
-var implementation = {
-  suites: { SidecarInitialized: (x) => x },
-  givens: {
-    SidecarReady: () => {
-      const config = {
-        name: "test-web-sidecar",
-        fs: "/tmp",
-        ports: [3001],
-        browserWSEndpoint: ""
-      };
-      return new PM_Web_Sidecar(config);
-    }
-  },
-  whens: {
-    SendTestMessage: (message) => async (sidecar) => {
-      let callbackFn;
-      process.on = (event, callback) => {
-        if (event === "message") {
-          callbackFn = callback;
-          callback(
-            JSON.stringify({
-              key: "mock-key",
-              payload: message
-            })
-          );
-        }
-      };
-      let writeCalled = false;
-      sidecar.client.write = (data) => {
-        writeCalled = true;
-        return true;
-      };
-      await sidecar.send("test-command", message);
-      return { writeCalled, callbackFn };
-    },
-    VerifyCleanup: () => async (sidecar) => {
-      let addListenerCalled = false;
-      let removeListenerCalled = false;
-      process.addListener = () => addListenerCalled = true;
-      process.removeListener = () => removeListenerCalled = true;
-      await sidecar.send("test-command", "test");
-      return { addListenerCalled, removeListenerCalled };
-    }
-  },
-  thens: {
-    MessageReceived: (expected) => (actual) => {
-      if (actual !== expected) {
-        throw new Error(`Expected "${expected}" but got "${actual}"`);
-      }
-      return actual;
-    },
-    ListenersCleaned: () => (result, { removeListenerCalled }) => {
-      if (!removeListenerCalled) {
-        throw new Error("Expected removeListener to be called");
-      }
-      return result;
-    }
-  },
-  checks: { SidecarState: () => "unknown" }
-};
-var testInterface = {
-  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-    const sidecar = initializer();
-    sidecar.client = {
-      write: () => true,
-      end: () => {
-      },
-      on: () => {
-      }
-    };
-    return sidecar;
-  },
-  andWhen: async (store, whenCB, testResource, pm) => {
-    try {
-      await whenCB(store, testResource, pm);
-    } catch (e) {
-      console.error("Error in andWhen:", e);
-      throw e;
-    }
-  }
-};
-var webSidecar_testeranto_default = Node_default(
-  () => new PM_Web_Sidecar({}),
-  specification,
-  implementation,
-  testInterface
-);
-export {
-  webSidecar_testeranto_default as default
-};