testeranto 0.129.0 → 0.134.0

package/src/PM/__tests__/nodeSidecar.testeranto.ts

@@ -0,0 +1,173 @@
+import net from "net";
+import { ITTestResourceConfiguration } from "../../lib";
+import { PM_Node_Sidecar } from "../nodeSidecar";
+import Testeranto from "../../Node";
+import {
+  Ibdd_out,
+  ITestSpecification,
+  IT,
+  ITestImplementation,
+  Ibdd_in,
+  IPartialNodeInterface,
+} from "../../Types";
+
+type I = Ibdd_in<
+  PM_Node_Sidecar,
+  PM_Node_Sidecar,
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown
+>;
+
+type O = Ibdd_out<
+  {
+    SidecarInitialized: [null];
+  },
+  {
+    SidecarReady: [];
+  },
+  {
+    SendTestMessage: [string];
+    VerifyCleanup: [];
+  },
+  {
+    MessageReceived: [string];
+    ListenersCleaned: [];
+  },
+  {
+    SidecarState: unknown;
+  }
+>;
+
+const specification: ITestSpecification<IT, O> = (Suite, Given, When, Then) => {
+  return [
+    Suite.SidecarInitialized(
+      "Sidecar message passing works correctly",
+      {
+        basicSend: Given.SidecarReady(
+          ["can send and receive messages"],
+          [When.SendTestMessage("test-message")],
+          [Then.MessageReceived("test-message")]
+        ),
+        cleanup: Given.SidecarReady(
+          ["cleans up listeners after message"],
+          [When.VerifyCleanup()],
+          [Then.ListenersCleaned()]
+        ),
+      },
+      []
+    ),
+  ];
+};
+
+const implementation: ITestImplementation<I, O> = {
+  suites: { SidecarInitialized: (x) => x },
+  givens: {
+    SidecarReady: () => {
+      const config: ITTestResourceConfiguration = {
+        name: "test-sidecar",
+        fs: "/tmp",
+        ports: [3001],
+        browserWSEndpoint: "",
+      };
+      return new PM_Node_Sidecar(config);
+    },
+  },
+  whens: {
+    SendTestMessage: (message) => async (sidecar: PM_Node_Sidecar) => {
+      let callbackFn: Function;
+      const mockProcess = {
+        on: (event: string, callback: Function) => {
+          if (event === "message") {
+            callbackFn = callback;
+            callback(
+              JSON.stringify({
+                key: "mock-key", 
+                payload: message,
+              })
+            );
+          }
+          return mockProcess;
+        },
+        addListener: () => mockProcess,
+        removeListener: () => mockProcess
+      } as unknown as NodeJS.Process;
+      
+      process = mockProcess;
+
+      let writeCalled = false;
+      sidecar.client.write = (data: string) => {
+        writeCalled = true;
+        return true;
+      };
+
+      await sidecar.send("test-command", message);
+      return { writeCalled, callbackFn };
+    },
+    VerifyCleanup: () => async (sidecar: PM_Node_Sidecar) => {
+      let addListenerCalled = false;
+      let removeListenerCalled = false;
+
+      const mockProcess = {
+        addListener: () => {
+          addListenerCalled = true;
+          return mockProcess;
+        },
+        removeListener: () => {
+          removeListenerCalled = true;
+          return mockProcess;
+        }
+      } as unknown as NodeJS.Process;
+      process = mockProcess;
+
+      await sidecar.send("test-command", "test");
+      return { addListenerCalled, removeListenerCalled };
+    },
+  },
+  thens: {
+    MessageReceived: (expected) => (actual) => {
+      if (actual !== expected) {
+        throw new Error(`Expected "${expected}" but got "${actual}"`);
+      }
+      return actual;
+    },
+    ListenersCleaned:
+      () =>
+      (result, { removeListenerCalled }) => {
+        if (!removeListenerCalled) {
+          throw new Error("Expected removeListener to be called");
+        }
+        return result;
+      },
+  },
+  checks: { SidecarState: () => "unknown" },
+};
+
+const testInterface: IPartialNodeInterface<I> = {
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    const sidecar = initializer();
+    sidecar.client = {
+      write: () => true,
+      end: () => {},
+      on: () => {},
+    } as unknown as net.Socket;
+    return sidecar;
+  },
+  andWhen: async (store, whenCB, testResource, pm) => {
+    try {
+      await whenCB(store, testResource, pm);
+    } catch (e) {
+      console.error("Error in andWhen:", e);
+      throw e;
+    }
+  },
+};
+
+export default Testeranto(
+  () => new PM_Node_Sidecar({} as ITTestResourceConfiguration),
+  specification,
+  implementation,
+  testInterface
+);

