testeranto 0.140.1 → 0.143.0

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

@@ -0,0 +1,136 @@
+import { Browser } from "puppeteer-core";
+
+import { IBuiltConfig, ITLog } from "../index";
+import { PM_Base } from "../../PM/base";
+
+export class MockPMBase implements PM_Base {
+  browser: Browser;
+  configs: IBuiltConfig;
+  calls: Record<string, any[]> = {};
+  testResourceConfiguration: any = {};
+
+  constructor(configs?: IBuiltConfig) {
+    this.configs = configs || ({} as IBuiltConfig);
+  }
+
+  // Common tracking functionality
+  protected trackCall(method: string, args: any) {
+    if (!this.calls[method]) {
+      this.calls[method] = [];
+    }
+    this.calls[method].push(args);
+  }
+
+  getCallCount(method: string): number {
+    return this.calls[method]?.length || 0;
+  }
+
+  getLastCall(method: string): any {
+    const calls = this.calls[method];
+    return calls ? calls[calls.length - 1] : null;
+  }
+
+  // Minimal implementations of required methods
+  launchSideCar(n: number, testName: string, projectName: string) {
+    this.trackCall("launchSideCar", { n, testName, projectName });
+    return Promise.resolve();
+  }
+
+  end(uid: number): Promise<boolean> {
+    this.trackCall("end", { uid });
+    return Promise.resolve(true);
+  }
+
+  writeFileSync(
+    path: string,
+    content: string,
+    testName?: string
+  ): Promise<boolean> {
+    this.trackCall("writeFileSync", { path, content, testName });
+    return Promise.resolve(true);
+  }
+
+  createWriteStream(path: string, testName?: string): Promise<number> {
+    this.trackCall("createWriteStream", { path, testName });
+    return Promise.resolve(0);
+  }
+
+  screencast(opts: any, testName: string, page?: any): Promise<any> {
+    this.trackCall("screencast", { opts, testName, page });
+    return Promise.resolve({});
+  }
+
+  customScreenShot(opts: any, testName: string, pageUid?: any): Promise<any> {
+    this.trackCall("customScreenShot", { opts, testName, pageUid });
+    return Promise.resolve({});
+  }
+
+  testArtiFactoryfileWriter(
+    tLog: ITLog,
+    callback: (Promise: any) => void
+  ): any {
+    return (fPath: string, value: string | Buffer | any) => {
+      this.trackCall("testArtiFactoryfileWriter", { fPath, value });
+      callback(Promise.resolve());
+    };
+  }
+
+  // Other required PM_Base methods with minimal implementations
+  closePage(p: any): any {
+    return Promise.resolve();
+  }
+  $(selector: string, p: string): Promise<any> {
+    return Promise.resolve();
+  }
+  click(selector: string, page: any): any {
+    return Promise.resolve();
+  }
+  goto(p: string, url: string): any {
+    return Promise.resolve();
+  }
+  newPage(): Promise<string> {
+    return Promise.resolve("mock-page");
+  }
+  pages(): Promise<string[]> {
+    return Promise.resolve(["mock-page"]);
+  }
+  waitForSelector(p: string, s: string): any {
+    return Promise.resolve(true);
+  }
+  focusOn(selector: string, p: string): any {
+    return Promise.resolve();
+  }
+  typeInto(value: string, p: string): any {
+    return Promise.resolve();
+  }
+  getAttribute(selector: string, attribute: string, p: string): any {
+    return Promise.resolve();
+  }
+  getInnerHtml(selector: string, p: string): Promise<any> {
+    return Promise.resolve();
+  }
+  isDisabled(selector: string, p: string): any {
+    return Promise.resolve(false);
+  }
+  screencastStop(s: string): any {
+    return Promise.resolve();
+  }
+  existsSync(destFolder: string): boolean {
+    return false;
+  }
+  mkdirSync(fp: string): any {
+    return Promise.resolve();
+  }
+  write(uid: number, contents: string): Promise<boolean> {
+    return Promise.resolve(true);
+  }
+  page(p: any): string | undefined {
+    return "mock-page";
+  }
+  doInPage(p: string, cb: (p: any) => unknown): any {
+    return Promise.resolve();
+  }
+  customclose(): any {
+    return Promise.resolve();
+  }
+}

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

