testeranto 0.189.0 → 0.197.0

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

@@ -6,6 +6,7 @@ import { MockBaseBuilder } from "./baseBuilder.test.mock";
 import { I, O } from "./baseBuilder.test.types";
 import { ITestJob, ITTestResourceRequest } from "..";
 import { BaseBuilder } from "../basebuilder";
+import { IPM } from "../types";
 
 // Define our test subject type
 type TestSubject = MockBaseBuilder<any, any, any, any, any, any>;
@@ -16,7 +17,7 @@ export const implementation: ITestImplementation<I, O, {}> = {
   },
 
   givens: {
-    "the default BaseBuilder": () => {
+    "the default BaseBuilder": () => () => {
       return new MockBaseBuilder(
         {}, // input
         {}, // suitesOverrides
@@ -27,7 +28,7 @@ export const implementation: ITestImplementation<I, O, {}> = {
         () => [] // testSpecification
       );
     },
-    "a BaseBuilder with TestInput": (input: any) => {
+    "a BaseBuilder with TestInput": (input: any) => () => {
       return new MockBaseBuilder(
         input,
         {},
@@ -40,24 +41,24 @@ export const implementation: ITestImplementation<I, O, {}> = {
     },
     "a BaseBuilder with Test Resource Requirements": (
       requirements: ITTestResourceRequest
-    ) => {
+    ) => () => {
       return new MockBaseBuilder({}, {}, {}, {}, {}, requirements, () => []);
     },
   },
 
   whens: {
-    addArtifact: (artifact: Promise<any>) => (builder: TestSubject) => {
+    addArtifact: (artifact: Promise<any>) => (builder: TestSubject, utils: IPM) => {
       builder.artifacts.push(artifact);
       return builder;
     },
-    setTestJobs: (jobs: ITestJob[]) => (builder: TestSubject) => {
+    setTestJobs: (jobs: ITestJob[]) => (builder: TestSubject, utils: IPM) => {
       builder.testJobs = jobs;
       return builder;
     },
   },
 
   thens: {
-    "it is initialized": () => (builder, utils) => {
+    "it is initialized": () => (builder: TestSubject, utils: IPM) => {
       utils.writeFileSync("hello.txt", "world");
 
       if (!(builder instanceof BaseBuilder)) {
@@ -84,19 +85,19 @@ export const implementation: ITestImplementation<I, O, {}> = {
 
       return builder;
     },
-    "it generates TestSpecifications": () => (builder: TestSubject) => {
+    "it generates TestSpecifications": () => (builder: TestSubject, utils: IPM) => {
       if (!Array.isArray(builder.specs)) {
         throw new Error("Specs were not generated");
       }
       return builder;
     },
-    "it creates jobs": () => (builder: TestSubject) => {
+    "it creates jobs": () => (builder: TestSubject, utils: IPM) => {
       if (!Array.isArray(builder.testJobs)) {
         throw new Error("Test jobs were not created");
       }
       return builder;
     },
-    "it tracks artifacts": () => (builder: TestSubject, utils) => {
+    "it tracks artifacts": () => (builder: TestSubject, utils: IPM) => {
       if (!Array.isArray(builder.artifacts)) {
         throw new Error("Artifacts array not initialized");
       }
@@ -104,31 +105,31 @@ export const implementation: ITestImplementation<I, O, {}> = {
       utils.writeFileSync("artifact_test.txt", "test");
       return builder;
     },
-    resourceRequirementsSet: () => (builder: TestSubject) => {
+    resourceRequirementsSet: () => (builder: TestSubject, utils: IPM) => {
       if (!builder.testResourceRequirement) {
         throw new Error("Resource requirements not set");
       }
       return builder;
     },
-    suitesOverridesConfigured: () => (builder: TestSubject) => {
+    suitesOverridesConfigured: () => (builder: TestSubject, utils: IPM) => {
       if (!builder.suitesOverrides) {
         throw new Error("Suites overrides not configured");
       }
       return builder;
     },
-    givensOverridesConfigured: () => (builder: TestSubject) => {
+    givensOverridesConfigured: () => (builder: TestSubject, utils: IPM) => {
       if (!builder.givenOverides) {
         throw new Error("Givens overrides not configured");
       }
       return builder;
     },
-    whensOverridesConfigured: () => (builder: TestSubject) => {
+    whensOverridesConfigured: () => (builder: TestSubject, utils: IPM) => {
       if (!builder.whenOverides) {
         throw new Error("Whens overrides not configured");
       }
       return builder;
     },
-    thensOverridesConfigured: () => (builder: TestSubject) => {
+    thensOverridesConfigured: () => (builder: TestSubject, utils: IPM) => {
       if (!builder.thenOverides) {
         throw new Error("Thens overrides not configured");
       }

package/src/lib/basebuilder.ts

@@ -34,7 +34,7 @@ export abstract class BaseBuilder<
 > {
   specs: any;
 
-  assertThis: (t: I["then"]) => {};
+  assertThis: (t: I["then"]) => any;
 
   testResourceRequirement: ITTestResourceRequest;
   artifacts: Promise<unknown>[] = [];
@@ -111,7 +111,6 @@ export abstract class BaseBuilder<
         receiveTestResourceConfig: async function (
           puppetMaster: IPM
         ): Promise<IFinalResults> {
-          // deprecated?
           const tLog = async (...l: string[]) => {
             //
           };
@@ -119,10 +118,11 @@ export abstract class BaseBuilder<
           try {
             const suiteDone: BaseSuite<I, O> = await runner(puppetMaster, tLog);
             const fails = suiteDone.fails;
-            await puppetMaster.writeFileSync([
+            await puppetMaster.writeFileSync(
               `tests.json`,
               JSON.stringify(this.toObj(), null, 2),
-            ]);
+              "test"
+            );
 
             return {
               failed: fails > 0,
@@ -139,11 +139,6 @@ export abstract class BaseBuilder<
               features: [],
             };
           }
-
-          // const logPromise = new Promise(async (res) => {
-          //   await puppetMaster.end(access);
-          //   res(true);
-          // });
         },
       };
     });

package/src/lib/classBuilder.ts

@@ -82,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)
           );
         };
@@ -94,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.ts

@@ -42,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,
@@ -64,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,
 
@@ -107,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

@@ -13,23 +13,27 @@ 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"],
@@ -37,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 = {
@@ -84,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

@@ -48,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);
+    }
   },
 };

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", {