testeranto 0.173.0 → 0.189.0

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

@@ -96,10 +96,12 @@ export const implementation: ITestImplementation<I, O, {}> = {
       }
       return builder;
     },
-    "it tracks artifacts": () => (builder: TestSubject) => {
+    "it tracks artifacts": () => (builder: TestSubject, utils) => {
       if (!Array.isArray(builder.artifacts)) {
         throw new Error("Artifacts array not initialized");
       }
+      // Verify we can write artifacts
+      utils.writeFileSync("artifact_test.txt", "test");
       return builder;
     },
     resourceRequirementsSet: () => (builder: TestSubject) => {

package/src/lib/baseBuilder.test/baseBuilder.test.mock.ts

@@ -58,23 +58,33 @@ export class MockBaseBuilder<
   /**
    * Simplified version for testing that doesn't actually run tests
    */
-  public testRun(puppetMaster: any): Promise<any> {
-    this.summary = {
-      [puppetMaster.testResourceConfiguration.name]: {
-        typeErrors: 0,
-        staticErrors: 0,
-        runTimeError: "",
-        prompt: "",
-        failingFeatures: {},
-      },
-    };
+  public async testRun(puppetMaster: any): Promise<any> {
+    try {
+      this.summary = {
+        [puppetMaster.testResourceConfiguration.name]: {
+          typeErrors: 0,
+          staticErrors: 0,
+          runTimeError: "",
+          prompt: "",
+          failingFeatures: {},
+        },
+      };
 
-    return Promise.resolve({
-      failed: false,
-      fails: 0,
-      artifacts: [],
-      // logPromise: Promise.resolve(),
-      features: [],
-    });
+      return {
+        failed: false,
+        fails: 0,
+        artifacts: this.artifacts,
+        features: [],
+      };
+    } catch (error) {
+      console.error("Test run failed:", error);
+      return {
+        failed: true,
+        fails: 1,
+        artifacts: this.artifacts,
+        features: [],
+        error: error.message
+      };
+    }
   }
 }

package/src/lib/baseBuilder.test/baseBuilder.test.pure.ts

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-empty-object-type */
-import Testeranto from "../../Web";
+import Testeranto from "../../Pure";
 
 import { specification } from "./baseBuilder.test.specification";
 import { implementation } from "./baseBuilder.test.implementation";

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 {
@@ -72,21 +74,27 @@ export abstract class BaseBuilder<
       const suiteRunner =
         (suite: BaseSuite<I, O>) =>
         async (puppetMaster: IPM, tLog: ITLog): Promise<BaseSuite<I, O>> => {
-          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;
+          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);
@@ -103,42 +111,39 @@ 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[]) => {
             //
           };
 
-          const suiteDone: BaseSuite<I, O> = await runner(puppetMaster, tLog);
+          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),
+            ]);
+
+            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: [],
+            };
+          }
 
           // 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(),
