testeranto 0.121.1 → 0.125.0

package/src/PM/base.ts

@@ -1,12 +1,15 @@
-import { CdpPage } from "puppeteer-core/lib/esm/puppeteer";
 import fs from "fs";
 import path from "path";
-import { Browser, ScreenRecorder, ScreenshotOptions } from "puppeteer-core";
+import {
+  Browser,
+  Page,
+  ScreenRecorder,
+  ScreenshotOptions,
+} from "puppeteer-core";
 import { PassThrough } from "stream";
 
-import { IBuiltConfig, ITLog } from "../lib/index.js";
-
-import { PM } from "./index.js";
+import { ITLog } from "../lib/index.js";
+import { IBuiltConfig } from "../Types.js";
 
 const fileStreams3: fs.WriteStream[] = [];
 type IFPaths = string[];
@@ -15,190 +18,130 @@ const files: Record<string, Set<string>> = {};
 const recorders: Record<string, ScreenRecorder> = {};
 const screenshots: Record<string, Promise<Uint8Array>[]> = {};
 
-export abstract class PM_Base extends PM {
+export abstract class PM_Base {
   browser: Browser;
   configs: IBuiltConfig;
 
   constructor(configs: IBuiltConfig) {
-    super();
-    this.server = {};
     this.configs = configs;
+  }
 
-    globalThis["waitForSelector"] = async (pageKey: string, sel: string) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
-      await page?.waitForSelector(sel);
-    };
-
-    globalThis["screencastStop"] = async (path: string) => {
-      return recorders[path].stop();
-    };
-
-    globalThis["closePage"] = async (pageKey) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
-      /* @ts-ignore:next-line */
-      return page.close();
-    };
-
-    globalThis["goto"] = async (pageKey: string, url: string) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
-      await page?.goto(url);
-      return;
-    };
-
-    globalThis["newPage"] = () => {
-      return this.browser.newPage();
-    };
-
-    globalThis["pages"] = () => {
-      return this.browser.pages();
-    };
+  customclose() {
+    throw new Error("Method not implemented.");
+  }
 
