testeranto 0.189.0 → 0.198.0

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

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { ITestImplementation } from "../../CoreTypes";
 import { IPM } from "../types";
 import { IProxy } from "../pmProxy";
@@ -11,30 +12,30 @@ 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, '/');
-    
+    const normalizedPath = path.replace(/\\/g, "/");
+    const normalizedBase = basePath.replace(/\\/g, "/");
+
     // Handle absolute paths
-    if (normalizedPath.startsWith('/')) {
+    if (normalizedPath.startsWith("/")) {
       return `${normalizedBase}${normalizedPath}`;
     }
-    
+
     // Handle parent directory references
-    if (normalizedPath.includes('../')) {
-      const parts = normalizedPath.split('/');
-      const baseParts = normalizedBase.split('/');
-      
+    if (normalizedPath.includes("../")) {
+      const parts = normalizedPath.split("/");
+      const baseParts = normalizedBase.split("/");
+
       for (const part of parts) {
-        if (part === '..') {
+        if (part === "..") {
           baseParts.pop();
-        } else if (part !== '.') {
+        } else if (part !== ".") {
           baseParts.push(part);
         }
       }
-      
-      return baseParts.join('/');
+
+      return baseParts.join("/");
     }
-    
+
     return `${normalizedBase}/${normalizedPath}`;
   };
 }
@@ -54,72 +55,82 @@ export const implementation: ITestImplementation<I, O, M> = {
   thens: {
     theButTheProxyReturns:
       (method: string, expectedPath: string) =>
-      (store: { pathRewriter: PathRewriter }) => {
+      async (store: { pathRewriter: PathRewriter }) => {
         const mockPm = new MockPMBase() as unknown as IPM;
         const filepath = "test/path";
-        const rewritePath = createPathRewriter(`${filepath}/butThen`);
 
-        let actualPath: string;
-        let actualContent: any;
+        // Track the actual path that was used
+        let actualPath: string | undefined;
+
+        // Monkey patch to track the path
+        const originalWriteFileSync = mockPm.writeFileSync;
+        mockPm.writeFileSync = async (
+          path: string,
+          content: string,
+          testName?: string
+        ) => {
+          actualPath = path;
+          return originalWriteFileSync.call(mockPm, path, content, testName);
+        };
+
+        const originalCreateWriteStream = mockPm.createWriteStream;
+        mockPm.createWriteStream = async (path: string, testName?: string) => {
+          actualPath = path;
+          return originalCreateWriteStream.call(mockPm, path, testName);
+        };
+
+        const originalScreencast = mockPm.screencast;
+        mockPm.screencast = async (opts: any, testName: string, page?: any) => {
+          actualPath = opts.path;
+          return originalScreencast.call(mockPm, opts, testName, page);
+        };
+
+        const originalCustomScreenShot = mockPm.customScreenShot;
+        mockPm.customScreenShot = async (
+          opts: any,
+          testName: string,
+          pageUid?: any
+        ) => {
+          actualPath = opts.path;
+          return originalCustomScreenShot.call(mockPm, opts, testName, pageUid);
+        };
 
         try {
           switch (method) {
             case "writeFileSync":
-              const content = expectedPath.includes("content")
-                ? "test content"
-                : "default content";
-              butThenProxy(mockPm, filepath, {}).writeFileSync(
-                expectedPath.includes("empty")
-                  ? ""
-                  : expectedPath.includes("nested")
-                  ? "nested/folder/test.txt"
-                  : expectedPath.includes("spaces")
-                  ? "file with spaces.txt"
-                  : expectedPath.includes("invalid")
-                  ? "../invalid.txt"
-                  : "test.txt",
-                content
+              await butThenProxy(mockPm, filepath, {}).writeFileSync(
+                "test.txt",
+                "content",
+                "test"
               );
-              actualPath = mockPm.getLastCall("writeFileSync")?.path;
-              actualContent = mockPm.getLastCall("writeFileSync")?.content;
               break;
-
             case "createWriteStream":
-              butThenProxy(mockPm, filepath, {}).createWriteStream(
-                expectedPath.includes("empty") ? "" : "stream.txt"
+              await butThenProxy(mockPm, filepath, {}).createWriteStream(
+                "stream.txt",
+                "test"
               );
-              actualPath = mockPm.getLastCall("createWriteStream")?.path;
               break;
-
             case "screencast":
-              butThenProxy(mockPm, filepath, {}).screencast(
-                {
-                  path: "screen.png",
-                  quality: 80,
-                  fullPage: true,
-                },
+              await butThenProxy(mockPm, filepath, {}).screencast(
+                { path: "screen.png" },
                 "test"
               );
-              actualPath = mockPm.getLastCall("screencast")?.opts?.path;
-              actualContent = mockPm.getLastCall("screencast")?.opts;
               break;
-
             case "customScreenShot":
-              butThenProxy(mockPm, filepath, {}).customScreenShot({ path: "shot.png" }, "test");
-              actualPath = mockPm.getLastCall("customScreenShot")?.opts?.path;
+              await butThenProxy(mockPm, filepath, {}).customScreenShot(
+                { path: "shot.png" },
+                "test"
+              );
               break;
-
             default:
               throw new Error(`Unknown method: ${method}`);
           }
 
-          if (expectedPath === undefined) {
-            return [undefined, undefined];
-          }
-
-          return [actualPath, expectedPath, actualContent];
+          // For now, just return the actual path to be asserted against expectedPath
+          // The testAdapter.assertThis will handle the comparison
+          return actualPath;
         } catch (error) {
-          return [error.message, expectedPath];
+          throw error;
         }
       },
 
@@ -134,5 +145,45 @@ export const implementation: ITestImplementation<I, O, M> = {
       }
       return result;
     },
+    // Test to verify tests.json is written correctly
+    verifyTestsJsonWrite:
+      () => async (store: { pathRewriter: PathRewriter }) => {
+        const mockPm = new MockPMBase() as unknown as IPM;
+
+        // Track the actual parameters passed to writeFileSync
+        let actualArgs: any[] | undefined;
+        const originalWriteFileSync = mockPm.writeFileSync;
+        mockPm.writeFileSync = async (...args: any[]) => {
+          actualArgs = args;
+          // Check if the first argument is being split
+          if (args[0] && typeof args[0] === "string") {
+            console.log(
+              `[TESTS.JSON DEBUG] First argument length: ${args[0].length}, value: "${args[0]}"`
+            );
+          }
+          return originalWriteFileSync.apply(mockPm, args);
+        };
+
+        // Simulate writing tests.json through the proxy
+        // This should mimic the call in BaseBuilder: puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2))
+        const testData = { test: "data" };
+        // const result = await butThenProxy(mockPm, "test/path", {}).writeFileSync(
+        //   "tests.json",
+        //   JSON.stringify(testData, null, 2),
+        //   "test"
+        // );
+
+        // Check if both path and content are correct
+        if (
+          actualArgs &&
+          actualArgs[0] === "test/path/butThen/tests.json" &&
+          actualArgs[1] === JSON.stringify(testData, null, 2) &&
+          actualArgs[2] === "test"
+        ) {
+          return "PASS";
+        } else {
+          return `FAIL: args=${JSON.stringify(actualArgs)}`;
+        }
+      },
   },
 };

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

@@ -88,7 +88,7 @@ export class MockPMBase implements PM_Base {
 
   testArtiFactoryfileWriter(
     tLog: ITLog,
-    callback: (Promise: any) => void
+    callback: (promise: Promise<any>) => void
   ): any {
     return (fPath: string, value: string | Buffer | any) => {
       this.trackCall("testArtiFactoryfileWriter", { fPath, value });

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

@@ -84,6 +84,17 @@ export const specification: ITestSpecification<I, O> = (
       ],
       "special chars test"
     ),
+    testsJsonTest: Given.SomeBaseString(
+      ["butThenProxy should handle tests.json correctly"],
+      [],
+      [
+        Then.theButTheProxyReturns(
+          "writeFileSync",
+          "test/path/butThen/tests.json"
+        ),
+      ],
+      "tests.json test"
+    ),
   }),
 
   Suite.Default("Proxy Type Coverage", {

package/src/lib/pmProxy.ts

@@ -36,11 +36,19 @@ const baseProxy: IProxyBase = function (
         const arger = mapping[1];
 
         if (prop === method) {
-          return (...x) => (target[prop] as any)(arger(...x));
+          return (...x) => {
+            // Add debug logging
+
+            const modifiedArgs = arger(...x);
+
+            return (target[prop] as any)(...modifiedArgs);
+          };
         }
       }
 
-      return (...x) => target[prop](...x);
+      return (...x) => {
+        return target[prop](...x);
+      };
     },
   });
 };
@@ -89,10 +97,28 @@ export const butThenProxy: IProxy = (
     ],
     [
       "writeFileSync",
-      (fp, contents) => {
+      (fp, contents, testName) => {
+        console.log(
+          `[DEBUG] butThenProxy writeFileSync: fp="${fp}" (type: ${typeof fp}), contents="${contents}" (type: ${typeof contents}), testName="${testName}" (type: ${typeof testName})`
+        );
+        // Check if fp is being treated as individual characters
+        if (typeof fp !== "string") {
+          console.log(`[ERROR] fp is not a string:`, fp);
+          // If fp is not a string, try to handle it
+          if (Array.isArray(fp)) {
+            // If it's an array, join it back into a string
+            fp = fp.join("");
+            console.log(`[DEBUG] Converted array to string: "${fp}"`);
+          } else {
+            // For other cases, convert to string
+            fp = String(fp);
+            console.log(`[DEBUG] Converted to string: "${fp}"`);
+          }
+        }
         const path = `${filepath}/butThen/${fp}`;
+        console.log(`[DEBUG] Generated path: "${path}"`);
         addArtifact(path);
-        return [path, contents];
+        return [path, contents, testName];
       },
     ],
     [
@@ -144,10 +170,10 @@ export const andWhenProxy: IProxy = (
 
     [
       "writeFileSync",
-      (fp, contents) => {
+      (fp, contents, testName) => {
         const path = `${filepath}/andWhen/${fp}`;
         addArtifact(path);
-        return [path, contents];
+        return [path, contents, testName];
       },
     ],
 
@@ -201,10 +227,10 @@ export const afterEachProxy: IProxyAfterEach = (
     ],
     [
       "writeFileSync",
-      (fp, contents) => {
+      (fp, contents, testName) => {
         const path = `suite-${suite}/given-${given}/afterEach/${fp}`;
         addArtifact(path);
-        return [path, contents];
+        return [path, contents, testName];
       },
     ],
 
@@ -250,10 +276,10 @@ export const beforeEachProxy: IProxyBeforeEach = (
 
     [
       "writeFileSync",
-      (fp, contents) => {
+      (fp, contents, testName) => {
         const path = `suite-${suite}/beforeEach/${fp}`;
         addArtifact(path);
-        return [path, contents];
+        return [path, contents, testName];
       },
     ],
 
@@ -291,11 +317,10 @@ export const beforeAllProxy: IProxy = (
   return baseProxy(pm, [
     [
       "writeFileSync",
-      (fp, contents) => {
+      (fp, contents, testName) => {
         const path = `suite-${suite}/beforeAll/${fp}`;
         addArtifact(path);
-
-        return [path, contents];
+        return [path, contents, testName];
       },
     ],
 
@@ -342,10 +367,10 @@ export const afterAllProxy: IProxy = (
 
     [
       "writeFileSync",
-      (fp, contents) => {
+      (fp, contents, testName) => {
         const path = `suite-${suite}/afterAll/${fp}`;
         addArtifact(path);
-        return [path, contents];
+        return [path, contents, testName];
       },
     ],
 

package/src/lib/types.ts

@@ -6,9 +6,11 @@ import type { Ibdd_in_any, Ibdd_out_any } from "../CoreTypes";
 import { PM_Node } from "../PM/node";
 import { PM_Pure } from "../PM/pure";
 import { PM_Web } from "../PM/web";
+import { IGivens, BaseGiven } from "./BaseGiven";
 
-import { IGivens, BaseGiven, BaseWhen, BaseThen } from "./abstractBase";
 import { BaseSuite } from "./BaseSuite";
+import { BaseThen } from "./BaseThen";
+import { BaseWhen } from "./BaseWhen";
 
 export type IPM = PM_Node | PM_Web | PM_Pure;
 

package/src/run.ts

@@ -25,18 +25,33 @@ if (mode !== "once" && mode !== "dev") {
   process.exit(-1);
 }
 
-import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
-  const bigConfig: IProject = module.default;
+const f = process.cwd() + "/" + "testeranto.config.ts";
+
+console.log("config file:", f);
+
+import(f).then(async (module) => {
+  const bigConfig: IProject = module.default || module;
 
   const rawConfig: ITestconfig = bigConfig.projects[projectName];
 
+  if (!rawConfig) {
+    console.error(`Project "${projectName}" does not exist in the configuration.`);
+    console.error("Available projects:", Object.keys(bigConfig.projects));
+    process.exit(-1);
+  }
+
+  if (!rawConfig.tests) {
+    console.error(projectName, "appears to have no tests: ", f);
+    console.error(`here is the config:`);
+    console.log(JSON.stringify(rawConfig));
+    process.exit(-1);
+  }
+
   const config: IBuiltConfig = {
     ...rawConfig,
     buildDir: process.cwd() + "/" + `testeranto/${projectName}.json`,
   };
 
-  if (!config.tests) throw "config has no tests?";
-
   const pm = new PM_Main(config, projectName, mode);
   pm.start();