testeranto 0.171.0 → 0.173.0

package/testeranto/bundles/{web/allTests/chunk-U7AW26HL.mjs → pure/core/src/lib/baseBuilder.test/baseBuilder.test.pure.mjs}

@@ -1,378 +1,6 @@
-import {
-  init_buffer,
-  init_dirname,
-  init_process
-} from "./chunk-HPYA4YZC.mjs";
-
-// src/lib/BaseSuite.ts
-init_dirname();
-init_buffer();
-init_process();
-
-// src/lib/pmProxy.ts
-init_dirname();
-init_buffer();
-init_process();
-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) => target[prop](arger(...x));
-        }
-      }
-      return (...x) => target[prop](...x);
-    }
-  });
-};
-var butThenProxy = (pm, filepath) => {
-  return baseProxy(pm, [
-    [
-      "screencast",
-      (opts2, p) => {
-        const path = `${filepath}/butThen/${opts2.path}`;
-        console.log(`[Proxy] Captured artifact path for butThen:`, path);
-        if (pm.currentStep?.addArtifact) {
-          pm.currentStep.addArtifact(path);
-        } else {
-          console.warn("No currentStep or addArtifact method found");
-        }
-        return [
-          {
-            ...opts2,
-            path
-          },
-          p
-        ];
-      }
-    ],
-    ["createWriteStream", (fp) => {
-      const path = `${filepath}/butThen/${fp}`;
-      console.log(`[Proxy] Captured artifact path for butThen:`, path);
-      if (pm.currentStep?.addArtifact) {
-        pm.currentStep.addArtifact(path);
-      } else {
-        console.warn("No currentStep or addArtifact method found");
-      }
-      return [path];
-    }],
-    [
-      "writeFileSync",
-      (fp, contents) => {
-        const path = `${filepath}/butThen/${fp}`;
-        pm.currentStep?.artifacts?.push(path);
-        return [path, contents];
-      }
-    ],
-    [
-      "customScreenShot",
-      (opts2, p) => {
-        const path = `${filepath}/butThen/${opts2.path}`;
-        pm.currentStep?.artifacts?.push(path);
-        return [
-          {
-            ...opts2,
-            path
-          },
-          p
-        ];
-      }
-    ]
-  ]);
-};
-var andWhenProxy = (pm, filepath) => baseProxy(pm, [
-  [
-    "screencast",
-    (opts2, p) => {
-      const path = `${filepath}/andWhen/${opts2.path}`;
-      pm.currentStep?.artifacts?.push(path);
-      return [
-        {
-          ...opts2,
-          path
-        },
-        p
-      ];
-    }
-  ],
-  ["createWriteStream", (fp) => {
-    const path = `${filepath}/andWhen/${fp}`;
-    pm.currentStep?.artifacts?.push(path);
-    return [path];
-  }],
-  ["writeFileSync", (fp, contents) => {
-    const path = `${filepath}/andWhen/${fp}`;
-    pm.currentStep?.artifacts?.push(path);
-    return [path, contents];
-  }],
-  [
-    "customScreenShot",
-    (opts2, p) => {
-      const path = `${filepath}/andWhen/${opts2.path}`;
-      pm.currentStep?.artifacts?.push(path);
-      return [
-        {
-          ...opts2,
-          path
-        },
-        p
-      ];
-    }
-  ]
-]);
-var afterEachProxy = (pm, suite, given) => baseProxy(pm, [
-  [
-    "screencast",
-    (opts2, p) => {
-      const path = `suite-${suite}/given-${given}/afterEach/${opts2.path}`;
-      pm.currentStep?.artifacts?.push(path);
-      return [
-        {
-          ...opts2,
-          path
-        },
-        p
-      ];
-    }
-  ],
-  ["createWriteStream", (fp) => {
-    const path = `suite-${suite}/afterEach/${fp}`;
-    pm.currentStep?.artifacts?.push(path);
-    return [path];
-  }],
-  [
-    "writeFileSync",
-    (fp, contents) => {
-      const path = `suite-${suite}/given-${given}/afterEach/${fp}`;
-      pm.currentStep?.artifacts?.push(path);
-      return [path, contents];
-    }
-  ],
-  [
-    "customScreenShot",
-    (opts2, p) => {
-      const path = `suite-${suite}/given-${given}/afterEach/${opts2.path}`;
-      pm.currentStep?.artifacts?.push(path);
-      return [
-        {
-          ...opts2,
-          path
-        },
-        p
-      ];
-    }
-  ]
-]);
-var beforeEachProxy = (pm, suite) => baseProxy(pm, [
-  [
-    "screencast",
-    (opts2, p) => {
-      const path = `suite-${suite}/beforeEach/${opts2.path}`;
-      pm.currentStep?.artifacts?.push(path);
-      return [
-        {
-          ...opts2,
-          path
-        },
-        p
-      ];
-    }
-  ],
-  [
-    "writeFileSync",
-    (fp, contents) => {
-      const path = `suite-${suite}/beforeEach/${fp}`;
-      pm.currentStep?.artifacts?.push(path);
-      return [path, contents];
-    }
-  ],
-  [
-    "customScreenShot",
-    (opts2, p) => {
-      const path = `suite-${suite}/beforeEach/${opts2.path}`;
-      pm.currentStep?.artifacts?.push(path);
-      return [
-        {
-          ...opts2,
-          path
-        },
-        p
-      ];
-    }
-  ],
-  ["createWriteStream", (fp) => {
-    const path = `suite-${suite}/beforeEach/${fp}`;
-    pm.currentStep?.artifacts?.push(path);
-    return [path];
-  }]
-]);
-var beforeAllProxy = (pm, suite) => baseProxy(pm, [
-  [
-    "writeFileSync",
-    (fp, contents) => {
-      const path = `suite-${suite}/beforeAll/${fp}`;
-      pm.currentStep?.artifacts?.push(path);
-      return [path, contents];
-    }
-  ],
-  [
-    "customScreenShot",
-    (opts2, p) => {
-      const path = `suite-${suite}/beforeAll/${opts2.path}`;
-      pm.currentStep?.artifacts?.push(path);
-      return [
-        {
-          ...opts2,
-          path
-        },
-        p
-      ];
-    }
-  ],
-  ["createWriteStream", (fp) => {
-    const path = `suite-${suite}/beforeAll/${fp}`;
-    pm.currentStep?.artifacts?.push(path);
-    return [path];
-  }]
-]);
-var afterAllProxy = (pm, suite) => baseProxy(pm, [
-  ["createWriteStream", (fp) => {
-    const path = `suite-${suite}/afterAll/${fp}`;
-    pm.currentStep?.artifacts?.push(path);
-    return [path];
-  }],
-  [
-    "writeFileSync",
-    (fp, contents) => {
-      const path = `suite-${suite}/afterAll/${fp}`;
-      pm.currentStep?.artifacts?.push(path);
-      return [path, contents];
-    }
-  ],
-  [
-    "customScreenShot",
-    (opts2, p) => {
-      const path = `suite-${suite}/afterAll/${opts2.path}`;
-      pm.currentStep?.artifacts?.push(path);
-      return [
-        {
-          ...opts2,
-          path
-        },
-        p
-      ];
-    }
-  ]
-]);
-
-// src/lib/BaseSuite.ts
-var BaseSuite = class {
-  constructor(name, index, givens = {}) {
-    const suiteName = name || "testSuite";
-    if (!suiteName) {
-      throw new Error("BaseSuite requires a non-empty name");
-    }
-    console.log(
-      "[DEBUG] BaseSuite constructor - name:",
-      suiteName,
-      "index:",
-      index
-    );
-    this.name = suiteName;
-    this.index = index;
-    this.givens = givens;
-    this.fails = 0;
-    console.log("[DEBUG] BaseSuite initialized:", this.name, this.index);
-    console.log("[DEBUG] BaseSuite givens:", Object.keys(givens).toString());
-  }
-  features() {
-    try {
-      const features = Object.keys(this.givens).map((k) => this.givens[k].features).flat().filter((value, index, array) => {
-        return array.indexOf(value) === index;
-      });
-      console.debug("[DEBUG] Features extracted:", features.toString());
-      return features || [];
-    } catch (e) {
-      console.error("[ERROR] Failed to extract features:", 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);
-    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];
-      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 {
-      this.afterAll(
-        this.store,
-        artifactory,
-        afterAllProxy(pm, sNdx.toString())
-      );
-    } catch (e) {
-      console.error(e);
-    }
-    return this;
-  }
-};
-
-// src/Web.ts
-init_dirname();
-init_buffer();
-init_process();
-
-// src/PM/web.ts
-init_dirname();
-init_buffer();
-init_process();
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
 
 // src/PM/index.ts