package/src/PM/__tests__/pureSidecar.testeranto.ts

@@ -0,0 +1,157 @@
+import net from "net";
+import { ITTestResourceConfiguration } from "../../lib";
+import { PM_Pure_Sidecar } from "../pureSidecar";
+import Testeranto from "../../Node";
+import {
+  Ibdd_out,
+  ITestSpecification,
+  IT,
+  ITestImplementation,
+  Ibdd_in,
+  IPartialNodeInterface,
+} from "../../Types";
+
+type I = Ibdd_in<
+  PM_Pure_Sidecar,
+  PM_Pure_Sidecar,
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown
+>;
+
+type O = Ibdd_out<
+  {
+    SidecarInitialized: [null];
+  },
+  {
+    SidecarReady: [];
+  },
+  {
+    SendTestMessage: [string];
+    VerifyCleanup: [];
+  },
+  {
+    MessageReceived: [string];
+    ListenersCleaned: [];
+  },
+  {
+    SidecarState: unknown;
+  }
+>;
+
+const specification: ITestSpecification<IT, O> = (Suite, Given, When, Then) => {
+  return [
+    Suite.SidecarInitialized(
+      "Pure Sidecar message passing works correctly",
+      {
+        basicSend: Given.SidecarReady(
+          ["can send and receive messages"],
+          [When.SendTestMessage("test-message")],
+          [Then.MessageReceived("test-message")]
+        ),
+        cleanup: Given.SidecarReady(
+          ["cleans up listeners after message"],
+          [When.VerifyCleanup()],
+          [Then.ListenersCleaned()]
+        ),
+      },
+      []
+    ),
+  ];
+};
+
+const implementation: ITestImplementation<I, O> = {
+  suites: { SidecarInitialized: (x) => x },
+  givens: {
+    SidecarReady: () => {
+      const config: ITTestResourceConfiguration = {
+        name: "test-pure-sidecar",
+        fs: "/tmp",
+        ports: [3001],
+        browserWSEndpoint: "",
+      };
+      return new PM_Pure_Sidecar(config);
+    },
+  },
+  whens: {
+    SendTestMessage: (message) => async (sidecar: PM_Pure_Sidecar) => {
+      let callbackFn: Function;
+      process.on = (event: string, callback: Function) => {
+        if (event === "message") {
+          callbackFn = callback;
+          callback(
+            JSON.stringify({
+              key: "mock-key",
+              payload: message,
+            })
+          );
+        }
+      };
+
+      let writeCalled = false;
+      sidecar.client.write = (data: string) => {
+        writeCalled = true;
+        return true;
+      };
+
+      await sidecar.send("test-command", message);
+      return { writeCalled, callbackFn };
+    },
+    VerifyCleanup: () => async (sidecar: PM_Pure_Sidecar) => {
+      let addListenerCalled = false;
+      let removeListenerCalled = false;
+
+      process.addListener = () => (addListenerCalled = true);
+      process.removeListener = () => (removeListenerCalled = true);
+
+      await sidecar.send("test-command", "test");
+      return { addListenerCalled, removeListenerCalled };
+    },
+  },
+  thens: {
+    MessageReceived: (expected) => (actual) => {
+      if (actual !== expected) {
+        throw new Error(`Expected "${expected}" but got "${actual}"`);
+      }
+      return actual;
+    },
+    ListenersCleaned:
+      () =>
+      (result, { removeListenerCalled }) => {
+        if (!removeListenerCalled) {
+          throw new Error("Expected removeListener to be called");
+        }
+        return result;
+      },
+  },
+  checks: { SidecarState: () => "unknown" },
+};
+
+const testInterface: IPartialNodeInterface<I> = {
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    const sidecar = initializer();
+    sidecar.client = {
+      write: () => true,
+      end: () => {},
+      on: () => {},
+    } as unknown as net.Socket;
+    return sidecar;
+  },
+  andWhen: async (store, whenCB, testResource, pm) => {
+    try {
+      await whenCB(store, testResource, pm);
+    } catch (e) {
+      console.error("Error in andWhen:", e);
+      throw e;
+    }
+  },
+};
+
+export default Testeranto(
+  () => new PM_Pure_Sidecar({} as ITTestResourceConfiguration),
+  specification,
+  implementation,
+  testInterface
+);

package/src/PM/__tests__/webSidecar.testeranto.ts