@@ -0,0 +1,123 @@
+import { I, O } from "./types";
+import { ITestSpecification } from "../../CoreTypes";
+
+export const specification: ITestSpecification<I, O> = (
+  Suite,
+  Given,
+  When,
+  Then,
+  Check
+) => [
+  Suite.Default("PM Proxy Functionality", {
+    // Basic path rewriting tests
+    writeFileProxyTest: Given.SomeBaseString(
+      ["butThenProxy should rewrite writeFileSync paths"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/test.txt")],
+      "writeFileSync test"
+    ),
+    createWriteStreamProxyTest: Given.SomeBaseString(
+      ["butThenProxy should rewrite createWriteStream paths"],
+      [],
+      [Then.theButTheProxyReturns("createWriteStream", "test/path/butThen/stream.txt")],
+      "createWriteStream test"
+    ),
+    screencastProxyTest: Given.SomeBaseString(
+      ["butThenProxy should rewrite screencast paths"],
+      [],
+      [Then.theButTheProxyReturns("screencast", "test/path/butThen/screen.png")],
+      "screencast test"
+    ),
+    customScreenShotProxyTest: Given.SomeBaseString(
+      ["butThenProxy should rewrite customScreenShot paths"],
+      [],
+      [Then.theButTheProxyReturns("customScreenShot", "test/path/butThen/shot.png")],
+      "customScreenShot test"
+    ),
+
+    // Edge cases
+    emptyPathTest: Given.SomeBaseString(
+      ["butThenProxy should handle empty paths"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/")],
+      "empty path test"
+    ),
+    nestedPathTest: Given.SomeBaseString(
+      ["butThenProxy should handle nested paths"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/nested/folder/test.txt")],
+      "nested path test"
+    ),
+    specialCharsTest: Given.SomeBaseString(
+      ["butThenProxy should handle special characters in paths"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/file with spaces.txt")],
+      "special chars test"
+    ),
+  }),
+
+  Suite.Default("Proxy Type Coverage", {
+    // Test all proxy types
+    butThenProxyTest: Given.SomeBaseString(
+      ["butThenProxy should work correctly"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/test.txt")],
+      "butThenProxy test"
+    ),
+    andWhenProxyTest: Given.SomeBaseString(
+      ["andWhenProxy should work correctly"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "test/path/andWhen/test.txt")],
+      "andWhenProxy test"
+    ),
+    beforeEachProxyTest: Given.SomeBaseString(
+      ["beforeEachProxy should work correctly"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "suite-1/beforeEach/test.txt")],
+      "beforeEachProxy test"
+    ),
+    afterEachProxyTest: Given.SomeBaseString(
+      ["afterEachProxy should work correctly"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "suite-1/given-1/afterEach/test.txt")],
+      "afterEachProxy test"
+    ),
+  }),
+
+  Suite.Default("Content Preservation", {
+    // Verify content is preserved
+    contentPreservationTest: Given.SomeBaseString(
+      ["Proxies should preserve file content"],
+      [],
+      [
+        Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/test.txt"),
+        Then.verifyContent("test content")
+      ],
+      "content preservation test"
+    ),
+    objectContentTest: Given.SomeBaseString(
+      ["Proxies should preserve object content"],
+      [],
+      [
+        Then.theButTheProxyReturns("screencast", "test/path/butThen/screen.png"),
+        Then.verifyContent({quality: 80, fullPage: true})
+      ],
+      "object content test"
+    ),
+  }),
+
+  Suite.Default("Error Cases", {
+    invalidPathTest: Given.SomeBaseString(
+      ["Proxies should handle invalid paths"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/../invalid.txt")],
+      "invalid path test"
+    ),
+    undefinedInputTest: Given.SomeBaseString(
+      ["Proxies should handle undefined inputs"],
+      [],
+      [Then.theButTheProxyReturns("writeFileSync", undefined)],
+      "undefined input test"
+    ),
+  }),
+];

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

@@ -0,0 +1,45 @@
+import { ITestProxies } from ".";
+import { Ibdd_in, Ibdd_out } from "../../CoreTypes";
+
+import { IProxiedFunctions, IProxy } from "../pmProxy";
+import { IPM } from "../types";
+
+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],
+  (
+    ...args: any[]
+  ) => (proxies: { butThenProxy: IProxy }) => { butThenProxy: IProxy },
+  [IPM, "string"]
+>;
+
+export type O = Ibdd_out<
+  { Default: [string] },
+  { SomeBaseString: [string] },
+  {}, // No Whens for pure functions
+  {
+    theButTheProxyReturns: [IProxiedFunctions, string];
+  },
+  { Default: [] }
+>;
+
+export type M = {
+  givens: {
+    [K in keyof O["givens"]]: (...Iw: O["givens"][K]) => string;
+  };
+  // whens: {
+  //   [K in keyof O["whens"]]: (
+  //     ...Iw: O["whens"][K]
+  //   ) => (rectangle: Rectangle, utils: PM) => Rectangle;
+  // };
+  // thens: {
+  //   [K in keyof O["thens"]]: (
+  //     ...Iw: O["thens"][K]
+  //   ) => (rectangle: Rectangle, utils: PM) => Rectangle;
+  // };
+};

package/src/lib/pmProxy.ts

@@ -1,8 +1,27 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
+
 import { IPM } from "./types";
 
-const prxy = function (pm: IPM, mappings: [string, (...x) => any][]) {
+export type IProxyBase = (
+  pm: IPM,
+  mappings: [string, (...x: any) => any][]
+) => IPM;
+
+export type IProxy = (pm: IPM, filepath: string) => IPM;
+export type IProxyAfterEach = (pm: IPM, suite: string, given: string) => IPM;
+export type IProxyBeforeEach = (pm: IPM, suite: string) => IPM;
+
+export type IProxiedFunctions =
+  | "screencast"
+  | "createWriteStream"
+  | "writeFileSync"
+  | "customScreenShot";
+
+const baseProxy: IProxyBase = function (
+  pm: IPM,
+  mappings: [IProxiedFunctions, (...x) => any][]
+) {
   return new Proxy(pm, {
     get: (target, prop, receiver) => {
       for (const mapping of mappings) {
@@ -10,7 +29,7 @@ const prxy = function (pm: IPM, mappings: [string, (...x) => any][]) {
         const arger = mapping[1];
 
         if (prop === method) {
-          return (...x) => target[prop](arger(...x));
+          return (...x) => (target[prop] as any)(arger(...x));
         }
       }
 
@@ -19,8 +38,8 @@ const prxy = function (pm: IPM, mappings: [string, (...x) => any][]) {
   });
 };
 
-export const butThenProxy = (pm: IPM, filepath: string) =>
-  prxy(pm, [
+export const butThenProxy: IProxy = (pm: IPM, filepath: string) =>
+  baseProxy(pm, [
     [
       "screencast",
       (opts, p) => [
@@ -51,8 +70,8 @@ export const butThenProxy = (pm: IPM, filepath: string) =>
     ],
   ]);
 
-export const andWhenProxy = (pm: IPM, filepath: string) =>
-  prxy(pm, [
+export const andWhenProxy: IProxy = (pm: IPM, filepath: string) =>
+  baseProxy(pm, [
     [
       "screencast",
       (opts, p) => [
@@ -80,8 +99,12 @@ export const andWhenProxy = (pm: IPM, filepath: string) =>
     ],
   ]);
 
-export const afterEachProxy = (pm: IPM, suite: string, given: string): IPM =>
-  prxy(pm, [
+export const afterEachProxy: IProxyAfterEach = (
+  pm: IPM,
+  suite: string,
+  given: string
+): IPM =>
+  baseProxy(pm, [
     [
       "screencast",
       (opts, p) => [
@@ -114,8 +137,11 @@ export const afterEachProxy = (pm: IPM, suite: string, given: string): IPM =>
     ],
   ]);
 
-export const beforeEachProxy = (pm: IPM, suite: string): IPM =>
-  prxy(pm, [
+export const beforeEachProxy: IProxyBeforeEach = (
+  pm: IPM,
+  suite: string
+): IPM =>
+  baseProxy(pm, [
     [
       "screencast",
       (opts, p) => [
@@ -146,8 +172,8 @@ export const beforeEachProxy = (pm: IPM, suite: string): IPM =>
     ["createWriteStream", (fp) => [`suite-${suite}/beforeEach/${fp}`]],
   ]);
 
-export const beforeAllProxy = (pm: IPM, suite: string): IPM =>
-  prxy(pm, [
+export const beforeAllProxy: IProxy = (pm: IPM, suite: string): IPM =>
+  baseProxy(pm, [
     [
       "writeFileSync",
       (fp, contents) => [`suite-${suite}/beforeAll/${fp}`, contents],
@@ -167,8 +193,8 @@ export const beforeAllProxy = (pm: IPM, suite: string): IPM =>
     ["createWriteStream", (fp) => [`suite-${suite}/beforeAll/${fp}`]],
   ]);
 
-export const afterAllProxy = (pm: IPM, suite: string): IPM =>
-  prxy(pm, [
+export const afterAllProxy: IProxy = (pm: IPM, suite: string): IPM =>
+  baseProxy(pm, [
     ["createWriteStream", (fp) => [`suite-${suite}/afterAll/${fp}`]],
 
     [
@@ -187,182 +213,3 @@ export const afterAllProxy = (pm: IPM, suite: string): IPM =>
       ],
     ],
   ]);
-
-/////////////////////////////////////////////////
-
-// export const butThenProxy = (pm: IPM, filepath: string) => {
-//   return new Proxy(pm, {
-//     get: (target, prop, receiver) => {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               path: `${filepath}/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) => target[prop](`${filepath}/${fp}`, contents);
-//       }
-//     },
-//   });
-// };
-
-// export const andWhenProxy = (pm: IPM, filepath: string) => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               path: `${filepath}/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](`${filepath}/andWhen/${fp}`, contents);
-//       }
-
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };
-
-// export const afterEachProxy = (pm: IPM, suite: string, given: string): IPM => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               path: `suite-${suite}/given-${given}/afterEach/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](
-//             `suite-${suite}/given-${given}/afterEach/${fp}`,
-//             contents
-//           );
-//       }
-
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };
-
-// export const beforeAllProxy = (pm: IPM, suite: string): IPM => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               // path: `${filepath}/${opts.path}`,
-//               path: `suite-${suite}/beforeAll/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](`suite-${suite}/beforeAll/${fp}`, contents);
-//       }
-
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };
-
-// export const beforeEachProxy = (pm: IPM, suite: string, given: string): IPM => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       // if (prop === "write") {
-//       //   return (handle, contents) =>
-//       //     target[prop](
-//       //       `suite-${suiteNdx}/given-${key}/when/beforeEach/${fp}`,
-//       //       contents
-//       //     );
-//       // }
-
-//       if (prop === "createWriteStream") {
-//         return (fp) =>
-//           target[prop](`suite-${suite}/given-${given}/when/beforeEach/${fp}`);
-//       }
-
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](
-//             `suite-${suite}/given-${given}/when/beforeEach/${fp}`,
-//             contents
-//           );
-//       }
-
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               path: `suite-${suite}/given-${given}/when/beforeEach/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-
-//       if (prop === "screencast") {
-//         return (opts, p) =>
-//           target.screencast(
-//             {
-//               ...opts,
-//               path: `suite-${suite}/given-${given}/when/beforeEach/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };
-
-// export const afterAllProxy = (pm: IPM, suite: string): IPM => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               // path: `${filepath}/${opts.path}`,
-//               path: `suite-${suite}/afterAll/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](`suite-${suite}/afterAll/${fp}`, contents);
-//       }
-
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };