testeranto 0.189.0 → 0.197.0

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

@@ -5,7 +5,7 @@ import {
   BaseThen,
   BaseWhen,
   Pure_default
-} from "../../../chunk-KHJ35R7C.mjs";
+} from "../../../chunk-62UVCSQC.mjs";
 
 // src/lib/BaseSuite.test/mock.ts
 var MockGiven = class extends BaseGiven {
@@ -15,14 +15,14 @@ var MockGiven = class extends BaseGiven {
       features,
       whens,
       thens,
-      async () => ({ testStore: true, testSelection: false }),
+      async () => ({ testStore: true }),
       // givenCB
       {}
       // initialValues
     );
   }
   async givenThat() {
-    return { testStore: true, testSelection: false };
+    return { testStore: true };
   }
   uberCatcher(e) {
     console.error("Given error 2:", e);
@@ -30,38 +30,18 @@ var MockGiven = class extends BaseGiven {
 };
 var MockWhen = class extends BaseWhen {
   async andWhen(store, whenCB, testResource, pm) {
-    const newStore = {
-      ...store,
-      testSelection: true
-      // Ensure testSelection is set for assertions
-    };
-    const result = await whenCB(newStore);
-    return result;
+    const selection = { testSelection: true };
+    const result = await whenCB(selection)(store);
+    return { ...store, ...result };
   }
-  addArtifact(name, content) {
-    return this;
+  addArtifact(path) {
   }
 };
 var MockThen = class extends BaseThen {
-  async butThen(store, thenCB, testResourceConfiguration, pm) {
-    const testSelection = {
-      name: store.name,
-      index: store.index,
-      testSelection: store.testSelection || false,
-      error: store.error ? true : void 0
-    };
-    try {
-      const result = await thenCB(testSelection);
-      if (!result || typeof result.testSelection === "undefined") {
-        throw new Error(
-          `Invalid test selection result: ${JSON.stringify(result)}`
-        );
-      }
-      return result;
-    } catch (e) {
-      console.error("[ERROR] MockThen - butThen failed:", e);
-      throw e;
-    }
+  async butThen(store, thenCB, testResourceConfiguration, pm, ...args) {
+    const selection = { testSelection: true };
+    await thenCB(selection);
+    return selection;
   }
 };
 var MockSuite = class extends BaseSuite {
@@ -74,11 +54,11 @@ var MockSuite = class extends BaseSuite {
       testGiven: new MockGiven(
         "testGiven",
         ["testFeature"],
-        [new MockWhen("testWhen", () => Promise.resolve({ testStore: true }))],
+        [new MockWhen("testWhen", async () => Promise.resolve({ testSelection: true }))],
         [
           new MockThen(
             "testThen",
-            async () => Promise.resolve({ testSelection: true })
+            async () => Promise.resolve(new BaseSuite("temp", 0, {}))
           )
         ]
       )
@@ -141,8 +121,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: {
@@ -221,30 +207,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;
@@ -338,25 +318,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;
     }
   },

package/testeranto/bundles/pure/core/src/lib/baseBuilder.test/baseBuilder.test.pure.mjs

@@ -2,7 +2,7 @@ import { createRequire } from 'module';const require = createRequire(import.meta
 import {
   BaseBuilder,
   Pure_default
-} from "../../../chunk-KHJ35R7C.mjs";
+} from "../../../chunk-62UVCSQC.mjs";
 
 // src/lib/baseBuilder.test/baseBuilder.test.specification.ts
 var specification = (Suite, Given, When, Then) => {
@@ -85,7 +85,7 @@ var implementation = {
     Default: "BaseBuilder test suite"
   },
   givens: {
-    "the default BaseBuilder": () => {
+    "the default BaseBuilder": () => () => {
       return new MockBaseBuilder(
         {},
         // input
@@ -103,7 +103,7 @@ var implementation = {
         // testSpecification
       );
     },
-    "a BaseBuilder with TestInput": (input) => {
+    "a BaseBuilder with TestInput": (input) => () => {
       return new MockBaseBuilder(
         input,
         {},
@@ -114,16 +114,16 @@ var implementation = {
         () => []
       );
     },
-    "a BaseBuilder with Test Resource Requirements": (requirements) => {
+    "a BaseBuilder with Test Resource Requirements": (requirements) => () => {
       return new MockBaseBuilder({}, {}, {}, {}, {}, requirements, () => []);
     }
   },
   whens: {
-    addArtifact: (artifact) => (builder) => {
+    addArtifact: (artifact) => (builder, utils) => {
       builder.artifacts.push(artifact);
       return builder;
     },
-    setTestJobs: (jobs) => (builder) => {
+    setTestJobs: (jobs) => (builder, utils) => {
       builder.testJobs = jobs;
       return builder;
     }
@@ -152,13 +152,13 @@ var implementation = {
       });
       return builder;
     },
-    "it generates TestSpecifications": () => (builder) => {
+    "it generates TestSpecifications": () => (builder, utils) => {
       if (!Array.isArray(builder.specs)) {
         throw new Error("Specs were not generated");
       }
       return builder;
     },
-    "it creates jobs": () => (builder) => {
+    "it creates jobs": () => (builder, utils) => {
       if (!Array.isArray(builder.testJobs)) {
         throw new Error("Test jobs were not created");
       }
@@ -171,31 +171,31 @@ var implementation = {
       utils.writeFileSync("artifact_test.txt", "test");
       return builder;
     },
-    resourceRequirementsSet: () => (builder) => {
+    resourceRequirementsSet: () => (builder, utils) => {
       if (!builder.testResourceRequirement) {
         throw new Error("Resource requirements not set");
       }
       return builder;
     },
-    suitesOverridesConfigured: () => (builder) => {
+    suitesOverridesConfigured: () => (builder, utils) => {
       if (!builder.suitesOverrides) {
         throw new Error("Suites overrides not configured");
       }
       return builder;
     },
-    givensOverridesConfigured: () => (builder) => {
+    givensOverridesConfigured: () => (builder, utils) => {
       if (!builder.givenOverides) {
         throw new Error("Givens overrides not configured");
       }
       return builder;
     },
-    whensOverridesConfigured: () => (builder) => {
+    whensOverridesConfigured: () => (builder, utils) => {
       if (!builder.whenOverides) {
         throw new Error("Whens overrides not configured");
       }
       return builder;
     },
-    thensOverridesConfigured: () => (builder) => {
+    thensOverridesConfigured: () => (builder, utils) => {
       if (!builder.thenOverides) {
         throw new Error("Thens overrides not configured");
       }
@@ -206,19 +206,25 @@ var implementation = {
 
 // src/lib/baseBuilder.test/baseBuilder.test.adapter.ts
 var testAdapter = {
-  beforeAll: async (input, testResource, pm) => input,
+  beforeAll: async (input, testResource, pm) => {
+    return input;
+  },
   beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-    const result = initializer();
+    const result = initializer()();
     return result;
   },
   andWhen: async (store, whenCB, testResource, utils) => {
-    return whenCB(store, utils);
+    const result = whenCB(store, utils);
+    return result;
   },
   butThen: async (store, thenCB, testResource, pm) => {
-    return thenCB(store, pm);
+    const result = thenCB(store, pm);
+    return result;
+  },
+  afterEach: async (store, key, pm) => {
+    return store;
   },
-  afterEach: (store) => store,
-  afterAll: () => {
+  afterAll: (store, pm) => {
   },
   assertThis: (x) => x
 };