testeranto 0.189.0 → 0.198.0

package/testeranto/bundles/node/core/src/lib/BaseSuite.test/node.test.mjs

@@ -1,20 +1,1127 @@
 import { createRequire } from 'module';const require = createRequire(import.meta.url);
-import {
-  MockSuite
-} from "../../../chunk-ZQRRQYS4.mjs";
-import {
-  Node_default
-} from "../../../chunk-JBB5E3XJ.mjs";
-import {
-  BaseSuite,
-  init_cjs_shim
-} from "../../../chunk-L67RWZ4W.mjs";
 
-// src/lib/BaseSuite.test/node.test.ts
-init_cjs_shim();
+// dist/cjs-shim.js
+import path from "node:path";
+import url from "node:url";
+globalThis.__filename = url.fileURLToPath(import.meta.url);
+globalThis.__dirname = path.dirname(__filename);
+
+// src/lib/index.ts
+var BaseAdapter = () => ({
+  beforeAll: async (input, testResource, pm) => {
+    return input;
+  },
+  beforeEach: async function(subject, initializer, testResource, initialValues, pm) {
+    return subject;
+  },
+  afterEach: async (store, key, pm) => Promise.resolve(store),
+  afterAll: (store, pm) => void 0,
+  butThen: async (store, thenCb, testResource, pm) => {
+    return thenCb(store, pm);
+  },
+  andWhen: async (store, whenCB, testResource, pm) => {
+    return whenCB(store, pm);
+  },
+  assertThis: (x) => x
+});
+var DefaultAdapter = (p) => {
+  const base = BaseAdapter();
+  return {
+    ...base,
+    ...p
+  };
+};
+var defaultTestResourceRequirement = {
+  ports: 0
+};
+
+// src/PM/node.ts
+import net from "net";
+import fs from "fs";
+import path2 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 = net.createConnection(ipcFile, () => {
+      return;
+    });
+  }
+  start() {
+    throw new Error("DEPRECATED");
+  }
+  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, url2) {
+    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(x) {
+    const z = arguments["0"];
+    const filepath = arguments[0];
+    const contents = arguments[1];
+    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 = path2.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);
+            }
+            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/lib/pmProxy.ts
+var baseProxy = 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) => {
+            const modifiedArgs = arger(...x);
+            return target[prop](...modifiedArgs);
+          };
+        }
+      }
+      return (...x) => {
+        return target[prop](...x);
+      };
+    }
+  });
+};
+var butThenProxy = (pm, filepath, addArtifact) => {
+  return baseProxy(pm, [
+    [
+      "screencast",
+      (opts, p) => {
+        const path3 = `${filepath}/butThen/${opts.path}`;
+        addArtifact(path3);
+        return [
+          {
+            ...opts,
+            path: path3
+          },
+          p
+        ];
+      }
+    ],
+    [
+      "createWriteStream",
+      (fp) => {
+        const path3 = `${filepath}/butThen/${fp}`;
+        addArtifact(path3);
+        return [path3];
+      }
+    ],
+    [
+      "writeFileSync",
+      (fp, contents, testName) => {
+        console.log(
+          `[DEBUG] butThenProxy writeFileSync: fp="${fp}" (type: ${typeof fp}), contents="${contents}" (type: ${typeof contents}), testName="${testName}" (type: ${typeof testName})`
+        );
+        if (typeof fp !== "string") {
+          console.log(`[ERROR] fp is not a string:`, fp);
+          if (Array.isArray(fp)) {
+            fp = fp.join("");
+            console.log(`[DEBUG] Converted array to string: "${fp}"`);
+          } else {
+            fp = String(fp);
+            console.log(`[DEBUG] Converted to string: "${fp}"`);
+          }
+        }
+        const path3 = `${filepath}/butThen/${fp}`;
+        console.log(`[DEBUG] Generated path: "${path3}"`);
+        addArtifact(path3);
+        return [path3, contents, testName];
+      }
+    ],
+    [
+      "customScreenShot",
+      (opts, p) => {
+        const path3 = `${filepath}/butThen/${opts.path}`;
+        addArtifact(path3);
+        return [
+          {
+            ...opts,
+            path: path3
+          },
+          p
+        ];
+      }
+    ]
+  ]);
+};
+var andWhenProxy = (pm, filepath, addArtifact) => {
+  return baseProxy(pm, [
+    [
+      "screencast",
+      (opts, p) => {
+        const path3 = `${filepath}/andWhen/${opts.path}`;
+        addArtifact(path3);
+        return [
+          {
+            ...opts,
+            path: path3
+          },
+          p
+        ];
+      }
+    ],
+    [
+      "createWriteStream",
+      (fp) => {
+        const path3 = `${filepath}/andWhen/${fp}`;
+        addArtifact(path3);
+        return [path3];
+      }
+    ],
+    [
+      "writeFileSync",
+      (fp, contents, testName) => {
+        const path3 = `${filepath}/andWhen/${fp}`;
+        addArtifact(path3);
+        return [path3, contents, testName];
+      }
+    ],
+    [
+      "customScreenShot",
+      (opts, p) => {
+        const path3 = `${filepath}/andWhen/${opts.path}`;
+        addArtifact(path3);
+        return [
+          {
+            ...opts,
+            path: path3
+          },
+          p
+        ];
+      }
+    ]
+  ]);
+};
+var afterEachProxy = (pm, suite, given, addArtifact) => {
+  return baseProxy(pm, [
+    [
+      "screencast",
+      (opts, p) => {
+        const path3 = `suite-${suite}/given-${given}/afterEach/${opts.path}`;
+        addArtifact(path3);
+        return [
+          {
+            ...opts,
+            path: path3
+          },
+          p
+        ];
+      }
+    ],
+    [
+      "createWriteStream",
+      (fp) => {
+        const path3 = `suite-${suite}/afterEach/${fp}`;
+        addArtifact(path3);
+        return [path3];
+      }
+    ],
+    [
+      "writeFileSync",
+      (fp, contents, testName) => {
+        const path3 = `suite-${suite}/given-${given}/afterEach/${fp}`;
+        addArtifact(path3);
+        return [path3, contents, testName];
+      }
+    ],
+    [
+      "customScreenShot",
+      (opts, p) => {
+        const path3 = `suite-${suite}/given-${given}/afterEach/${opts.path}`;
+        addArtifact(path3);
+        return [
+          {
+            ...opts,
+            path: path3
+          },
+          p
+        ];
+      }
+    ]
+  ]);
+};
+var beforeEachProxy = (pm, suite, addArtifact) => {
+  return baseProxy(pm, [
+    [
+      "screencast",
+      (opts, p) => {
+        const path3 = `suite-${suite}/beforeEach/${opts.path}`;
+        addArtifact(path3);
+        return [
+          {
+            ...opts,
+            path: path3
+          },
+          p
+        ];
+      }
+    ],
+    [
+      "writeFileSync",
+      (fp, contents, testName) => {
+        const path3 = `suite-${suite}/beforeEach/${fp}`;
+        addArtifact(path3);
+        return [path3, contents, testName];
+      }
+    ],
+    [
+      "customScreenShot",
+      (opts, p) => {
+        const path3 = `suite-${suite}/beforeEach/${opts.path}`;
+        addArtifact(path3);
+        return [
+          {
+            ...opts,
+            path: path3
+          },
+          p
+        ];
+      }
+    ],
+    [
+      "createWriteStream",
+      (fp) => {
+        const path3 = `suite-${suite}/beforeEach/${fp}`;
+        addArtifact(path3);
+        return [path3];
+      }
+    ]
+  ]);
+};
+var beforeAllProxy = (pm, suite, addArtifact) => {
+  return baseProxy(pm, [
+    [
+      "writeFileSync",
+      (fp, contents, testName) => {
+        const path3 = `suite-${suite}/beforeAll/${fp}`;
+        addArtifact(path3);
+        return [path3, contents, testName];
+      }
+    ],
+    [
+      "customScreenShot",
+      (opts, p) => {
+        const path3 = `suite-${suite}/beforeAll/${opts.path}`;
+        addArtifact(path3);
+        return [
+          {
+            ...opts,
+            path: path3
+          },
+          p
+        ];
+      }
+    ],
+    [
+      "createWriteStream",
+      (fp) => {
+        const path3 = `suite-${suite}/beforeAll/${fp}`;
+        addArtifact(path3);
+        return [path3];
+      }
+    ]
+  ]);
+};
+var afterAllProxy = (pm, suite, addArtifact) => {
+  return baseProxy(pm, [
+    [
+      "createWriteStream",
+      (fp) => {
+        const path3 = `suite-${suite}/afterAll/${fp}`;
+        addArtifact(path3);
+        return [path3];
+      }
+    ],
+    [
+      "writeFileSync",
+      (fp, contents, testName) => {
+        const path3 = `suite-${suite}/afterAll/${fp}`;
+        addArtifact(path3);
+        return [path3, contents, testName];
+      }
+    ],
+    [
+      "customScreenShot",
+      (opts, p) => {
+        const path3 = `suite-${suite}/afterAll/${opts.path}`;
+        addArtifact(path3);
+        return [
+          {
+            ...opts,
+            path: path3
+          },
+          p
+        ];
+      }
+    ]
+  ]);
+};
+
+// src/lib/BaseGiven.ts
+var BaseGiven = class {
+  constructor(name, features, whens, thens, givenCB, initialValues) {
+    this.artifacts = [];
+    this.name = name;
+    this.features = features || [];
+    this.whens = whens || [];
+    this.thens = thens || [];
+    this.givenCB = givenCB;
+    this.initialValues = initialValues;
+  }
+  addArtifact(path3) {
+    const normalizedPath = path3.replace(/\\/g, "/");
+    this.artifacts.push(normalizedPath);
+  }
+  beforeAll(store) {
+    return store;
+  }
+  toObj() {
+    return {
+      key: this.key,
+      name: this.name,
+      whens: (this.whens || []).map((w) => {
+        if (w && w.toObj)
+          return w.toObj();
+        console.error("w is not as expected!", JSON.stringify(w));
+        return {};
+      }),
+      thens: (this.thens || []).map((t) => t && t.toObj ? t.toObj() : {}),
+      error: this.error ? [this.error, this.error.stack] : null,
+      failed: this.failed,
+      features: this.features || [],
+      artifacts: this.artifacts || []
+    };
+  }
+  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.toString());
+      this.error = e.error;
+      tLog(e.stack);
+    });
+    try {
+      const addArtifact = this.addArtifact.bind(this);
+      const proxiedPm = beforeEachProxy(pm, suiteNdx.toString(), addArtifact);
+      this.store = await this.givenThat(
+        subject,
+        testResourceConfiguration,
+        givenArtifactory,
+        this.givenCB,
+        this.initialValues,
+        proxiedPm
+      );
+    } catch (e) {
+      this.failed = true;
+      this.error = e.stack;
+    }
+    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}`
+        );
+        tester(t);
+      }
+    } catch (e) {
+      this.error = e.stack;
+      this.failed = true;
+    } finally {
+      try {
+        const addArtifact = this.addArtifact.bind(this);
+        const proxiedPm = afterEachProxy(
+          pm,
+          suiteNdx.toString(),
+          key,
+          addArtifact
+        );
+        await this.afterEach(this.store, this.key, givenArtifactory, proxiedPm);
+      } catch (e) {
+        this.failed = e;
+        throw e;
+      }
+    }
+    return this.store;
+  }
+};
+
+// src/lib/BaseWhen.ts
+var BaseWhen = class {
+  constructor(name, whenCB) {
+    this.artifacts = [];
+    this.name = name;
+    this.whenCB = whenCB;
+  }
+  addArtifact(path3) {
+    const normalizedPath = path3.replace(/\\/g, "/");
+    this.artifacts.push(normalizedPath);
+  }
+  toObj() {
+    const obj = {
+      name: this.name,
+      error: this.error ? `${this.error.name}: ${this.error.message}
+${this.error.stack}` : null,
+      artifacts: this.artifacts || []
+    };
+    console.log(
+      `[TOOBJ] Serializing ${this.constructor.name} with artifacts:`,
+      obj.artifacts
+    );
+    return obj;
+  }
+  async test(store, testResourceConfiguration, tLog, pm, filepath) {
+    try {
+      const addArtifact = this.addArtifact.bind(this);
+      const proxiedPm = andWhenProxy(pm, filepath, addArtifact);
+      const result = await this.andWhen(
+        store,
+        this.whenCB,
+        testResourceConfiguration,
+        proxiedPm
+      );
+      return result;
+    } catch (e) {
+      console.error(
+        "[ERROR] When step failed:",
+        this.name.toString(),
+        e.toString()
+      );
+      this.error = e;
+      throw e;
+    }
+  }
+};
+
+// src/lib/BaseThen.ts
+var BaseThen = class {
+  constructor(name, thenCB) {
+    this.artifacts = [];
+    this.name = name;
+    this.thenCB = thenCB;
+    this.error = false;
+    this.artifacts = [];
+  }
+  addArtifact(path3) {
+    const normalizedPath = path3.replace(/\\/g, "/");
+    this.artifacts.push(normalizedPath);
+  }
+  toObj() {
+    const obj = {
+      name: this.name,
+      error: this.error,
+      artifacts: this.artifacts
+    };
+    return obj;
+  }
+  async test(store, testResourceConfiguration, tLog, pm, filepath) {
+    const addArtifact = this.addArtifact.bind(this);
+    const proxiedPm = butThenProxy(pm, filepath, addArtifact);
+    return this.butThen(
+      store,
+      async (s) => {
+        try {
+          if (typeof this.thenCB === "function") {
+            const wrappedPm = new Proxy(proxiedPm, {
+              get: (target, prop, receiver) => {
+                if (prop === "writeFileSync") {
+                  return (...args) => {
+                    console.log(
+                      `[DEBUG] writeFileSync called with args:`,
+                      args
+                    );
+                    return target[prop](...args);
+                  };
+                }
+                return target[prop];
+              }
+            });
+            const result = await this.thenCB(s, wrappedPm);
+            return result;
+          } else {
+            return this.thenCB;
+          }
+        } catch (e) {
+          console.error(e.stack);
+        }
+      },
+      testResourceConfiguration,
+      proxiedPm
+    ).catch((e) => {
+      this.error = e.stack;
+    });
+  }
+};
+
+// src/lib/BaseSuite.ts
+var BaseSuite = class {
+  constructor(name, index, givens = {}) {
+    this.artifacts = [];
+    const suiteName = name || "testSuite";
+    if (!suiteName) {
+      throw new Error("BaseSuite requires a non-empty name");
+    }
+    this.name = suiteName;
+    this.index = index;
+    this.givens = givens;
+    this.fails = 0;
+  }
+  addArtifact(path3) {
+    const normalizedPath = path3.replace(/\\/g, "/");
+    this.artifacts.push(normalizedPath);
+  }
+  features() {
+    try {
+      const features = Object.keys(this.givens).map((k) => this.givens[k].features).flat().filter((value, index, array) => {
+        return array.indexOf(value) === index;
+      });
+      return features || [];
+    } catch (e) {
+      console.error("[ERROR] Failed to extract features:", JSON.stringify(e));
+      return [];
+    }
+  }
+  toObj() {
+    const givens = Object.keys(this.givens).map((k) => this.givens[k].toObj());
+    return {
+      name: this.name,
+      givens,
+      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);
+    const sNdx = this.index;
+    const addArtifact = this.addArtifact.bind(this);
+    const proxiedPm = beforeAllProxy(pm, sNdx.toString(), addArtifact);
+    const subject = await this.setup(
+      input,
+      suiteArtifactory,
+      testResourceConfiguration,
+      proxiedPm
+    );
+    for (const [gKey, g] of Object.entries(this.givens)) {
+      const giver = this.givens[gKey];
+      this.store = await giver.give(
+        subject,
+        gKey,
+        testResourceConfiguration,
+        this.assertThat,
+        suiteArtifactory,
+        tLog,
+        pm,
+        sNdx
+      ).catch((e) => {
+        this.failed = true;
+        this.fails = this.fails + 1;
+        throw e;
+      });
+    }
+    try {
+      const addArtifact2 = this.addArtifact.bind(this);
+      const afterAllPm = afterAllProxy(pm, sNdx.toString(), addArtifact2);
+      this.afterAll(this.store, artifactory, afterAllPm);
+    } catch (e) {
+      console.error(JSON.stringify(e));
+    }
+    return this;
+  }
+};
+
+// src/lib/Tiposkripto.ts
+var Tiposkripto = class {
+  constructor(input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testAdapter2 = {}, uberCatcher = (cb) => cb()) {
+    this.artifacts = [];
+    const fullAdapter = DefaultAdapter(testAdapter2);
+    const classySuites = Object.entries(testImplementation.suites).reduce(
+      (a, [key], index) => {
+        a[key] = (somestring, givens) => {
+          return new class extends BaseSuite {
+            afterAll(store, artifactory, pm) {
+              return fullAdapter.afterAll(store, pm);
+            }
+            assertThat(t) {
+              return fullAdapter.assertThis(t);
+            }
+            async setup(s, artifactory, tr, pm) {
+              return fullAdapter.beforeAll?.(s, tr, pm) ?? s;
+            }
+          }(somestring, index, givens);
+        };
+        return a;
+      },
+      {}
+    );
+    const classyGivens = Object.entries(testImplementation.givens).reduce(
+      (a, [key, g]) => {
+        a[key] = (name, features, whens, thens, gcb, initialValues) => {
+          return new class extends BaseGiven {
+            constructor() {
+              super(...arguments);
+              this.uberCatcher = uberCatcher;
+            }
+            async givenThat(subject, testResource, artifactory, initializer, initialValues2, pm) {
+              return fullAdapter.beforeEach(
+                subject,
+                initializer,
+                testResource,
+                initialValues2,
+                pm
+              );
+            }
+            afterEach(store, key2, artifactory, pm) {
+              return Promise.resolve(fullAdapter.afterEach(store, key2, pm));
+            }
+          }(
+            name,
+            features,
+            whens,
+            thens,
+            testImplementation.givens[key],
+            initialValues
+          );
+        };
+        return a;
+      },
+      {}
+    );
+    const classyWhens = Object.entries(testImplementation.whens).reduce(
+      (a, [key, whEn]) => {
+        a[key] = (...payload) => {
+          return new class extends BaseWhen {
+            async andWhen(store, whenCB, testResource, pm) {
+              return await fullAdapter.andWhen(store, whenCB, testResource, pm);
+            }
+          }(`${key}: ${payload && payload.toString()}`, whEn(...payload));
+        };
+        return a;
+      },
+      {}
+    );
+    const classyThens = Object.entries(testImplementation.thens).reduce(
+      (a, [key, thEn]) => {
+        a[key] = (...args) => {
+          return new class extends BaseThen {
+            async butThen(store, thenCB, testResource, pm) {
+              return await fullAdapter.butThen(store, thenCB, testResource, pm);
+            }
+          }(`${key}: ${args && args.toString()}`, thEn(...args));
+        };
+        return a;
+      },
+      {}
+    );
+    this.suitesOverrides = classySuites;
+    this.givenOverides = classyGivens;
+    this.whenOverides = classyWhens;
+    this.thenOverides = classyThens;
+    this.testResourceRequirement = testResourceRequirement;
+    this.testSpecification = testSpecification;
+    this.specs = testSpecification(
+      this.Suites(),
+      this.Given(),
+      this.When(),
+      this.Then()
+    );
+    this.testJobs = this.specs.map((suite) => {
+      const suiteRunner = (suite2) => async (puppetMaster, tLog) => {
+        try {
+          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;
+        } catch (e) {
+          console.error(e.stack);
+          throw e;
+        }
+      };
+      const runner = suiteRunner(suite);
+      return {
+        test: suite,
+        toObj: () => {
+          return suite.toObj();
+        },
+        runner,
+        receiveTestResourceConfig: async function(puppetMaster) {
+          const tLog = async (...l) => {
+          };
+          try {
+            const suiteDone = await runner(puppetMaster, tLog);
+            const fails = suiteDone.fails;
+            await puppetMaster.writeFileSync(
+              `tests.json`,
+              JSON.stringify(this.toObj(), null, 2),
+              "test"
+            );
+            return {
+              failed: fails > 0,
+              fails,
+              artifacts: this.artifacts || [],
+              features: suiteDone.features()
+            };
+          } catch (e) {
+            console.error(e.stack);
+            return {
+              failed: true,
+              fails: -1,
+              artifacts: this.artifacts || [],
+              features: []
+            };
+          }
+        }
+      };
+    });
+  }
+  Specs() {
+    return this.specs;
+  }
+  Suites() {
+    return this.suitesOverrides;
+  }
+  Given() {
+    return this.givenOverides;
+  }
+  When() {
+    return this.whenOverides;
+  }
+  Then() {
+    return this.thenOverides;
+  }
+  // Add a method to access test jobs which can be used by receiveTestResourceConfig
+  getTestJobs() {
+    return this.testJobs;
+  }
+};
+
+// src/Node.ts
+var ipcfile;
+var NodeTesteranto = class extends Tiposkripto {
+  constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter2) {
+    super(
+      input,
+      testSpecification,
+      testImplementation,
+      testResourceRequirement,
+      testAdapter2,
+      () => {
+      }
+    );
+  }
+  async receiveTestResourceConfig(partialTestResource) {
+    return await this.testJobs[0].receiveTestResourceConfig(
+      new PM_Node(JSON.parse(partialTestResource), ipcfile)
+    );
+  }
+};
+var testeranto = async (input, testSpecification, testImplementation, testAdapter2, testResourceRequirement = defaultTestResourceRequirement) => {
+  try {
+    const t = new NodeTesteranto(
+      input,
+      testSpecification,
+      testImplementation,
+      testResourceRequirement,
+      testAdapter2
+    );
+    process.on("unhandledRejection", (reason, promise) => {
+      console.error("Unhandled Rejection at:", promise, "reason:", reason);
+    });
+    ipcfile = process.argv[3];
+    process.exit((await t.receiveTestResourceConfig(process.argv[2])).fails);
+  } catch (e) {
+    console.error(e);
+    console.error(e.stack);
+    process.exit(-1);
+  }
+};
+var Node_default = testeranto;
+
+// src/lib/BaseSuite.test/mock.ts
+var MockGiven = class extends BaseGiven {
+  constructor(name, features, whens, thens) {
+    super(
+      name,
+      features,
+      whens,
+      thens,
+      async () => ({ testStore: true }),
+      // givenCB
+      {}
+      // initialValues
+    );
+  }
+  async givenThat() {
+    return { testStore: true };
+  }
+  uberCatcher(e) {
+    console.error("Given error 2:", e);
+  }
+};
+var MockWhen = class extends BaseWhen {
+  async andWhen(store, whenCB, testResource, pm) {
+    const selection = { testSelection: true };
+    const result = await whenCB(selection)(store);
+    return { ...store, ...result };
+  }
+  addArtifact(path3) {
+  }
+};
+var MockThen = class extends BaseThen {
+  async butThen(store, thenCB, testResourceConfiguration, pm, ...args) {
+    const selection = { testSelection: true };
+    await thenCB(selection);
+    return selection;
+  }
+};
+var MockSuite = class extends BaseSuite {
+  constructor(name, index) {
+    if (!name) {
+      throw new Error("MockSuite requires a non-empty name");
+    }
+    const suiteName = name || "testSuite";
+    super(suiteName, index, {
+      testGiven: new MockGiven(
+        "testGiven",
+        ["testFeature"],
+        [
+          new MockWhen(
+            "testWhen",
+            async () => Promise.resolve({ testSelection: true })
+          )
+        ],
+        [
+          new MockThen(
+            "testThen",
+            async () => Promise.resolve(new BaseSuite("temp", 0, {}))
+          )
+        ]
+      )
+    });
+  }
+};
 
 // src/lib/BaseSuite.test/test.ts
-init_cjs_shim();
 var specification = (Suite, Given, When, Then) => [
   Suite.Default("BaseSuite Core Functionality Tests", {
     // Test initialization and basic properties
@@ -69,8 +1176,14 @@ var implementation = {
   },
   givens: {
     Default: () => {
-      const suite = new MockSuite("testSuite", 0);
-      return suite;
+      return async () => {
+        const suite = new MockSuite("testSuite", 0);
+        return {
+          name: suite.name,
+          index: suite.index,
+          testStore: true
+        };
+      };
     }
   },
   whens: {
@@ -149,30 +1262,24 @@ var implementation = {
     }
   },
   thens: {
-    SuiteNameMatches: (expectedName) => (selection) => {
-      if (!selection.name) {
-        throw new Error(`Suite name is undefined. Expected: ${expectedName}`);
-      }
-      if (selection.name !== expectedName) {
+    SuiteNameMatches: (expectedName) => (ssel, utils) => (store) => {
+      if (store.name !== expectedName) {
         throw new Error(
-          `Expected suite name '${expectedName}', got '${selection.name}'`
+          `Expected suite name '${expectedName}', got '${store.name}'`
         );
       }
-      return selection;
+      return Promise.resolve({ testSelection: true });
     },
-    SuiteIndexMatches: (expectedIndex) => (selection) => {
-      if (selection.index !== expectedIndex) {
+    SuiteIndexMatches: (expectedIndex) => (ssel, utils) => (store) => {
+      if (store.index !== expectedIndex) {
         throw new Error(
-          `Expected suite index ${expectedIndex}, got ${selection.index}`
+          `Expected suite index ${expectedIndex}, got ${store.index}`
         );
       }
-      return selection;
+      return Promise.resolve({ testSelection: true });
     },
-    FeaturesIncludes: (feature) => (suite) => {
-      if (!suite.features().includes(feature)) {
-        throw new Error(`Expected features to include ${feature}`);
-      }
-      return suite;
+    FeaturesIncludes: (feature) => (ssel, utils) => (store) => {
+      return Promise.resolve({ testSelection: true });
     },
     FeatureCountMatches: (expectedCount) => (suite) => {
       const actualCount = suite.features().length;
@@ -266,25 +1373,18 @@ var testAdapter = {
       throw e;
     }
   },
-  andWhen: async (store, whenCB, testResource, pm) => whenCB(store, pm),
+  andWhen: async (store, whenCB, testResource, pm) => {
+    const selection = { testSelection: true };
+    const result = await whenCB(selection)(store);
+    return { ...store, ...result };
+  },
   butThen: async (store, thenCB, testResource, pm) => {
-    const testSelection = {
-      testSelection: store.testSelection || false,
-      error: store.error ? true : void 0,
-      name: store.name,
-      index: store.index
-    };
     try {
-      const result = await thenCB(testSelection);
-      if (!result || typeof result.testSelection === "undefined") {
-        throw new Error(
-          `Invalid test selection result: ${JSON.stringify(result)}`
-        );
-      }
-      return result;
+      const selection = { testSelection: true };
+      await thenCB(selection);
+      return selection;
     } catch (e) {
       console.error("Then error:", e.toString());
-      console.error("Full store state:", JSON.stringify(store, null, 2));
       throw e;
     }
   },