-init_dirname();
-init_buffer();
-init_process();
 var PM = class {
 };
 
@@ -452,8 +80,6 @@ var PM_Web = class extends PM {
   customScreenShot(x, y) {
     const opts2 = x[0];
     const page2 = x[1];
-    console.log("customScreenShot 2 opts", opts2);
-    console.log("customScreenShot 2 page", page2);
     return window["customScreenShot"](
       {
         ...opts2,
@@ -472,7 +98,7 @@ var PM_Web = class extends PM {
   write(uid, contents) {
     return window["write"](uid, contents);
   }
-  writeFileSync(filepath, contents) {
+  writeFileSync([filepath, contents]) {
     return window["writeFileSync"](
       this.testResourceConfiguration.fs + "/" + filepath,
       contents,
@@ -505,15 +131,7 @@ var PM_Web = class extends PM {
   }
 };
 
-// src/lib/core.ts
-init_dirname();
-init_buffer();
-init_process();
-
 // src/lib/index.ts
-init_dirname();
-init_buffer();
-init_process();
 var BaseAdapter = () => ({
   beforeAll: async (s) => s,
   beforeEach: async function(subject, initialValues, x, testResource, pm) {
@@ -544,10 +162,186 @@ var defaultTestResourceRequirement = {
   ports: 0
 };
 
+// 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) => target[prop](arger(...x));
+        }
+      }
+      return (...x) => target[prop](...x);
+    }
+  });
+};
+var butThenProxy = (pm, filepath) => {
+  return baseProxy(pm, [
+    [
+      "screencast",
+      (opts2, p) => {
+        const path = `${filepath}/butThen/${opts2.path}`;
+        pm.currentStep?.artifacts?.push(path);
+        return [
+          {
+            ...opts2,
+            path
+          },
+          p
+        ];
+      }
+    ],
+    [
+      "createWriteStream",
+      (fp) => {
+        const path = `${filepath}/butThen/${fp}`;
+        pm.currentStep?.artifacts?.push(path);
+        return [path];
+      }
+    ],
+    [
+      "writeFileSync",
+      (fp, contents) => {
+        const path = `${filepath}/butThen/${fp}`;
+        pm.currentStep?.artifacts?.push(path);
+        return [path, contents];
+      }
+    ],
+    [
+      "customScreenShot",
+      (opts2, p) => {
+        const path = `${filepath}/butThen/${opts2.path}`;
+        pm.currentStep?.artifacts?.push(path);
+        return [
+          {
+            ...opts2,
+            path
+          },
+          p
+        ];
+      }
+    ]
+  ]);
+};
+var andWhenProxy = (pm, filepath) => baseProxy(pm, [
+  [
+    "screencast",
+    (opts2, p) => [
+      {
+        ...opts2,
+        path: `${filepath}/andWhen/${opts2.path}`
+      },
+      p
+    ]
+  ],
+  ["createWriteStream", (fp) => [`${filepath}/andWhen/${fp}`]],
+  ["writeFileSync", (fp, contents) => [`${filepath}/andWhen${fp}`, contents]],
+  [
+    "customScreenShot",
+    (opts2, p) => [
+      {
+        ...opts2,
+        path: `${filepath}/andWhen${opts2.path}`
+      },
+      p
+    ]
+  ]
+]);
+var afterEachProxy = (pm, suite, given) => baseProxy(pm, [
+  [
+    "screencast",
+    (opts2, p) => [
+      {
+        ...opts2,
+        path: `suite-${suite}/given-${given}/afterEach/${opts2.path}`
+      },
+      p
+    ]
+  ],
+  ["createWriteStream", (fp) => [`suite-${suite}/afterEach/${fp}`]],
+  [
+    "writeFileSync",
+    (fp, contents) => [
+      `suite-${suite}/given-${given}/afterEach/${fp}`,
+      contents
+    ]
+  ],
+  [
+    "customScreenShot",
+    (opts2, p) => [
+      {
+        ...opts2,
+        path: `suite-${suite}/given-${given}/afterEach/${opts2.path}`
+      },
+      p
+    ]
+  ]
+]);
+var beforeEachProxy = (pm, suite) => baseProxy(pm, [
+  [
+    "screencast",
+    (opts2, p) => [
+      {
+        ...opts2,
+        path: `suite-${suite}/beforeEach/${opts2.path}`
+      },
+      p
+    ]
+  ],
+  [
+    "writeFileSync",
+    (fp, contents) => [`suite-${suite}/beforeEach/${fp}`, contents]
+  ],
+  [
+    "customScreenShot",
+    (opts2, p) => [
+      {
+        ...opts2,
+        path: `suite-${suite}/beforeEach/${opts2.path}`
+      },
+      p
+    ]
+  ],
+  ["createWriteStream", (fp) => [`suite-${suite}/beforeEach/${fp}`]]
+]);
+var beforeAllProxy = (pm, suite) => baseProxy(pm, [
+  [
+    "writeFileSync",
+    (fp, contents) => [`suite-${suite}/beforeAll/${fp}`, contents]
+  ],
+  [
+    "customScreenShot",
+    (opts2, p) => [
+      {
+        ...opts2,
+        path: `suite-${suite}/beforeAll/${opts2.path}`
+      },
+      p
+    ]
+  ],
+  ["createWriteStream", (fp) => [`suite-${suite}/beforeAll/${fp}`]]
+]);
+var afterAllProxy = (pm, suite) => baseProxy(pm, [
+  ["createWriteStream", (fp) => [`suite-${suite}/afterAll/${fp}`]],
+  [
+    "writeFileSync",
+    (fp, contents) => [`suite-${suite}/afterAll/${fp}`, contents]
+  ],
+  [
+    "customScreenShot",
+    (opts2, p) => [
+      {
+        ...opts2,
+        path: `suite-${suite}/afterAll/${opts2.path}`
+      },
+      p
+    ]
+  ]
+]);
+
 // src/lib/abstractBase.ts
-init_dirname();
-init_buffer();
-init_process();
 var BaseGiven = class {
   constructor(name, features, whens, thens, givenCB, initialValues) {
     this.artifacts = [];
@@ -737,15 +531,7 @@ var BaseThen = class {
   }
 };
 
-// src/lib/classBuilder.ts
-init_dirname();
-init_buffer();
-init_process();
-
 // src/lib/basebuilder.ts
-init_dirname();
-init_buffer();
-init_process();
 var BaseBuilder = class {
   constructor(input, suitesOverrides, givenOverides, whenOverides, thenOverides, testResourceRequirement, testSpecification) {
     this.artifacts = [];
@@ -790,11 +576,14 @@ var BaseBuilder = class {
           };
           const suiteDone = await runner(puppetMaster, tLog);
           const fails = suiteDone.fails;
-          await puppetMaster.writeFileSync(`bdd_errors.txt`, fails.toString());
-          await puppetMaster.writeFileSync(
+          await puppetMaster.writeFileSync([
+            `bdd_errors.txt`,
+            fails.toString()
+          ]);
+          await puppetMaster.writeFileSync([
             `tests.json`,
             JSON.stringify(this.toObj(), null, 2)
-          );
+          ]);
           return {
             failed: fails > 0,
             fails,
@@ -899,10 +688,102 @@ var ClassBuilder = class extends BaseBuilder {
   }
 };
 
+// src/lib/BaseSuite.ts
+var BaseSuite = class {
+  constructor(name, index, givens = {}) {
+    const suiteName = name || "testSuite";
+    if (!suiteName) {
+      throw new Error("BaseSuite requires a non-empty name");
+    }
+    console.log(
+      "[DEBUG] BaseSuite constructor - name:",
+      suiteName,
+      "index:",
+      index
+    );
+    this.name = suiteName;
+    this.index = index;
+    this.givens = givens;
+    this.fails = 0;
+    console.log("[DEBUG] BaseSuite initialized:", this.name, this.index);
+    console.log("[DEBUG] BaseSuite givens:", Object.keys(givens).toString());
+  }
+  features() {
+    try {
+      const features = Object.keys(this.givens).map((k) => this.givens[k].features).flat().filter((value, index, array) => {
+        return array.indexOf(value) === index;
+      });
+      console.debug("[DEBUG] Features extracted:", features.toString());
+      return features || [];
+    } catch (e) {
+      console.error("[ERROR] Failed to extract features:", 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);
+    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];
+      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 {
+      this.afterAll(
+        this.store,
+        artifactory,
+        afterAllProxy(pm, sNdx.toString())
+      );
+    } catch (e) {
+      console.error(e);
+    }
+    return this;
+  }
+};
+
 // src/lib/core.ts
 var TesterantoCore = class extends ClassBuilder {
-  constructor(input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testAdapter, uberCatcher) {
-    const fullAdapter = DefaultAdapter(testAdapter);
+  constructor(input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testAdapter2, uberCatcher) {
+    const fullAdapter = DefaultAdapter(testAdapter2);
     super(
       testImplementation,
       testSpecification,
@@ -960,13 +841,13 @@ var TesterantoCore = class extends ClassBuilder {
 
 // src/Web.ts
 var WebTesteranto = class extends TesterantoCore {
-  constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter) {
+  constructor(input, testSpecification, testImplementation, testResourceRequirement, testAdapter2) {
     super(
       input,
       testSpecification,
       testImplementation,
       testResourceRequirement,
-      testAdapter,
+      testAdapter2,
       (cb) => {
       }
     );
@@ -977,21 +858,237 @@ var WebTesteranto = class extends TesterantoCore {
     return await this.testJobs[0].receiveTestResourceConfig(pm);
   }
 };
-var Web_default = async (input, testSpecification, testImplementation, testAdapter, testResourceRequirement = defaultTestResourceRequirement) => {
+var Web_default = async (input, testSpecification, testImplementation, testAdapter2, testResourceRequirement = defaultTestResourceRequirement) => {
   return new WebTesteranto(
     input,
     testSpecification,
     testImplementation,
     testResourceRequirement,
-    testAdapter
+    testAdapter2
   );
 };
 
+// src/lib/baseBuilder.test/baseBuilder.test.specification.ts
+var specification = (Suite, Given, When, Then) => {
+  return [
+    Suite.Default("Testing BaseBuilder functionality", {
+      testInitialization: Given["the default BaseBuilder"](
+        ["BaseBuilder should initialize correctly"],
+        [],
+        [
+          Then["it is initialized"](),
+          Then["it tracks artifacts"]()
+          // Then["it creates jobs"](),
+          // Then["it generates TestSpecifications"](),
+        ]
+      ),
+      testSpecsGeneration: Given["the default BaseBuilder"](
+        ["BaseBuilder should generate specs from test specification"],
+        [],
+        [Then["it generates TestSpecifications"]()]
+      ),
+      testJobsCreation: Given["the default BaseBuilder"](
+        ["BaseBuilder should create test jobs"],
+        [],
+        [Then["it creates jobs"]()]
+      )
+    })
+  ];
+};
+
+// src/lib/baseBuilder.test/baseBuilder.test.mock.ts
+var MockBaseBuilder = class extends BaseBuilder {
+  constructor(input, suitesOverrides = {}, givenOverrides = {}, whenOverrides = {}, thenOverrides = {}, testResourceRequirement = { ports: 0 }, testSpecification = () => []) {
+    super(
+      input,
+      suitesOverrides,
+      givenOverrides,
+      whenOverrides,
+      thenOverrides,
+      testResourceRequirement,
+      testSpecification
+    );
+    this.summary = {};
+  }
+  /**
+   * Simplified version for testing that doesn't actually run tests
+   */
+  testRun(puppetMaster) {
+    this.summary = {
+      [puppetMaster.testResourceConfiguration.name]: {
+        typeErrors: 0,
+        staticErrors: 0,
+        runTimeError: "",
+        prompt: "",
+        failingFeatures: {}
+      }
+    };
+    return Promise.resolve({
+      failed: false,
+      fails: 0,
+      artifacts: [],
+      // logPromise: Promise.resolve(),
+      features: []
+    });
+  }
+};
+
+// src/lib/baseBuilder.test/baseBuilder.test.implementation.ts
+var implementation = {
+  suites: {
+    Default: "BaseBuilder test suite"
+  },
+  givens: {
+    "the default BaseBuilder": () => {
+      return new MockBaseBuilder(
+        {},
+        // input
+        {},
+        // suitesOverrides
+        {},
+        // givenOverrides
+        {},
+        // whenOverrides
+        {},
+        // thenOverrides
+        { ports: 0 },
+        // testResourceRequirement
+        () => []
+        // testSpecification
+      );
+    },
+    "a BaseBuilder with TestInput": (input) => {
+      return new MockBaseBuilder(
+        input,
+        {},
+        {},
+        {},
+        {},
+        { ports: [] },
+        () => []
+      );
+    },
+    "a BaseBuilder with Test Resource Requirements": (requirements) => {
+      return new MockBaseBuilder({}, {}, {}, {}, {}, requirements, () => []);
+    }
+  },
+  whens: {
+    addArtifact: (artifact) => (builder) => {
+      builder.artifacts.push(artifact);
+      return builder;
+    },
+    setTestJobs: (jobs) => (builder) => {
+      builder.testJobs = jobs;
+      return builder;
+    }
+  },
+  thens: {
+    "it is initialized": () => (builder, utils) => {
+      utils.writeFileSync("hello.txt", "world");
+      if (!(builder instanceof BaseBuilder)) {
+        console.error("Builder instance:", builder);
+        throw new Error(
+          `Builder was not properly initialized - expected BaseBuilder instance but got ${builder?.constructor?.name}`
+        );
+      }
+      [
+        "artifacts",
+        "testJobs",
+        "specs",
+        "suitesOverrides",
+        "givenOverides",
+        "whenOverides",
+        "thenOverides"
+      ].forEach((prop) => {
+        if (!(prop in builder)) {
+          throw new Error(`Builder missing required property: ${prop}`);
+        }
+      });
+      return builder;
+    },
+    "it generates TestSpecifications": () => (builder) => {
+      if (!Array.isArray(builder.specs)) {
+        throw new Error("Specs were not generated");
+      }
+      return builder;
+    },
+    "it creates jobs": () => (builder) => {
+      if (!Array.isArray(builder.testJobs)) {
+        throw new Error("Test jobs were not created");
+      }
+      return builder;
+    },
+    "it tracks artifacts": () => (builder) => {
+      if (!Array.isArray(builder.artifacts)) {
+        throw new Error("Artifacts array not initialized");
+      }
+      return builder;
+    },
+    resourceRequirementsSet: () => (builder) => {
+      if (!builder.testResourceRequirement) {
+        throw new Error("Resource requirements not set");
+      }
+      return builder;
+    },
+    suitesOverridesConfigured: () => (builder) => {
+      if (!builder.suitesOverrides) {
+        throw new Error("Suites overrides not configured");
+      }
+      return builder;
+    },
+    givensOverridesConfigured: () => (builder) => {
+      if (!builder.givenOverides) {
+        throw new Error("Givens overrides not configured");
+      }
+      return builder;
+    },
+    whensOverridesConfigured: () => (builder) => {
+      if (!builder.whenOverides) {
+        throw new Error("Whens overrides not configured");
+      }
+      return builder;
+    },
+    thensOverridesConfigured: () => (builder) => {
+      if (!builder.thenOverides) {
+        throw new Error("Thens overrides not configured");
+      }
+      return builder;
+    }
+  }
+};
+
+// src/lib/baseBuilder.test/baseBuilder.test.adapter.ts
+var testAdapter = {
+  beforeAll: async (input, testResource, pm) => input,
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    console.log("Initializing test with:", {
+      subject,
+      initializer,
+      initialValues
+    });
+    const result = initializer();
+    console.log("Initialization result:", result.toString());
+    return result;
+  },
+  andWhen: async (store, whenCB, testResource, utils) => {
+    return whenCB(store, utils);
+  },
+  butThen: async (store, thenCB, testResource, pm) => {
+    return thenCB(store, pm);
+  },
+  afterEach: (store) => store,
+  afterAll: () => {
+  },
+  assertThis: (x) => x
+};
+
+// src/lib/baseBuilder.test/baseBuilder.test.pure.ts
+var baseBuilder_test_pure_default = Web_default(
+  MockBaseBuilder.prototype,
+  specification,
+  implementation,
+  testAdapter
+);
 export {
-  BaseGiven,
-  BaseWhen,
-  BaseThen,
-  BaseBuilder,
-  BaseSuite,
-  Web_default
+  baseBuilder_test_pure_default as default
 };