@@ -0,0 +1,157 @@
+import net from "net";
+import { ITTestResourceConfiguration } from "../../lib";
+import { PM_Web_Sidecar } from "../webSidecar";
+import Testeranto from "../../Node";
+import {
+  Ibdd_out,
+  ITestSpecification,
+  IT,
+  ITestImplementation,
+  Ibdd_in,
+  IPartialNodeInterface,
+} from "../../Types";
+
+type I = Ibdd_in<
+  PM_Web_Sidecar,
+  PM_Web_Sidecar,
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown
+>;
+
+type O = Ibdd_out<
+  {
+    SidecarInitialized: [null];
+  },
+  {
+    SidecarReady: [];
+  },
+  {
+    SendTestMessage: [string];
+    VerifyCleanup: [];
+  },
+  {
+    MessageReceived: [string];
+    ListenersCleaned: [];
+  },
+  {
+    SidecarState: unknown;
+  }
+>;
+
+const specification: ITestSpecification<IT, O> = (Suite, Given, When, Then) => {
+  return [
+    Suite.SidecarInitialized(
+      "Web Sidecar message passing works correctly",
+      {
+        basicSend: Given.SidecarReady(
+          ["can send and receive messages"],
+          [When.SendTestMessage("test-message")],
+          [Then.MessageReceived("test-message")]
+        ),
+        cleanup: Given.SidecarReady(
+          ["cleans up listeners after message"],
+          [When.VerifyCleanup()],
+          [Then.ListenersCleaned()]
+        ),
+      },
+      []
+    ),
+  ];
+};
+
+const implementation: ITestImplementation<I, O> = {
+  suites: { SidecarInitialized: (x) => x },
+  givens: {
+    SidecarReady: () => {
+      const config: ITTestResourceConfiguration = {
+        name: "test-web-sidecar",
+        fs: "/tmp",
+        ports: [3001],
+        browserWSEndpoint: "",
+      };
+      return new PM_Web_Sidecar(config);
+    },
+  },
+  whens: {
+    SendTestMessage: (message) => async (sidecar: PM_Web_Sidecar) => {
+      let callbackFn: Function;
+      process.on = (event: string, callback: Function) => {
+        if (event === "message") {
+          callbackFn = callback;
+          callback(
+            JSON.stringify({
+              key: "mock-key",
+              payload: message,
+            })
+          );
+        }
+      };
+
+      let writeCalled = false;
+      sidecar.client.write = (data: string) => {
+        writeCalled = true;
+        return true;
+      };
+
+      await sidecar.send("test-command", message);
+      return { writeCalled, callbackFn };
+    },
+    VerifyCleanup: () => async (sidecar: PM_Web_Sidecar) => {
+      let addListenerCalled = false;
+      let removeListenerCalled = false;
+
+      process.addListener = () => (addListenerCalled = true);
+      process.removeListener = () => (removeListenerCalled = true);
+
+      await sidecar.send("test-command", "test");
+      return { addListenerCalled, removeListenerCalled };
+    },
+  },
+  thens: {
+    MessageReceived: (expected) => (actual) => {
+      if (actual !== expected) {
+        throw new Error(`Expected "${expected}" but got "${actual}"`);
+      }
+      return actual;
+    },
+    ListenersCleaned:
+      () =>
+      (result, { removeListenerCalled }) => {
+        if (!removeListenerCalled) {
+          throw new Error("Expected removeListener to be called");
+        }
+        return result;
+      },
+  },
+  checks: { SidecarState: () => "unknown" },
+};
+
+const testInterface: IPartialNodeInterface<I> = {
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    const sidecar = initializer();
+    sidecar.client = {
+      write: () => true,
+      end: () => {},
+      on: () => {},
+    } as unknown as net.Socket;
+    return sidecar;
+  },
+  andWhen: async (store, whenCB, testResource, pm) => {
+    try {
+      await whenCB(store, testResource, pm);
+    } catch (e) {
+      console.error("Error in andWhen:", e);
+      throw e;
+    }
+  },
+};
+
+export default Testeranto(
+  () => new PM_Web_Sidecar({} as ITTestResourceConfiguration),
+  specification,
+  implementation,
+  testInterface
+);

package/src/PM/base.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import fs from "fs";
 import path from "path";
 import {
@@ -26,8 +28,10 @@ export abstract class PM_Base {
     this.configs = configs;
   }
 
+  abstract launchSideCar(n: number, testName: string, projectName: string);
+
   customclose() {
-    throw new Error("Method not implemented.");
+    throw new Error("customclose not implemented.");
   }
 
   waitForSelector(p: string, s: string): any {
@@ -54,8 +58,8 @@ export abstract class PM_Base {
     });
   }
 
-  newPage(): Promise<Page> {
-    return this.browser.newPage();
+  async newPage(): Promise<string> {
+    return (await this.browser.newPage()).mainFrame()._id;
   }
 
   goto(p, url: string): any {
@@ -69,12 +73,12 @@ export abstract class PM_Base {
     });
   }
 
