testeranto 0.177.0 → 0.197.0

package/src/lib/basebuilder.ts

@@ -3,6 +3,8 @@
 /* eslint-disable no-async-promise-executor */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+// Do not add logging to this file as it is used by the pure runtime.
+
 import { PassThrough } from "stream";
 
 import type {
@@ -32,7 +34,7 @@ export abstract class BaseBuilder<
 > {
   specs: any;
 
-  assertThis: (t: I["then"]) => {};
+  assertThis: (t: I["then"]) => any;
 
   testResourceRequirement: ITTestResourceRequest;
   artifacts: Promise<unknown>[] = [];
@@ -72,23 +74,27 @@ export abstract class BaseBuilder<
       const suiteRunner =
         (suite: BaseSuite<I, O>) =>
         async (puppetMaster: IPM, tLog: ITLog): Promise<BaseSuite<I, O>> => {
-          console.log("mark17");
-          const x = await suite.run(
-            input,
-            puppetMaster.testResourceConfiguration,
-            (fPath: string, value: string | Buffer | PassThrough) =>
-              puppetMaster.testArtiFactoryfileWriter(
-                tLog,
-                (p: Promise<void>) => {
-                  this.artifacts.push(p);
-                }
-              )(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value),
-            tLog,
-            puppetMaster
-          );
-          console.log("mark18");
-
-          return x;
+          try {
+            const x = await suite.run(
+              input,
+              puppetMaster.testResourceConfiguration,
+              (fPath: string, value: string | Buffer | PassThrough) =>
+                puppetMaster.testArtiFactoryfileWriter(
+                  tLog,
+                  (p: Promise<void>) => {
+                    this.artifacts.push(p);
+                  }
+                )(
+                  puppetMaster.testResourceConfiguration.fs + "/" + fPath,
+                  value
+                ),
+              tLog,
+              puppetMaster
+            );
+            return x;
+          } catch (e) {
+            console.error(e.stack);
+          }
         };
 
       const runner = suiteRunner(suite);
@@ -105,46 +111,34 @@ export abstract class BaseBuilder<
         receiveTestResourceConfig: async function (
           puppetMaster: IPM
         ): Promise<IFinalResults> {
-          // const logFilePath = "logs.txt";
-          // const access: number = await puppetMaster.createWriteStream(
-          //   logFilePath
-          // );
-
-          // deprecated?
           const tLog = async (...l: string[]) => {
             //
           };
 
-          console.log("mark14");
-          const suiteDone: BaseSuite<I, O> = await runner(puppetMaster, tLog);
-          console.log("mark15");
-
-          // 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),
-          ]);
-
-          console.log("mark13");
-
-          return {
-            failed: fails > 0,
-            fails,
-            artifacts: this.artifacts || [],
-            // logPromise,
-            features: suiteDone.features(),
-          };
+          try {
+            const suiteDone: BaseSuite<I, O> = 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: [],
+            };
+          }
         },
       };
     });

package/src/lib/classBuilder.ts