-    globalThis["mkdirSync"] = (fp: string) => {
-      if (!fs.existsSync(fp)) {
-        return fs.mkdirSync(fp, {
-          recursive: true,
-        });
-      }
-      return false;
-    };
+  waitForSelector(p: string, s: string): any {
+    return new Promise((res) => {
+      this.doInPage(p, async (page) => {
+        const x = page.$(s);
+        const y = await x;
 
-    globalThis["writeFileSync"] = (
-      filepath: string,
-      contents: string,
-      testName: string
-    ) => {
-      fs.mkdirSync(path.dirname(filepath), {
-        recursive: true,
+        res(y !== null);
+        // return page.focus(selector);
       });
-      if (!files[testName]) {
-        files[testName] = new Set();
-      }
-      files[testName].add(filepath);
-      return fs.writeFileSync(filepath, contents);
-    };
+    });
+  }
 
-    globalThis["createWriteStream"] = (filepath: string, testName: string) => {
-      const f = fs.createWriteStream(filepath);
-      fileStreams3.push(f);
-      // files.add(filepath);
-      if (!files[testName]) {
-        files[testName] = new Set();
-      }
-      files[testName].add(filepath);
-      return {
-        ...JSON.parse(JSON.stringify(f)),
-        uid: fileStreams3.length - 1,
-      };
-    };
+  closePage(p): any {
+    // throw new Error("Method not implemented.");
+    return new Promise((res) => {
+      this.doInPage(p, async (page) => {
+        page.close();
 
-    globalThis["write"] = (uid: number, contents: string) => {
-      fileStreams3[uid].write(contents);
-    };
+        res({});
+        // return page.focus(selector);
+      });
+    });
+  }
 
-    globalThis["end"] = (uid: number) => {
-      fileStreams3[uid].end();
-    };
+  newPage(): Promise<Page> {
+    return this.browser.newPage();
+  }
 
-    globalThis["customScreenShot"] = async (
-      opts: { path: string },
-      pageKey: string,
-      testName: string
-    ) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
+  goto(p, url: string): any {
+    return new Promise((res) => {
+      this.doInPage(p, async (page) => {
+        await page?.goto(url);
 
-      const p = opts.path as string;
-      const dir = path.dirname(p);
-      fs.mkdirSync(dir, {
-        recursive: true,
+        res({});
+        // return page.focus(selector);
       });
-      if (!files[opts.path]) {
-        files[opts.path] = new Set();
-      }
-      files[opts.path].add(opts.path as string);
+    });
+  }
 
-      /* @ts-ignore:next-line */
-      const sPromise = page.screenshot({
-        ...opts,
-        path: p,
+  $(selector: string, p: string): Promise<boolean> {
+    return new Promise((res) => {
+      this.doInPage(p, async (page) => {
+        const x = page.$(selector);
+        const y = await x;
+        res(y !== null);
       });
+    });
+  }
 
-      if (!screenshots[opts.path]) {
-        screenshots[opts.path] = [];
-      }
-      screenshots[opts.path].push(sPromise);
+  async pages(): Promise<string[]> {
+    return (await this.browser.pages()).map((p) => {
+      return (p.mainFrame() as any)._id;
+    });
+  }
 
-      await sPromise;
-      return sPromise;
-    };
+  async screencast(ssOpts: ScreenshotOptions, testName: string, page: Page) {
+    const p = ssOpts.path as string;
+    const dir = path.dirname(p);
+    fs.mkdirSync(dir, {
+      recursive: true,
+    });
+    if (!files[testName]) {
+      files[testName] = new Set();
+    }
+    files[testName].add(ssOpts.path as string);
 
-    globalThis["screencast"] = async (
-      opts: ScreenshotOptions,
-      pageKey: string
-    ) => {
-      const page = (await this.browser.pages()).find(
-        /* @ts-ignore:next-line */
-        (p) => p.mainFrame()._id === pageKey
-      );
+    const sPromise = page.screenshot({
+      ...ssOpts,
+      path: p,
+    });
 
-      const p = opts.path as string;
-      const dir = path.dirname(p);
-      fs.mkdirSync(dir, {
-        recursive: true,
-      });
+    if (!screenshots[testName]) {
+      screenshots[testName] = [];
+    }
+    screenshots[testName].push(sPromise);
+    await sPromise;
+    return sPromise;
+  }
 
-      const recorder = await page?.screencast({
-        ...opts,
-        /* @ts-ignore:next-line */
-        path: p,
-      });
+  async customScreenShot(
+    ssOpts: ScreenshotOptions,
+    testName: string,
+    page: Page
+  ) {
+    const p = ssOpts.path as string;
+    const dir = path.dirname(p);
+    fs.mkdirSync(dir, {
+      recursive: true,
+    });
+    if (!files[testName]) {
+      files[testName] = new Set();
+    }
+    files[testName].add(ssOpts.path as string);
 
-      /* @ts-ignore:next-line */
-      recorders[opts.path] = recorder;
+    const sPromise = page.screenshot({
+      ...ssOpts,
+      path: p,
+    });
 
-      return opts.path;
-    };
+    if (!screenshots[testName]) {
+      screenshots[testName] = [];
+    }
+    screenshots[testName].push(sPromise);
+    await sPromise;
+    return sPromise;
   }
 
-  customclose() {
-    throw new Error("Method not implemented.");
-  }
-  waitForSelector(p: string, s: string): any {
-    throw new Error("Method not implemented.");
-  }
-  closePage(p): any {
-    throw new Error("Method not implemented.");
-  }
-  newPage(): CdpPage {
-    throw new Error("Method not implemented.");
-  }
-  goto(p, url: string): any {
-    throw new Error("Method not implemented.");
-  }
-  $(selector: string): boolean {
-    throw new Error("Method not implemented.");
-  }
-  screencast(opts: object) {
-    throw new Error("Method not implemented.");
-  }
-  /* @ts-ignore:next-line */
-  customScreenShot(opts: object, cdpPage?: CdpPage) {
-    throw new Error("Method not implemented.");
-  }
-  end(accessObject: { uid: number }): boolean {
-    throw new Error("Method not implemented.");
+  async end(uid: number): Promise<boolean> {
+    await fileStreams3[uid].end();
+    return true;
   }
+
   existsSync(destFolder: string): boolean {
     return fs.existsSync(destFolder);
   }
@@ -212,12 +155,36 @@ export abstract class PM_Base extends PM {
     return false;
   }
 
-  writeFileSync(fp: string, contents: string) {
-    fs.writeFileSync(fp, contents);
+  async writeFileSync(
+    filepath: string,
+    contents: string,
+    testName: string
+  ): Promise<boolean> {
+    return new Promise<boolean>(async (res) => {
+      fs.mkdirSync(path.dirname(filepath), {
+        recursive: true,
+      });
+      if (!files[testName]) {
+        files[testName] = new Set();
+      }
+      files[testName].add(filepath);
+
+      await fs.writeFileSync(filepath, contents);
+      res(true);
+    });
   }
 
-  createWriteStream(filepath: string): fs.WriteStream {
-    return fs.createWriteStream(filepath);
+  async createWriteStream(filepath: string, testName: string): Promise<number> {
+    return new Promise<number>((res) => {
+      const f = fs.createWriteStream(filepath);
+      fileStreams3.push(f);
+      if (!files[testName]) {
+        files[testName] = new Set();
+      }
+      files[testName].add(filepath);
+
+      res(fileStreams3.length - 1);
+    });
   }
 
   testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise) => void) {
@@ -271,31 +238,62 @@ export abstract class PM_Base extends PM {
     };
   }
 
-  write(accessObject: { uid: number }, contents: string): boolean {
-    throw new Error("Method not implemented.");
+  async write(uid: number, contents: string): Promise<boolean> {
+    return new Promise<boolean>((res) => {
+      const x = fileStreams3[uid].write(contents);
+      res(x);
+    });
   }
+
   page(): string | undefined {
     throw new Error("Method not implemented.");
   }
-  click(selector: string): string | undefined {
-    throw new Error("Method not implemented.");
+
+  click(selector: string, page: Page) {
+    return page.click(selector);
   }
-  focusOn(selector: string) {
-    throw new Error("Method not implemented.");
+
+  async focusOn(selector: string, p: string) {
+    this.doInPage(p, (page) => {
+      return page.focus(selector);
+    });
   }
-  typeInto(value: string) {
-    throw new Error("Method not implemented.");
+
+  async typeInto(value: string, p: string) {
+    this.doInPage(p, (page) => {
+      return page.keyboard.type(value);
+    });
   }
-  getValue(value: string) {
-    throw new Error("Method not implemented.");
+
+  getValue(value: string, p: string) {
+    this.doInPage(p, (page) => {
+      return page.keyboard.type(value);
+    });
   }
-  getAttribute(selector: string, attribute: string) {
-    throw new Error("Method not implemented.");
+
+  getAttribute(selector: string, attribute: string, p: string) {
+    this.doInPage(p, (page) => {
+      return page.$eval(selector, (input) => input.getAttribute("value"));
+    });
   }
-  isDisabled(selector: string): Promise<boolean> {
-    throw new Error("Method not implemented.");
+
+  isDisabled(selector: string, p: string) {
+    this.doInPage(p, async (page) => {
+      return await page.$eval(selector, (input: HTMLButtonElement) => {
+        return input.disabled;
+      });
+    });
   }
+
   screencastStop(s: string) {
-    throw new Error("Method not implemented.");
+    return recorders[s].stop();
+  }
+
+  async doInPage(p: string, cb: (p: Page) => unknown) {
+    (await this.browser.pages()).forEach((page: Page) => {
+      if ((page.mainFrame() as any)._id === p) {
+        return cb(page);
+      }
+    });
   }
 }

package/src/PM/index.ts

@@ -1,5 +1,8 @@
-import { CdpPage } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser";
-import { ScreenRecorderOptions } from "puppeteer-core/lib/esm/puppeteer";
+import { Page } from "puppeteer-core";
+import {
+  CdpPage,
+  ScreenRecorderOptions,
+} from "puppeteer-core/lib/esm/puppeteer";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 
 type IFPaths = string[];
@@ -9,30 +12,34 @@ export abstract class PM {
   server: any;
   testResourceConfiguration: ITTestResourceConfiguration;
 
+  abstract start(): Promise<void>;
+  abstract stop(): Promise<void>;
   abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise) => void);
-  abstract createWriteStream(filepath: string): any;
-  abstract writeFileSync(fp: string, contents: string);
-  abstract mkdirSync(a: string);
-  abstract existsSync(fp: string): boolean;
-  abstract write(accessObject: { uid: number }, contents: string): boolean;
-  abstract end(accessObject: { uid: number }): boolean;
-  abstract customScreenShot(opts: object, page?: string): any;
-  abstract screencast(opts: ScreenRecorderOptions, p?): any;
-  abstract screencastStop(s: string): any;
 
-  abstract page(): string | undefined;
+  abstract $(selector: string): any;
   abstract click(selector: string): any;
+  abstract closePage(p): any;
+  abstract createWriteStream(
+    filepath: string,
+    testName: string
+  ): Promise<string>;
+  abstract customclose();
+  abstract customScreenShot(opts: object, page?: string): any;
+  abstract end(uid: number): Promise<boolean>;
+  abstract existsSync(fp: string): Promise<boolean>;
   abstract focusOn(selector: string): any;
-  abstract typeInto(value: string): any;
-  abstract getValue(value: string): any;
   abstract getAttribute(selector: string, attribute: string): any;
-  abstract isDisabled(selector: string): Promise<boolean>;
-  abstract $(selector: string): any;
-
-  abstract newPage(): CdpPage;
+  abstract getValue(value: string): any;
   abstract goto(p, url: string): any;
-  abstract closePage(p): any;
-
+  abstract isDisabled(selector: string): Promise<boolean>;
+  abstract mkdirSync(a: string);
+  abstract newPage(): Promise<string>;
+  abstract page(): Promise<string | undefined>;
+  abstract pages(): Promise<string[]>;
+  abstract screencast(o: ScreenRecorderOptions, p: Page | string): any;
+  abstract screencastStop(s: string): any;
+  abstract typeInto(selector: string, value: string): any;
   abstract waitForSelector(p, sel: string);
-  abstract customclose();
+  abstract write(uid: number, contents: string): Promise<boolean>;
+  abstract writeFileSync(f: string, c: string, t: string): Promise<boolean>;
 }