-  $(selector: string, p: string): Promise<boolean> {
+  $(selector: string, p: string): Promise<any> {
     return new Promise((res) => {
       this.doInPage(p, async (page) => {
-        const x = page.$(selector);
-        const y = await x;
-        res(y !== null);
+        const x = await page.$(selector);
+        const y = await x?.jsonValue();
+        res(y);
       });
     });
   }
@@ -112,7 +116,7 @@ export abstract class PM_Base {
   async customScreenShot(
     ssOpts: ScreenshotOptions,
     testName: string,
-    page: Page
+    pageUid: any
   ) {
     const p = ssOpts.path as string;
     const dir = path.dirname(p);
@@ -124,6 +128,9 @@ export abstract class PM_Base {
     }
     files[testName].add(ssOpts.path as string);
 
+    const page = (await this.browser.pages()).find(
+      (p) => p.mainFrame()._id === pageUid
+    ) as Page;
     const sPromise = page.screenshot({
       ...ssOpts,
       path: p,
@@ -231,7 +238,6 @@ export abstract class PM_Base {
               });
               res();
             } else {
-              /* @ts-ignore:next-line */
               const pipeStream: PassThrough = value;
               const myFile = fs.createWriteStream(fPath);
               pipeStream.pipe(myFile);
@@ -253,8 +259,8 @@ export abstract class PM_Base {
     });
   }
 
-  page(): string | undefined {
-    throw new Error("Method not implemented.");
+  page(p): string | undefined {
+    return p;
   }
 
   click(selector: string, page: Page) {
@@ -273,15 +279,29 @@ export abstract class PM_Base {
     });
   }
 
-  getValue(value: string, p: string) {
+  // setValue(value: string, p: string) {
+  //   this.doInPage(p, (page) => {
+  //     return page.keyboard.type(value);
+  //   });
+  // }
+
+  getAttribute(selector: string, attribute: string, p: string) {
     this.doInPage(p, (page) => {
-      return page.keyboard.type(value);
+      return page.$eval(selector, (input) => input.getAttribute(attribute));
     });
   }
 
-  getAttribute(selector: string, attribute: string, p: string) {
-    this.doInPage(p, (page) => {
-      return page.$eval(selector, (input) => input.getAttribute("value"));
+  async getInnerHtml(selector: string, p: string) {
+    return new Promise((res, rej) => {
+      this.doInPage(p, async (page) => {
+        const e = await page.$(selector);
+        if (!e) {
+          rej();
+        } else {
+          const text = await (await e.getProperty("textContent")).jsonValue();
+          res(text);
+        }
+      });
     });
   }
 
@@ -299,7 +319,8 @@ export abstract class PM_Base {
 
   async doInPage(p: string, cb: (p: Page) => unknown) {
     (await this.browser.pages()).forEach((page: Page) => {
-      if ((page.mainFrame() as any)._id === p) {
+      const frame = page.mainFrame() as { _id?: string };
+      if (frame._id === p) {
         return cb(page);
       }
     });

package/src/PM/index.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Page } from "puppeteer-core";
 import { ScreenRecorderOptions } from "puppeteer-core/lib/esm/puppeteer";
 
@@ -11,7 +12,7 @@ export abstract class PM {
   abstract stop(): Promise<void>;
   abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise) => void);
 
-  abstract $(selector: string): any;
+  abstract $(selector: string, page: string): any;
   abstract click(selector: string): any;
   abstract closePage(p): any;
   abstract createWriteStream(
@@ -23,8 +24,8 @@ export abstract class PM {
   abstract end(uid: number): Promise<boolean>;
   abstract existsSync(fp: string): Promise<boolean>;
   abstract focusOn(selector: string): any;
-  abstract getAttribute(selector: string, attribute: string): any;
-  abstract getValue(value: string): any;
+  abstract getAttribute(selector: string, attribute: string, page: string): any;
+  abstract getInnerHtml(selector: string, page: string): any;
   abstract goto(p, url: string): any;
   abstract isDisabled(selector: string): Promise<boolean>;
   abstract mkdirSync(a: string);
@@ -37,4 +38,9 @@ export abstract class PM {
   abstract waitForSelector(p, sel: string);
   abstract write(uid: number, contents: string): Promise<boolean>;
   abstract writeFileSync(f: string, c: string, t: string): Promise<boolean>;
+
+  abstract launchSideCar(
+    n: number
+  ): Promise<[number, ITTestResourceConfiguration]>;
+  abstract stopSideCar(n: number): Promise<any>;
 }