@@ -1,5 +1,8 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
+
+// Do not add logging to this file as it is used by the pure runtime.
+
 import { NonEmptyObject } from "type-fest";
 
 import type {
@@ -79,10 +82,10 @@ export abstract class ClassBuilder<
     );
 
     const classyWhens = Object.entries(testImplementation.whens).reduce(
-      (a, [key, whEn]: [string, (x) => any]) => {
-        a[key] = (...payload: any) => {
+      (a, [key, whEn]: [string, (...x: any[]) => any]) => {
+        a[key] = (...payload: any[]) => {
           return new whenKlasser.prototype.constructor(
-            `${whEn.name}: ${payload && payload.toString()}`,
+            `${key}: ${payload && payload.toString()}`,
             whEn(...payload)
           );
         };
@@ -91,14 +94,12 @@ export abstract class ClassBuilder<
       {}
     );
 
-    const classyThens = Object.entries<(expected: any, ...x: any[]) => any>(
-      testImplementation.thens
-    ).reduce(
-      (a, [key, thEn]: [string, (s: I["iselection"]) => I["isubject"]]) => {
-        a[key] = (expected, ...x) => {
+    const classyThens = Object.entries(testImplementation.thens).reduce(
+      (a, [key, thEn]: [string, (...x: any[]) => any]) => {
+        a[key] = (...args: any[]) => {
           return new thenKlasser.prototype.constructor(
-            `${thEn.name}: ${expected && expected.toString()}`,
-            thEn(expected, ...x)
+            `${key}: ${args && args.toString()}`,
+            thEn(...args)
           );
         };
         return a;

package/src/lib/core.test/MockCore.ts

@@ -33,27 +33,6 @@ export class MockCore<
     testAdapter: Partial<ITestAdapter<I>>,
     uberCatcher: (cb: () => void) => void = (cb) => cb()
   ) {
-    console.log("[DEBUG] MockCore constructor starting...");
-
-    if (!testImplementation) {
-      throw new Error("testImplementation is required");
-    }
-    if (!testSpecification) {
-      console.warn(
-        "[WARN] testSpecification is null/undefined - tests may fail"
-      );
-    }
-
-    console.log("[DEBUG] MockCore constructor called with:");
-    console.log("- input:", JSON.stringify(input, null, 2));
-    console.log("- testSpecification keys:", Object.keys(testSpecification));
-    console.log("- testImplementation keys:", Object.keys(testImplementation));
-    console.log(
-      "- testResourceRequirement:",
-      JSON.stringify(testResourceRequirement)
-    );
-    console.log("- testAdapter keys:", Object.keys(testAdapter));
-
     // Validate required implementation methods
     const requiredMethods = ["suites", "givens", "whens", "thens"];
     requiredMethods.forEach((method) => {
@@ -62,8 +41,6 @@ export class MockCore<
       }
     });
 
-    console.log("[DEBUG] Validation passed, calling super...");
-
     // this.testResourceRequirement = testResourceRequirement;
     // this.testAdapter = testAdapter;
     super(

package/src/lib/core.test/core.test.adapter.ts

@@ -6,26 +6,20 @@ import { MockCore } from "./MockCore";
 
 export const testAdapter: ITestAdapter<I> = {
   beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-    console.log('[DEBUG] BeforeEach - subject:', subject);
-    console.log('[DEBUG] BeforeEach - initialValues:', initialValues);
-    console.log('[DEBUG] BeforeEach called with:');
-    console.log('- subject type:', typeof subject);
-    console.log('- testResource:', JSON.stringify(testResource, null, 2));
-    console.log('- initialValues:', initialValues);
-    
     try {
       const result = await initializer();
       if (!result) {
-        throw new Error('Initializer returned undefined');
+        throw new Error("Initializer returned undefined");
       }
       if (!(result instanceof MockCore)) {
-        throw new Error(`Initializer returned ${result?.constructor?.name}, expected MockCore`);
+        throw new Error(
+          `Initializer returned ${result?.constructor?.name}, expected MockCore`
+        );
       }
-      
-      console.log('[DEBUG] BeforeEach initialized MockCore successfully');
+
       return result;
     } catch (e) {
-      console.error('[ERROR] BeforeEach failed:', e);
+      console.error("[ERROR] BeforeEach failed:", e);
       throw e;
     }
   },

package/src/lib/core.test/core.test.implementation.ts

@@ -12,13 +12,9 @@ export const implementation: ITestImplementation<I, O, M> = {
 
   givens: {
     Default: () => {
-      console.log('[DEBUG] Creating Default MockCore instance');
       const input = { debug: true };
       const resourceReq = { ports: [3000] };
-      
-      console.log('[DEBUG] Default Given - input:', input);
-      console.log('[DEBUG] Default Given - resourceReq:', resourceReq);
-      
+
       try {
         const instance = new MockCore(
           input,
@@ -28,10 +24,9 @@ export const implementation: ITestImplementation<I, O, M> = {
           testAdapter,
           (cb) => cb()
         );
-        console.log('[DEBUG] MockCore instance created successfully:', instance);
         return instance;
       } catch (e) {
-        console.error('[ERROR] Failed to create MockCore:', e);
+        console.error("[ERROR] Failed to create MockCore:", e);
         throw e;
       }
     },
@@ -77,9 +72,9 @@ export const implementation: ITestImplementation<I, O, M> = {
       return builder;
     },
     modifySpecs: (modifier: (specs: any[]) => any[]) => (builder) => {
-      console.log('Modifying specs - current count:', builder.specs?.length);
+      console.log("Modifying specs - current count:", builder.specs?.length);
       const newSpecs = modifier(builder.specs || []);
-      console.log('Modifying specs - new count:', newSpecs.length);
+      console.log("Modifying specs - new count:", newSpecs.length);
       builder.specs = newSpecs;
       return builder;
     },
@@ -94,7 +89,9 @@ export const implementation: ITestImplementation<I, O, M> = {
         throw new Error("Builder is undefined");
       }
       if (!(builder instanceof MockCore)) {
-        throw new Error(`Builder is not MockCore (got ${builder.constructor.name})`);
+        throw new Error(
+          `Builder is not MockCore (got ${builder.constructor.name})`
+        );
       }
       if (!builder.testResourceRequirement) {
         throw new Error("testResourceRequirement not set");

package/src/lib/core.ts

@@ -1,6 +1,8 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
+// Do not add logging to this file as it is used by the pure runtime.
+
 import type {
   Ibdd_in_any,
   Ibdd_out_any,
@@ -40,7 +42,7 @@ export default abstract class TesterantoCore<
     testAdapter: Partial<ITestAdapter<I>>,
     uberCatcher: (cb: () => void) => void
   ) {
-    const fullAdapter = DefaultAdapter(testAdapter);
+    const fullAdapter = DefaultAdapter<I>(testAdapter);
 
     super(
       testImplementation,
@@ -62,20 +64,7 @@ export default abstract class TesterantoCore<
           tr: ITTestResourceConfiguration,
           pm: IPM
         ): Promise<I["isubject"]> {
-          return (
-            fullAdapter.beforeAll ||
-            (async (
-              input: I["iinput"],
-              artifactory: ITestArtifactory,
-              tr,
-              pm: IPM
-            ) => input as any)
-          )(
-            s,
-            this.testResourceConfiguration,
-            // artifactory,
-            pm
-          );
+          return fullAdapter.beforeAll?.(s, tr, pm) ?? (s as unknown as Promise<I["isubject"]>);
         }
       } as any,
 
@@ -90,7 +79,6 @@ export default abstract class TesterantoCore<
           initialValues,
           pm
         ) {
-          console.log("mark800");
           return fullAdapter.beforeEach(
             subject,
             initializer,
@@ -106,11 +94,8 @@ export default abstract class TesterantoCore<
           artifactory,
           pm
         ): Promise<unknown> {
-          return new Promise((res) =>
-            res(fullAdapter.afterEach(store, key, pm))
-          );
+          return Promise.resolve(fullAdapter.afterEach(store, key, pm));
         }
-        s;
       } as any,
 
       class When extends BaseWhen<I> {

package/src/lib/index.ts

@@ -1,34 +1,39 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { PM_Pure } from "../PM/pure.js";
 
-import { PM_Node } from "../PM/node.js";
-import { PM_Web } from "../PM/web.js";
-import { ITestconfig, IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
+// Do not add logging to this file as it is used by the pure runtime.
 
-import { IGivens } from "./abstractBase.js";
-import { IPM } from "./types.js";
-import type { ITestAdapter, Ibdd_in_any, Ibdd_out_any } from "../CoreTypes.js";
-import { BaseSuite } from "./BaseSuite.js";
+import { Ibdd_in_any, ITestAdapter, Ibdd_out_any } from "../CoreTypes";
+import { PM_Node } from "../PM/node";
+import { PM_Pure } from "../PM/pure";
+import { PM_Web } from "../PM/web";
+import { ITestconfig, IBuiltConfig, IRunTime, ITestTypes } from "../Types";
+import { IGivens } from "./abstractBase";
+import { BaseSuite } from "./BaseSuite";
+import { IPM } from "./types";
 
 export const BaseAdapter = <T extends Ibdd_in_any>(): ITestAdapter<T> => ({
-  beforeAll: async (s: T["istore"]) => s,
+  beforeAll: async (input: T["iinput"], testResource: ITTestResourceConfiguration, pm: IPM) => {
+    return input as unknown as T["isubject"];
+  },
   beforeEach: async function (
     subject: T["isubject"],
-    initialValues: T["iinitialValues"],
-    x: unknown,
+    initializer: (c?: any) => T["given"],
     testResource: ITTestResourceConfiguration,
+    initialValues: any,
     pm: IPM
-  ): Promise<T["isubject"]> {
-    return subject;
+  ): Promise<T["istore"]> {
+    return subject as unknown as T["istore"];
   },
-  afterEach: async (s: T["istore"]) => s,
-  afterAll: (store: T["istore"]) => undefined,
+  afterEach: async (store: T["istore"], key: string, pm: IPM) => Promise.resolve(store),
+  afterAll: (store: T["istore"], pm: IPM) => undefined,
   butThen: async (
     store: T["istore"],
-    thenCb: (s: T["iselection"]) => Promise<T["isubject"]>
+    thenCb: T["then"],
+    testResource: ITTestResourceConfiguration,
+    pm: IPM
   ) => {
-    return thenCb(store);
+    return thenCb(store, pm);
   },
   andWhen: async (
     store: T["istore"],
@@ -36,23 +41,19 @@ export const BaseAdapter = <T extends Ibdd_in_any>(): ITestAdapter<T> => ({
     testResource: ITTestResourceConfiguration,
     pm: IPM
   ) => {
-    try {
-      await whenCB(store, testResource, pm);
-    } catch (error) {
-      console.error("Error in andWhen:", error);
-      throw error; // Re-throw to maintain test failure
-    }
+    return whenCB(store, pm);
   },
-  assertThis: (x: any) => x,
+  assertThis: (x: T["then"]) => x,
 });
 
 export const DefaultAdapter = <T extends Ibdd_in_any>(
   p: Partial<ITestAdapter<T>>
 ): ITestAdapter<T> => {
+  const base = BaseAdapter<T>();
   return {
-    ...BaseAdapter,
+    ...base,
     ...p,
-  };
+  } as ITestAdapter<T>;
 };
 
 export type ITTestResourceConfiguration = {
@@ -83,7 +84,7 @@ export type ILogWriter = {
   mkdirSync: () => any;
   testArtiFactoryfileWriter: (
     tLog: ITLog,
-    n: (Promise) => void
+    n: (promise: Promise<any>) => void
   ) => (fPath: string, value: unknown) => void;
 };
 

package/src/lib/pmProxy.test/adapter.ts

@@ -22,12 +22,18 @@ export const testAdapter: ITestAdapter<I> = {
   },
 
   andWhen: async (store, whenCB, testResource, pm) => {
-    const proxiedPM = andWhenProxy(pm, "some/path", store);
+    const proxiedPM = andWhenProxy(pm, "some/path", (path) => {
+      console.log("Artifact added:", path);
+      return path;
+    });
     return whenCB(store, proxiedPM);
   },
 
   butThen: async (store, thenCB, testResource, pm) => {
-    const proxiedPM = butThenProxy(pm, "some/path", store);
+    const proxiedPM = butThenProxy(pm, "some/path", (path) => {
+      console.log("Artifact added:", path);
+      return path;
+    });
     return thenCB(store, proxiedPM);
   },
 
@@ -42,7 +48,15 @@ export const testAdapter: ITestAdapter<I> = {
     };
   },
 
-  assertThis: (returnedFilePath, expectation) => {
-    assert.equal(returnedFilePath, expectation);
+  assertThis: (actualResult, expectedResult) => {
+    // Handle both path assertions and our new test result
+    if (typeof actualResult === 'string' && actualResult.startsWith('PASS')) {
+      assert.equal(actualResult, 'PASS', 'tests.json should be written with correct path and content');
+    } else if (typeof actualResult === 'string' && actualResult.startsWith('FAIL')) {
+      // For the tests.json write test, we want to see what's actually happening
+      assert.fail(`Test failed: ${actualResult}`);
+    } else {
+      assert.equal(actualResult, expectedResult);
+    }
   },
 };