testeranto 0.140.2 → 0.146.0

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);
-//     },
-//   });
-// };

package/src/run.ts

@@ -7,7 +7,9 @@ import { ITestconfig, IBuiltConfig, IProject } from "./Types";
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
 
-console.log(ansiC.inverse("Press 'x' to shutdown forcefully."));
+console.log(ansiC.inverse("Press 'q' to initiate a graceful shutdown."));
+console.log(ansiC.inverse("Press 'x' to quit forcefully."));
+
 process.stdin.on("keypress", (str, key) => {
   if (key.name === "x") {
     console.log(ansiC.inverse("Shutting down forcefully..."));
@@ -15,7 +17,7 @@ process.stdin.on("keypress", (str, key) => {
   }
 });
 
-const testName = process.argv[2];
+const projectName = process.argv[2];
 
 const mode = process.argv[3] as "once" | "dev";
 if (mode !== "once" && mode !== "dev") {
@@ -23,19 +25,17 @@ if (mode !== "once" && mode !== "dev") {
   process.exit(-1);
 }
 
-console.log("testeranto is running", testName, mode);
-
 import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
   const bigConfig: IProject = module.default;
 
-  const rawConfig: ITestconfig = bigConfig.projects[testName];
+  const rawConfig: ITestconfig = bigConfig.projects[projectName];
 
   const config: IBuiltConfig = {
     ...rawConfig,
-    buildDir: process.cwd() + "/" + `testeranto/${testName}.json`,
+    buildDir: process.cwd() + "/" + `testeranto/${projectName}.json`,
   };
 
-  const pm = new PM_Main(config, testName, mode);
+  const pm = new PM_Main(config, projectName, mode);
   pm.start();
 
   process.stdin.on("keypress", (str, key) => {

package/testeranto/bundles/node/allTests/chunk-NQBTLMSG.mjs

@@ -0,0 +1,254 @@
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+import {
+  PM,
+  TesterantoCore,
+  defaultTestResourceRequirement
+} from "./chunk-RF3LIUSG.mjs";
+
+// src/PM/node.ts
+import net from "net";
+import fs from "fs";
+import path from "path";
+var fPaths = [];
+var PM_Node = class extends PM {
+  constructor(t, ipcFile) {
+    super();
+    this.testResourceConfiguration = t;
+    this.client = net.createConnection(ipcFile, () => {
+      return;
+    });
+  }
+  start() {
+    throw new Error("DEPRECATED");
+  }
+  stop() {
+    throw new Error("stop not implemented.");
+  }
+  send(command, ...argz) {
+    const key = Math.random().toString();
+    if (!this.client) {
+      console.error(
+        `Tried to send "${command} (${argz})" but the test has not been started and the IPC client is not established. Exiting as failure!`
+      );
+      process.exit(-1);
+    }
+    return new Promise((res) => {
+      const myListener = (event) => {
+        const x = JSON.parse(event);
+        if (x.key === key) {
+          process.removeListener("message", myListener);
+          res(x.payload);
+        }
+      };
+      process.addListener("message", myListener);
+      this.client.write(JSON.stringify([command, ...argz, key]));
+    });
+  }
+  async launchSideCar(n) {
+    return this.send(
+      "launchSideCar",
+      n,
+      this.testResourceConfiguration.name
+    );
+  }
+  stopSideCar(n) {
+    return this.send(
+      "stopSideCar",
+      n,
+      this.testResourceConfiguration.name
+    );
+  }
+  async pages() {
+    return this.send("pages", ...arguments);
+  }
+  waitForSelector(p, s) {
+    return this.send("waitForSelector", ...arguments);
+  }
+  closePage(p) {
+    return this.send("closePage", ...arguments);
+  }
+  goto(page, url) {
+    return this.send("goto", ...arguments);
+  }
+  async newPage() {
+    return this.send("newPage");
+  }
+  $(selector, page) {
+    return this.send("$", ...arguments);
+  }
+  isDisabled(selector) {
+    return this.send("isDisabled", ...arguments);
+  }
+  getAttribute(selector, attribute, p) {
+    return this.send("getAttribute", ...arguments);
+  }
+  getInnerHtml(selector, p) {
+    return this.send("getInnerHtml", ...arguments);
+  }
+  // setValue(selector: string) {
+  //   return this.send("getValue", ...arguments);
+  // }
+  focusOn(selector) {
+    return this.send("focusOn", ...arguments);
+  }
+  typeInto(selector) {
+    return this.send("typeInto", ...arguments);
+  }
+  page() {
+    return this.send("page");
+  }
+  click(selector) {
+    return this.send("click", ...arguments);
+  }
+  screencast(opts, page) {
+    return this.send(
+      "screencast",
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path
+      },
+      page,
+      this.testResourceConfiguration.name
+    );
+  }
+  screencastStop(p) {
+    return this.send("screencastStop", ...arguments);
+  }
+  customScreenShot(x, y) {
+    const opts = x[0];
+    const page = x[1];
+    return this.send(
+      "customScreenShot",
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path
+      },
+      this.testResourceConfiguration.name,
+      page
+    );
+  }
+  async existsSync(destFolder) {
+    return await this.send(
+      "existsSync",
+      this.testResourceConfiguration.fs + "/" + destFolder
+    );
+  }
+  mkdirSync() {
+    return this.send("mkdirSync", this.testResourceConfiguration.fs + "/");
+  }
+  async write(uid, contents) {
+    return await this.send("write", ...arguments);
+  }
+  async writeFileSync(filepath, contents) {
+    return await this.send(
+      "writeFileSync",
+      this.testResourceConfiguration.fs + "/" + filepath,
+      contents,
+      this.testResourceConfiguration.name
+    );
+  }
+  async createWriteStream(filepath) {
+    return await this.send(
+      "createWriteStream",
+      this.testResourceConfiguration.fs + "/" + filepath,
+      this.testResourceConfiguration.name
+    );
+  }
+  async end(uid) {
+    return await this.send("end", ...arguments);
+  }
+  async customclose() {
+    return await this.send(
+      "customclose",
+      this.testResourceConfiguration.fs,
+      this.testResourceConfiguration.name
+    );
+  }
+  testArtiFactoryfileWriter(tLog, callback) {
+    return (fPath, value) => {
+      callback(
+        new Promise((res, rej) => {
+          tLog("testArtiFactory =>", fPath);
+          const cleanPath = path.resolve(fPath);
+          fPaths.push(cleanPath.replace(process.cwd(), ``));
+          const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+          fs.mkdir(targetDir, { recursive: true }, async (error) => {
+            if (error) {
+              console.error(`\u2757\uFE0FtestArtiFactory failed`, targetDir, error);
+            }
+            if (Buffer.isBuffer(value)) {
+              fs.writeFileSync(fPath, value, "binary");
+              res();
+            } else if (`string` === typeof value) {
+              fs.writeFileSync(fPath, value.toString(), {
+                encoding: "utf-8"
+              });
+              res();
+            } else {
+              const pipeStream = value;
+              const myFile = fs.createWriteStream(fPath);
+              pipeStream.pipe(myFile);
+              pipeStream.on("close", () => {
+                myFile.close();
+                res();
+              });
+            }
+          });
+        })
+      );
+    };
+  }
+  // launch(options?: PuppeteerLaunchOptions): Promise<Browser>;
+  startPuppeteer(options) {
+  }
+};
+
+// src/Node.ts
+var ipcfile;
+console.log("mark4");
+var NodeTesteranto = class extends TesterantoCore {
+  constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
+    super(
+      input,
+      testSpecification,
+      testImplementation,
+      testResourceRequirement,
+      testInterface,
+      () => {
+      }
+    );
+  }
+  async receiveTestResourceConfig(partialTestResource) {
+    console.log("receiveTestResourceConfig", partialTestResource);
+    const t = JSON.parse(partialTestResource);
+    const pm = new PM_Node(t, ipcfile);
+    return await this.testJobs[0].receiveTestResourceConfig(pm);
+  }
+};
+var testeranto = async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {
+  try {
+    const t = new NodeTesteranto(
+      input,
+      testSpecification,
+      testImplementation,
+      testResourceRequirement,
+      testInterface
+    );
+    console.log("args", process.argv);
+    process.on("unhandledRejection", (reason, promise) => {
+      console.error("Unhandled Rejection at:", promise, "reason:", reason);
+    });
+    ipcfile = process.argv[3];
+    const f = await t.receiveTestResourceConfig(process.argv[2]);
+    console.error("goodbye node with failures", f.fails);
+    process.exit(f.fails);
+  } catch (e) {
+    console.error("goodbye node with caught error", e);
+    process.exit(-1);
+  }
+};
+var Node_default = testeranto;
+
+export {
+  Node_default
+};