-          };
         },
       };
     });

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 {

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,

package/src/lib/index.ts

@@ -1,15 +1,16 @@
 /* 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,

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");
+    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");
+    const proxiedPM = butThenProxy(pm, "some/path", (path) => {
+      console.log("Artifact added:", path);
+      return path;
+    });
     return thenCB(store, proxiedPM);
   },
 

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

@@ -1,10 +1,43 @@
 import { ITestImplementation } from "../../CoreTypes";
-
 import { IPM } from "../types";
-import { IProxiedFunctions, IProxy } from "../pmProxy";
-
+import { IProxy } from "../pmProxy";
 import { I, M, O } from "./types";
 import { MockPMBase } from "./mockPMBase";
+import { butThenProxy } from "../pmProxy";
+
+type PathRewriter = (path: string) => string;
+
+function createPathRewriter(basePath: string): PathRewriter {
+  return (path: string) => {
+    if (!path) return path;
+    // Normalize paths and handle edge cases
+    const normalizedPath = path.replace(/\\/g, '/');
+    const normalizedBase = basePath.replace(/\\/g, '/');
+    
+    // Handle absolute paths
+    if (normalizedPath.startsWith('/')) {
+      return `${normalizedBase}${normalizedPath}`;
+    }
+    
+    // Handle parent directory references
+    if (normalizedPath.includes('../')) {
+      const parts = normalizedPath.split('/');
+      const baseParts = normalizedBase.split('/');
+      
+      for (const part of parts) {
+        if (part === '..') {
+          baseParts.pop();
+        } else if (part !== '.') {
+          baseParts.push(part);
+        }
+      }
+      
+      return baseParts.join('/');
+    }
+    
+    return `${normalizedBase}/${normalizedPath}`;
+  };
+}
 
 export const implementation: ITestImplementation<I, O, M> = {
   suites: {
@@ -20,11 +53,11 @@ export const implementation: ITestImplementation<I, O, M> = {
   },
   thens: {
     theButTheProxyReturns:
-      (method: IProxiedFunctions, expectedPath: string) =>
-      (store: { butThenProxy: IProxy }) => {
+      (method: string, expectedPath: string) =>
+      (store: { pathRewriter: PathRewriter }) => {
         const mockPm = new MockPMBase() as unknown as IPM;
         const filepath = "test/path";
-        const proxiedPm = store.butThenProxy(mockPm, filepath);
+        const rewritePath = createPathRewriter(`${filepath}/butThen`);
 
         let actualPath: string;
         let actualContent: any;
@@ -35,7 +68,7 @@ export const implementation: ITestImplementation<I, O, M> = {
               const content = expectedPath.includes("content")
                 ? "test content"
                 : "default content";
-              proxiedPm.writeFileSync(
+              butThenProxy(mockPm, filepath, {}).writeFileSync(
                 expectedPath.includes("empty")
                   ? ""
                   : expectedPath.includes("nested")
@@ -52,14 +85,14 @@ export const implementation: ITestImplementation<I, O, M> = {
               break;
 
             case "createWriteStream":
-              proxiedPm.createWriteStream(
+              butThenProxy(mockPm, filepath, {}).createWriteStream(
                 expectedPath.includes("empty") ? "" : "stream.txt"
               );
               actualPath = mockPm.getLastCall("createWriteStream")?.path;
               break;
 
             case "screencast":
-              proxiedPm.screencast(
+              butThenProxy(mockPm, filepath, {}).screencast(
                 {
                   path: "screen.png",
                   quality: 80,
@@ -72,7 +105,7 @@ export const implementation: ITestImplementation<I, O, M> = {
               break;
 
             case "customScreenShot":
-              proxiedPm.customScreenShot({ path: "shot.png" }, "test");
+              butThenProxy(mockPm, filepath, {}).customScreenShot({ path: "shot.png" }, "test");
               actualPath = mockPm.getLastCall("customScreenShot")?.opts?.path;
               break;
 

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

@@ -32,6 +32,17 @@ export class MockPMBase implements PM_Base {
     return calls ? calls[calls.length - 1] : null;
   }
 
+  // Add missing methods used in tests
+  // writeFileSync(path: string, content: string): Promise<boolean> {
+  //   this.trackCall('writeFileSync', { path, content });
+  //   return Promise.resolve(true);
+  // }
+
+  // end(uid: number): Promise<boolean> {
+  //   this.trackCall('end', { uid });
+  //   return Promise.resolve(true);
+  // }
+
   // Minimal implementations of required methods
   launchSideCar(n: number, testName: string, projectName: string) {
     this.trackCall("launchSideCar", { n, testName, projectName });

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

@@ -8,8 +8,6 @@ export type I = Ibdd_in<
   { butThenProxy: IProxy },
   { proxies: ITestProxies; filepath: string; mockPm: IPM },
   { butThenProxy: IProxy },
-  // { butThenProxy: IProxy },
-
   { proxies: ITestProxies; filepath: string; mockPm: IPM },
   [string, string],
   (