testeranto 0.128.0 → 0.134.0

package/testeranto/bundles/node/mothership/src/PM/__tests__/sidecar.testeranto.mjs

@@ -0,0 +1,1199 @@
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+
+// src/PM/nodeSidecar.ts
+import net from "net";
+
+// src/PM/sidecar.ts
+var PM_sidecar = class {
+  testArtiFactoryfileWriter(tLog, callback) {
+    return (fPath, value) => {
+      callback(Promise.resolve());
+    };
+  }
+  // abstract $(selector: string): any;
+  // abstract click(selector: string): any;
+  // abstract closePage(p): any;
+  // abstract createWriteStream(
+  //   filepath: string,
+  //   testName: string
+  // ): Promise<string>;
+  // abstract customclose();
+  // abstract customScreenShot(opts: object, page?: string): any;
+  // abstract end(uid: number): Promise<boolean>;
+  // abstract existsSync(fp: string): Promise<boolean>;
+  // abstract focusOn(selector: string): any;
+  // abstract getAttribute(selector: string, attribute: string): any;
+  // abstract getValue(value: string): any;
+  // abstract goto(p, url: string): any;
+  // abstract isDisabled(selector: string): Promise<boolean>;
+  // abstract mkdirSync(a: string);
+  // abstract newPage(): Promise<string>;
+  // abstract page(): Promise<string | undefined>;
+  // abstract pages(): Promise<string[]>;
+  // abstract screencast(o: ScreenRecorderOptions, p: Page | string): any;
+  // abstract screencastStop(s: string): any;
+  // abstract typeInto(selector: string, value: string): any;
+  // abstract waitForSelector(p, sel: string);
+  // abstract write(uid: number, contents: string): Promise<boolean>;
+  // abstract writeFileSync(f: string, c: string, t: string): Promise<boolean>;
+  // abstract launchSideCar(
+  //   n: number
+  // ): Promise<[number, ITTestResourceConfiguration]>;
+  // abstract stopSideCar(n: number): Promise<any>;
+};
+
+// src/PM/nodeSidecar.ts
+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/lib/index.ts
+var BaseTestInterface = {
+  beforeAll: async (s) => s,
+  beforeEach: async function(subject, initialValues, x, testResource, pm) {
+    return subject;
+  },
+  afterEach: async (s) => s,
+  afterAll: (store) => void 0,
+  butThen: async (store, thenCb) => {
+    return thenCb(store);
+  },
+  andWhen: async (store, whenCB, testResource, pm) => {
+    await whenCB(store, testResource, pm);
+  },
+  assertThis: (x) => x
+};
+var DefaultTestInterface = (p) => {
+  return {
+    ...BaseTestInterface,
+    ...p
+  };
+};
+var defaultTestResourceRequirement = {
+  ports: 0
+};
+
+// src/lib/pmProxy.ts
+var prxy = function(pm, mappings) {
+  return new Proxy(pm, {
+    get: (target, prop, receiver) => {
+      for (const mapping of mappings) {
+        const method = mapping[0];
+        const arger = mapping[1];
+        if (prop === method) {
+          return (...x) => target[prop](arger(...x));
+        }
+      }
+      return (...x) => target[prop](...x);
+    }
+  });
+};
+var butThenProxy = (pm, filepath) => prxy(pm, [
+  [
+    "screencast",
+    (opts, p) => [
+      {
+        ...opts,
+        path: `${filepath}/butThen/${opts.path}`
+      },
+      p
+    ]
+  ],
+  ["createWriteStream", (fp) => [`${filepath}/butThen/${fp}`]],
+  [
+    "writeFileSync",
+    (fp, contents) => [`${filepath}/butThen/${fp}`, contents]
+  ],
+  [
+    "customScreenShot",
+    (opts, p) => [
+      {
+        ...opts,
+        path: `${filepath}/butThen/${opts.path}`
+      },
+      p
+    ]
+  ]
+]);
+var andWhenProxy = (pm, filepath) => prxy(pm, [
+  [
+    "screencast",
+    (opts, p) => [
+      {
+        ...opts,
+        path: `${filepath}/andWhen/${opts.path}`
+      },
+      p
+    ]
+  ],
+  ["createWriteStream", (fp) => [`${filepath}/andWhen/${fp}`]],
+  ["writeFileSync", (fp, contents) => [`${filepath}/andWhen${fp}`, contents]],
+  [
+    "customScreenShot",
+    (opts, p) => [
+      {
+        ...opts,
+        path: `${filepath}/andWhen${opts.path}`
+      },
+      p
+    ]
+  ]
+]);
+var afterEachProxy = (pm, suite, given) => prxy(pm, [
+  [
+    "screencast",
+    (opts, p) => [
+      {
+        ...opts,
+        path: `suite-${suite}/given-${given}/afterEach/${opts.path}`
+      },
+      p
+    ]
+  ],
+  ["createWriteStream", (fp) => [`suite-${suite}/afterEach/${fp}`]],
+  [
+    "writeFileSync",
+    (fp, contents) => [
+      `suite-${suite}/given-${given}/afterEach/${fp}`,
+      contents
+    ]
+  ],
+  [
+    "customScreenShot",
+    (opts, p) => [
+      {
+        ...opts,
+        path: `suite-${suite}/given-${given}/afterEach/${opts.path}`
+      },
+      p
+    ]
+  ]
+]);
+var beforeEachProxy = (pm, suite) => prxy(pm, [
+  [
+    "screencast",
+    (opts, p) => [
+      {
+        ...opts,
+        path: `suite-${suite}/beforeEach/${opts.path}`
+      },
+      p
+    ]
+  ],
+  [
+    "writeFileSync",
+    (fp, contents) => [`suite-${suite}/beforeEach/${fp}`, contents]
+  ],
+  [
+    "customScreenShot",
+    (opts, p) => [
+      {
+        ...opts,
+        path: `suite-${suite}/beforeEach/${opts.path}`
+      },
+      p
+    ]
+  ],
+  ["createWriteStream", (fp) => [`suite-${suite}/beforeEach/${fp}`]]
+]);
+var beforeAllProxy = (pm, suite) => prxy(pm, [
+  [
+    "writeFileSync",
+    (fp, contents) => [`suite-${suite}/beforeAll/${fp}`, contents]
+  ],
+  [
+    "customScreenShot",
+    (opts, p) => [
+      {
+        ...opts,
+        path: `suite-${suite}/beforeAll/${opts.path}`
+      },
+      p
+    ]
+  ],
+  ["createWriteStream", (fp) => [`suite-${suite}/beforeAll/${fp}`]]
+]);
+var afterAllProxy = (pm, suite) => prxy(pm, [
+  ["createWriteStream", (fp) => [`suite-${suite}/afterAll/${fp}`]],
+  [
+    "writeFileSync",
+    (fp, contents) => [`suite-${suite}/afterAll/${fp}`, contents]
+  ],
+  [
+    "customScreenShot",
+    (opts, p) => [
+      {
+        ...opts,
+        path: `suite-${suite}/afterAll/${opts.path}`
+      },
+      p
+    ]
+  ]
+]);
+
+// src/lib/abstractBase.ts
+var BaseSuite = class {
+  constructor(name, index, givens = {}, checks = []) {
+    this.name = name;
+    this.index = index;
+    this.givens = givens;
+    this.checks = checks;
+    this.fails = 0;
+  }
+  features() {
+    const features = Object.keys(this.givens).map((k) => this.givens[k].features).flat().filter((value, index, array) => {
+      return array.indexOf(value) === index;
+    });
+    return features || [];
+  }
+  toObj() {
+    const givens = Object.keys(this.givens).map((k) => this.givens[k].toObj());
+    const checks = Object.keys(this.checks).map((k) => this.checks[k].toObj());
+    return {
+      name: this.name,
+      givens,
+      checks,
+      fails: this.fails,
+      failed: this.failed,
+      features: this.features()
+    };
+  }
+  setup(s, artifactory, tr, pm) {
+    return new Promise((res) => res(s));
+  }
+  assertThat(t) {
+    return !!t;
+  }
+  afterAll(store, artifactory, pm) {
+    return store;
+  }
+  async run(input, testResourceConfiguration, artifactory, tLog, pm) {
+    this.testResourceConfiguration = testResourceConfiguration;
+    const suiteArtifactory = (fPath, value) => artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
+    tLog("\nSuite:", this.index, this.name);
+    const sNdx = this.index;
+    const subject = await this.setup(
+      input,
+      suiteArtifactory,
+      testResourceConfiguration,
+      beforeAllProxy(pm, sNdx.toString())
+    );
+    for (const [gKey, g] of Object.entries(this.givens)) {
+      const giver = this.givens[gKey];
+      try {
+        this.store = await giver.give(
+          subject,
+          gKey,
+          testResourceConfiguration,
+          this.assertThat,
+          suiteArtifactory,
+          tLog,
+          pm,
+          sNdx
+        );
+      } catch (e) {
+        this.failed = true;
+        this.fails = this.fails + 1;
+      }
+    }
+    for (const [ndx, thater] of this.checks.entries()) {
+      await thater.check(
+        subject,
+        thater.name,
+        testResourceConfiguration,
+        this.assertThat,
+        suiteArtifactory,
+        tLog,
+        pm
+      );
+    }
+    try {
+      this.afterAll(
+        this.store,
+        artifactory,
+        afterAllProxy(pm, sNdx.toString())
+      );
+    } catch (e) {
+      console.error(e);
+    }
+    return this;
+  }
+};
+var BaseGiven = class {
+  constructor(name, features, whens, thens, givenCB, initialValues) {
+    this.name = name;
+    this.features = features;
+    this.whens = whens;
+    this.thens = thens;
+    this.givenCB = givenCB;
+    this.initialValues = initialValues;
+  }
+  beforeAll(store) {
+    return store;
+  }
+  toObj() {
+    return {
+      key: this.key,
+      name: this.name,
+      whens: this.whens.map((w) => w.toObj()),
+      thens: this.thens.map((t) => t.toObj()),
+      error: this.error ? [this.error, this.error.stack] : null,
+      failed: this.failed,
+      features: this.features
+    };
+  }
+  async afterEach(store, key, artifactory, pm) {
+    return store;
+  }
+  async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm, suiteNdx) {
+    this.key = key;
+    tLog(`
+ ${this.key}`);
+    tLog(`
+ Given: ${this.name}`);
+    const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
+    this.uberCatcher((e) => {
+      console.error(e);
+      this.error = e.error;
+      tLog(e.stack);
+    });
+    try {
+      this.store = await this.givenThat(
+        subject,
+        testResourceConfiguration,
+        givenArtifactory,
+        this.givenCB,
+        this.initialValues,
+        beforeEachProxy(pm, suiteNdx.toString())
+      );
+    } catch (e) {
+      console.error("failure 4 ", e);
+      this.error = e;
+      throw e;
+    }
+    try {
+      for (const [whenNdx, whenStep] of this.whens.entries()) {
+        await whenStep.test(
+          this.store,
+          testResourceConfiguration,
+          tLog,
+          pm,
+          `suite-${suiteNdx}/given-${key}/when/${whenNdx}`
+        );
+      }
+      for (const [thenNdx, thenStep] of this.thens.entries()) {
+        const t = await thenStep.test(
+          this.store,
+          testResourceConfiguration,
+          tLog,
+          pm,
+          `suite-${suiteNdx}/given-${key}/then-${thenNdx}`
+        );
+        return tester(t);
+      }
+    } catch (e) {
+      this.failed = true;
+      tLog(e.stack);
+      throw e;
+    } finally {
+      try {
+        await this.afterEach(
+          this.store,
+          this.key,
+          givenArtifactory,
+          afterEachProxy(pm, suiteNdx.toString(), key)
+        );
+      } catch (e) {
+        console.error("afterEach failed!", e);
+        this.failed = e;
+        throw e;
+      }
+    }
+    return this.store;
+  }
+};
+var BaseWhen = class {
+  constructor(name, whenCB) {
+    this.name = name;
+    this.whenCB = whenCB;
+  }
+  toObj() {
+    console.log("toObj error", this.error);
+    return {
+      name: this.name,
+      error: this.error && this.error.name + this.error.stack
+    };
+  }
+  async test(store, testResourceConfiguration, tLog, pm, filepath) {
+    tLog(" When:", this.name);
+    return await this.andWhen(
+      store,
+      this.whenCB,
+      testResourceConfiguration,
+      andWhenProxy(pm, filepath)
+    ).catch((e) => {
+      console.log("MARK9", e);
+      this.error = e;
+      throw e;
+    });
+  }
+};
+var BaseThen = class {
+  constructor(name, thenCB) {
+    this.name = name;
+    this.thenCB = thenCB;
+    this.error = false;
+  }
+  toObj() {
+    return {
+      name: this.name,
+      error: this.error
+    };
+  }
+  async test(store, testResourceConfiguration, tLog, pm, filepath) {
+    return this.butThen(
+      store,
+      async (s) => {
+        tLog(" Then!!!:", this.name);
+        if (typeof this.thenCB === "function") {
+          return await this.thenCB(s);
+        } else {
+          return this.thenCB;
+        }
+      },
+      testResourceConfiguration,
+      butThenProxy(pm, filepath)
+    ).catch((e) => {
+      console.log("test failed 3", e);
+      this.error = e;
+      throw e;
+    });
+  }
+  check() {
+  }
+};
+var BaseCheck = class {
+  constructor(name, features, checker, x, checkCB) {
+    this.name = name;
+    this.features = features;
+    this.checkCB = checkCB;
+    this.checker = checker;
+  }
+  toObj() {
+    return {
+      key: this.key,
+      name: this.name,
+      // functionAsString: this.checkCB.toString(),
+      features: this.features
+    };
+  }
+  async afterEach(store, key, artifactory, pm) {
+    return store;
+  }
+  beforeAll(store) {
+    return store;
+  }
+  async check(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm) {
+    this.key = key;
+    tLog(`
+ Check: ${this.name}`);
+    this.store = await this.checkThat(
+      subject,
+      testResourceConfiguration,
+      artifactory,
+      this.checkCB,
+      this.initialValues,
+      pm
+    );
+    await this.checker(this.store, pm);
+    return;
+  }
+};
+
+// src/lib/basebuilder.ts
+var BaseBuilder = class {
+  constructor(input, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides, testResourceRequirement, testSpecification) {
+    this.artifacts = [];
+    this.artifacts = [];
+    this.testResourceRequirement = testResourceRequirement;
+    this.suitesOverrides = suitesOverrides;
+    this.givenOverides = givenOverides;
+    this.whenOverides = whenOverides;
+    this.thenOverides = thenOverides;
+    this.checkOverides = checkOverides;
+    this.testSpecification = testSpecification;
+    this.specs = testSpecification(
+      this.Suites(),
+      this.Given(),
+      this.When(),
+      this.Then(),
+      this.Check()
+    );
+    this.testJobs = this.specs.map((suite) => {
+      const suiteRunner = (suite2) => async (puppetMaster, tLog) => {
+        const x = await suite2.run(
+          input,
+          puppetMaster.testResourceConfiguration,
+          (fPath, value) => puppetMaster.testArtiFactoryfileWriter(
+            tLog,
+            (p) => {
+              this.artifacts.push(p);
+            }
+          )(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value),
+          tLog,
+          puppetMaster
+        );
+        return x;
+      };
+      const runner = suiteRunner(suite);
+      return {
+        test: suite,
+        toObj: () => {
+          return suite.toObj();
+        },
+        runner,
+        receiveTestResourceConfig: async function(puppetMaster) {
+          const logFilePath = "log.txt";
+          const access = await puppetMaster.createWriteStream(
+            logFilePath
+          );
+          const tLog = async (...l) => {
+          };
+          const suiteDone = await runner(puppetMaster, tLog);
+          const logPromise = new Promise(async (res) => {
+            await puppetMaster.end(access);
+            res(true);
+          });
+          const fails = suiteDone.fails;
+          await puppetMaster.writeFileSync(`bdd_errors.txt`, fails.toString());
+          await puppetMaster.writeFileSync(
+            `tests.json`,
+            JSON.stringify(this.toObj(), null, 2)
+          );
+          return {
+            failed: fails > 0,
+            fails,
+            artifacts: this.artifacts || [],
+            logPromise,
+            features: suiteDone.features()
+          };
+        }
+      };
+    });
+  }
+  // testsJson() {
+  //   puppetMaster.writeFileSync(
+  //     `tests.json`,
+  //     JSON.stringify({ features: suiteDone.features() }, null, 2)
+  //   );
+  // }
+  Specs() {
+    return this.specs;
+  }
+  Suites() {
+    return this.suitesOverrides;
+  }
+  Given() {
+    return this.givenOverides;
+  }
+  When() {
+    return this.whenOverides;
+  }
+  Then() {
+    return this.thenOverides;
+  }
+  Check() {
+    return this.checkOverides;
+  }
+};
+
+// src/lib/classBuilder.ts
+var ClassBuilder = class extends BaseBuilder {
+  constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, checkKlasser, testResourceRequirement) {
+    const classySuites = Object.entries(testImplementation.suites).reduce(
+      (a, [key], index) => {
+        a[key] = (somestring, givens, checks) => {
+          return new suiteKlasser.prototype.constructor(
+            somestring,
+            index,
+            givens,
+            checks
+          );
+        };
+        return a;
+      },
+      {}
+    );
+    const classyGivens = Object.entries(testImplementation.givens).reduce(
+      (a, [key, g]) => {
+        a[key] = (features, whens, thens, ...initialValues) => {
+          return new givenKlasser.prototype.constructor(
+            key,
+            features,
+            whens,
+            thens,
+            testImplementation.givens[key],
+            initialValues
+          );
+        };
+        return a;
+      },
+      {}
+    );
+    const classyWhens = Object.entries(testImplementation.whens).reduce(
+      (a, [key, whEn]) => {
+        a[key] = (payload) => {
+          return new whenKlasser.prototype.constructor(
+            `${whEn.name}: ${payload && payload.toString()}`,
+            whEn(payload)
+          );
+        };
+        return a;
+      },
+      {}
+    );
+    const classyThens = Object.entries(testImplementation.thens).reduce(
+      (a, [key, thEn]) => {
+        a[key] = (expected, ...x) => {
+          return new thenKlasser.prototype.constructor(
+            `${thEn.name}: ${expected && expected.toString()}`,
+            thEn(expected, ...x)
+          );
+        };
+        return a;
+      },
+      {}
+    );
+    const classyChecks = Object.entries(testImplementation.checks).reduce(
+      (a, [key, chEck]) => {
+        a[key] = (name, features, checker) => {
+          return new checkKlasser.prototype.constructor(
+            key,
+            features,
+            chEck,
+            checker
+          );
+        };
+        return a;
+      },
+      {}
+    );
+    super(
+      input,
+      classySuites,
+      classyGivens,
+      classyWhens,
+      classyThens,
+      classyChecks,
+      testResourceRequirement,
+      testSpecification
+    );
+  }
+};
+
+// src/lib/core.ts
+var Testeranto = class extends ClassBuilder {
+  constructor(input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testInterface2, uberCatcher) {
+    const fullTestInterface = DefaultTestInterface(testInterface2);
+    super(
+      testImplementation,
+      testSpecification,
+      input,
+      class extends BaseSuite {
+        afterAll(store, artifactory, pm) {
+          return fullTestInterface.afterAll(store, pm);
+        }
+        assertThat(t) {
+          return fullTestInterface.assertThis(t);
+        }
+        async setup(s, artifactory, tr, pm) {
+          return (fullTestInterface.beforeAll || (async (input2, artifactory2, tr2, pm2) => input2))(
+            s,
+            this.testResourceConfiguration,
+            // artifactory,
+            pm
+          );
+        }
+      },
+      class Given extends BaseGiven {
+        constructor() {
+          super(...arguments);
+          this.uberCatcher = uberCatcher;
+        }
+        async givenThat(subject, testResource, artifactory, initializer, initialValues, pm) {
+          return fullTestInterface.beforeEach(
+            subject,
+            initializer,
+            testResource,
+            initialValues,
+            pm
+          );
+        }
+        afterEach(store, key, artifactory, pm) {
+          return new Promise(
+            (res) => res(fullTestInterface.afterEach(store, key, pm))
+          );
+        }
+      },
+      class When extends BaseWhen {
+        async andWhen(store, whenCB, testResource, pm) {
+          return await fullTestInterface.andWhen(
+            store,
+            whenCB,
+            testResource,
+            pm
+          );
+        }
+      },
+      class Then extends BaseThen {
+        async butThen(store, thenCB, testResource, pm) {
+          return await fullTestInterface.butThen(
+            store,
+            thenCB,
+            testResource,
+            pm
+          );
+        }
+      },
+      class Check extends BaseCheck {
+        constructor(name, features, checkCallback, x, i, c) {
+          super(name, features, checkCallback, x, c);
+          this.initialValues = i;
+        }
+        async checkThat(subject, testResourceConfiguration, artifactory, initializer, initialValues, pm) {
+          return fullTestInterface.beforeEach(
+            subject,
+            initializer,
+            testResourceConfiguration,
+            initialValues,
+            pm
+          );
+        }
+        afterEach(store, key, artifactory, pm) {
+          return new Promise(
+            (res) => res(fullTestInterface.afterEach(store, key, pm))
+          );
+        }
+      },
+      testResourceRequirement
+    );
+  }
+};
+
+// src/PM/node.ts
+import net2 from "net";
+import fs from "fs";
+import path from "path";
+
+// src/PM/index.ts
+var PM = class {
+};
+
+// src/PM/node.ts
+var fPaths = [];
+var PM_Node = class extends PM {
+  constructor(t, ipcFile) {
+    super();
+    this.testResourceConfiguration = t;
+    this.client = net2.createConnection(ipcFile, () => {
+      return;
+    });
+  }
+  start() {
+    throw new Error("DEPREFECATED");
+  }
+  stop() {
+    throw new Error("stop not implemented.");
+  }
+  send(command, ...argz) {
+    const key = Math.random().toString();
+    if (!this.client) {
+      console.error(
+        `Tried to send "${command} (${argz})" but the test has not been started and the IPC client is not established. Exiting as failure!`
+      );
+      process.exit(-1);
+    }
+    return new Promise((res) => {
+      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]));
+    });
+  }
+  async launchSideCar(n) {
+    return this.send(
+      "launchSideCar",
+      n,
+      this.testResourceConfiguration.name
+    );
+  }
+  stopSideCar(n) {
+    return this.send(
+      "stopSideCar",
+      n,
+      this.testResourceConfiguration.name
+    );
+  }
+  async pages() {
+    return this.send("pages", ...arguments);
+  }
+  waitForSelector(p, s) {
+    return this.send("waitForSelector", ...arguments);
+  }
+  closePage(p) {
+    return this.send("closePage", ...arguments);
+  }
+  goto(page, url) {
+    return this.send("goto", ...arguments);
+  }
+  async newPage() {
+    return this.send("newPage");
+  }
+  $(selector, page) {
+    return this.send("$", ...arguments);
+  }
+  isDisabled(selector) {
+    return this.send("isDisabled", ...arguments);
+  }
+  getAttribute(selector, attribute, p) {
+    return this.send("getAttribute", ...arguments);
+  }
+  getInnerHtml(selector, p) {
+    return this.send("getInnerHtml", ...arguments);
+  }
+  // setValue(selector: string) {
+  //   return this.send("getValue", ...arguments);
+  // }
+  focusOn(selector) {
+    return this.send("focusOn", ...arguments);
+  }
+  typeInto(selector) {
+    return this.send("typeInto", ...arguments);
+  }
+  page() {
+    return this.send("page");
+  }
+  click(selector) {
+    return this.send("click", ...arguments);
+  }
+  screencast(opts, page) {
+    return this.send(
+      "screencast",
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path
+      },
+      page,
+      this.testResourceConfiguration.name
+    );
+  }
+  screencastStop(p) {
+    return this.send("screencastStop", ...arguments);
+  }
+  customScreenShot(x, y) {
+    const opts = x[0];
+    const page = x[1];
+    return this.send(
+      "customScreenShot",
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path
+      },
+      this.testResourceConfiguration.name,
+      page
+    );
+  }
+  async existsSync(destFolder) {
+    return await this.send(
+      "existsSync",
+      this.testResourceConfiguration.fs + "/" + destFolder
+    );
+  }
+  mkdirSync() {
+    return this.send("mkdirSync", this.testResourceConfiguration.fs + "/");
+  }
+  async write(uid, contents) {
+    return await this.send("write", ...arguments);
+  }
+  async writeFileSync(filepath, contents) {
+    return await this.send(
+      "writeFileSync",
+      this.testResourceConfiguration.fs + "/" + filepath,
+      contents,
+      this.testResourceConfiguration.name
+    );
+  }
+  async createWriteStream(filepath) {
+    return await this.send(
+      "createWriteStream",
+      this.testResourceConfiguration.fs + "/" + filepath,
+      this.testResourceConfiguration.name
+    );
+  }
+  async end(uid) {
+    return await this.send("end", ...arguments);
+  }
+  async customclose() {
+    return await this.send(
+      "customclose",
+      this.testResourceConfiguration.fs,
+      this.testResourceConfiguration.name
+    );
+  }
+  testArtiFactoryfileWriter(tLog, callback) {
+    return (fPath, value) => {
+      callback(
+        new Promise((res, rej) => {
+          tLog("testArtiFactory =>", fPath);
+          const cleanPath = path.resolve(fPath);
+          fPaths.push(cleanPath.replace(process.cwd(), ``));
+          const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+          fs.mkdir(targetDir, { recursive: true }, async (error) => {
+            if (error) {
+              console.error(`\u2757\uFE0FtestArtiFactory failed`, targetDir, error);
+            }
+            fs.writeFileSync(
+              path.resolve(
+                targetDir.split("/").slice(0, -1).join("/"),
+                "manifest"
+              ),
+              fPaths.join(`
+`),
+              {
+                encoding: "utf-8"
+              }
+            );
+            if (Buffer.isBuffer(value)) {
+              fs.writeFileSync(fPath, value, "binary");
+              res();
+            } else if (`string` === typeof value) {
+              fs.writeFileSync(fPath, value.toString(), {
+                encoding: "utf-8"
+              });
+              res();
+            } else {
+              const pipeStream = value;
+              const myFile = fs.createWriteStream(fPath);
+              pipeStream.pipe(myFile);
+              pipeStream.on("close", () => {
+                myFile.close();
+                res();
+              });
+            }
+          });
+        })
+      );
+    };
+  }
+  // launch(options?: PuppeteerLaunchOptions): Promise<Browser>;
+  startPuppeteer(options) {
+  }
+};
+
+// src/Node.ts
+var ipcfile;
+var NodeTesteranto = class extends Testeranto {
+  constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface2) {
+    super(
+      input,
+      testSpecification,
+      testImplementation,
+      testResourceRequirement,
+      testInterface2,
+      () => {
+      }
+    );
+  }
+  async receiveTestResourceConfig(partialTestResource) {
+    const t = JSON.parse(partialTestResource);
+    const pm = new PM_Node(t, ipcfile);
+    return await this.testJobs[0].receiveTestResourceConfig(pm);
+  }
+};
+var testeranto = async (input, testSpecification, testImplementation, testInterface2, testResourceRequirement = defaultTestResourceRequirement) => {
+  const t = new NodeTesteranto(
+    input,
+    testSpecification,
+    testImplementation,
+    testResourceRequirement,
+    testInterface2
+  );
+  process.on("unhandledRejection", (reason, promise) => {
+    console.error("Unhandled Rejection at:", promise, "reason:", reason);
+  });
+  try {
+    ipcfile = process.argv[3];
+    const f = await t.receiveTestResourceConfig(process.argv[2]);
+    console.error("goodbye node error", f.fails);
+    process.exit(f.fails);
+  } catch (e) {
+    console.error("goodbye node error", e);
+    process.exit(-1);
+  }
+  return t;
+};
+var Node_default = testeranto;
+
+// src/PM/__tests__/sidecar.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;
+      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 sidecar_testeranto_default = Node_default(
+  () => new PM_Node_Sidecar({}),
+  specification,
+  implementation,
+  testInterface
+);
+export {
+  sidecar_testeranto_default as default
+};