testeranto 0.90.0 → 0.100.0

package/src/PM/node.ts

@@ -1,12 +1,12 @@
 import fs from "fs";
 import path from "path";
-import puppeteer from "puppeteer-core";
+import puppeteer, { ScreencastOptions, ScreenRecorder } from "puppeteer-core";
 import { PassThrough } from "stream";
 
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 
 import { PM } from "./index.js";
-import { Page } from "puppeteer-core/lib/esm/puppeteer";
+import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
 
 type IFPaths = string[];
 const fPaths: IFPaths = [];
@@ -23,10 +23,23 @@ export class PM_Node extends PM {
     this.testResourceConfiguration = t;
   }
 
-  $(selector: string): boolean {
-    throw new Error("Method not implemented.");
+  waitForSelector(p: string, s: string): any {
+    return globalThis["waitForSelector"](p, s);
   }
-  screencast(opts: object) {
+
+  closePage(p): string {
+    return globalThis["closePage"](p);
+  }
+
+  goto(cdpPage: CdpPage, url: string): any {
+    return globalThis["goto"](cdpPage.mainFrame()._id, url);
+  }
+
+  newPage(): CdpPage {
+    return globalThis["newPage"]();
+  }
+
+  $(selector: string): boolean {
     throw new Error("Method not implemented.");
   }
 
@@ -57,8 +70,30 @@ export class PM_Node extends PM {
     return globalThis["click"](selector);
   }
 
-  customScreenShot(opts: object) {
-    return globalThis["customScreenShot"](opts);
+  screencast(opts: ScreencastOptions, page: CdpPage) {
+    return globalThis["screencast"](
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path,
+      },
+      page.mainFrame()._id,
+      this.testResourceConfiguration.name
+    );
+  }
+
+  screencastStop(p: string) {
+    return globalThis["screencastStop"](p);
+  }
+
+  customScreenShot(opts: ScreencastOptions, cdpPage: CdpPage) {
+    return globalThis["customScreenShot"](
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path,
+      },
+      cdpPage.mainFrame()._id,
+      this.testResourceConfiguration.name
+    );
   }
 
   existsSync(destFolder: string): boolean {

package/src/PM/web.ts

@@ -3,7 +3,8 @@ import { PassThrough } from "stream";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 
 import { PM } from "./index.js";
-import { ScreenshotOptions } from "puppeteer-core";
+import { ScreencastOptions, ScreenshotOptions } from "puppeteer-core";
+import { CdpPage } from "puppeteer-core/lib/esm/puppeteer";
 
 type PuppetMasterServer = Record<string, Promise<any>>;
 
@@ -16,12 +17,39 @@ export class PM_Web extends PM {
     this.testResourceConfiguration = t;
   }
 
+  waitForSelector(p: string, s: string): any {
+    return window["waitForSelector"](p, s);
+  }
+
+  screencast(opts: ScreencastOptions) {
+    return window["screencast"](
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path,
+      },
+      this.testResourceConfiguration.name
+    );
+  }
+
+  screencastStop(recorder: string) {
+    return window["screencastStop"](recorder);
+  }
+
+  closePage(p): string {
+    return window["closePage"](p);
+  }
+
+  goto(p, url: string): any {
+    return window["goto"](p, url);
+  }
+
+  newPage(): CdpPage {
+    return window["newPage"]();
+  }
+
   $(selector: string): boolean {
     return window["$"](selector);
   }
-  screencast(opts: object) {
-    throw new Error("Method not implemented.");
-  }
 
   isDisabled(selector: string): boolean {
     return window["isDisabled"](selector);
@@ -64,7 +92,7 @@ export class PM_Web extends PM {
     return window["existsSync"](destFolder);
   }
 
-  mkdirSync() {
+  mkdirSync(x) {
     return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
   }
 

package/src/SubPackages/puppeteer.ts

@@ -29,7 +29,7 @@ export default <ITestShape extends IBaseTest>(
     testSpecifications,
     testImplementations,
     {
-      beforeAll(x) {
+      beforeAll: (x) => {
         // process.parentPort.postMessage(
         //   `/docs/web/src/ClassicalComponent/test.html`
         // );

package/src/SubPackages/react/jsx/index.ts

@@ -1,4 +1,5 @@
 import { CElement } from "react";
+import React from "react";
 
 import {
   IBaseTest,
@@ -6,7 +7,6 @@ import {
   ITestImplementation,
   ITestSpecification,
 } from "../../../Types";
-import React from "react";
 
 export type IWhenShape = any;
 export type IThenShape = any;
@@ -29,14 +29,22 @@ export const testInterface: IPartialInterface<any> = {
   //   //   resolve(x());
   //   // });
   // },
-  beforeEach: async (subject, initializer, artificer): Promise<IStore> => {
+  // beforeEach: async (subject, initializer, artificer): Promise<IStore> => {
+  //   return new Promise((resolve, rej) => {
+  //     resolve(React.createElement(subject));
+  //   });
+  // },
+  andWhen: async (s: IStore, whenCB): Promise<IStore> => {
+    await whenCB(s());
     return new Promise((resolve, rej) => {
-      const x = React.createElement(subject);
-      console.log("react-element", x);
-      resolve(x);
+      resolve(React.createElement(s));
     });
+    // return whenCB(s);
   },
-  andWhen: function (s: IStore, whenCB): Promise<ISelection> {
-    return whenCB(s);
+  butThen: async (subject, thenCB) => {
+    await thenCB(subject());
+    return new Promise((resolve, rej) => {
+      resolve(React.createElement(subject));
+    });
   },
 };

package/src/SubPackages/react/jsx/node.ts

@@ -8,19 +8,31 @@ import {
   testInterface as baseInterface,
 } from "./index.js";
 
-export default <ITestShape extends IBaseTest>(
+export default <
+  ITestShape extends IBaseTest<
+    IInput,
+    number,
+    number,
+    number,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+>(
   testImplementations: ITestImpl<ITestShape>,
   testSpecifications: ITestSpec<ITestShape>,
   testInput: IInput,
-  testInterface: IPartialInterface<ITestShape>
+  testInterface: IPartialInterface<ITestShape> = baseInterface
 ) => {
   return Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
-    {
-      ...baseInterface,
-      ...testInterface,
-    }
+    testInterface
   );
 };

package/src/SubPackages/react-dom/component/web.ts

@@ -25,7 +25,7 @@ export type IStore = {
 
 type ISubject = {
   htmlElement: HTMLElement;
-  reactElement: any; //CElement<any, any>,
+  // reactElement: any; //CElement<any, any>,
   domRoot: ReactDom.Root;
 };
 
@@ -52,63 +52,40 @@ export default <ITestShape extends IBaseTest, IWhen, IGiven>(
     testSpecifications,
     testImplementations,
     {
-      beforeAll: async (initialProps, artificer): Promise<ISubject> => {
+      beforeAll: async (subject, artificer): Promise<ISubject> => {
         return await new Promise((resolve, rej) => {
           const htmlElement = document.getElementById("root");
           if (htmlElement) {
             const domRoot = ReactDom.createRoot(htmlElement);
-            // Ignore these type errors
-            domRoot.render(
-              createElement(
-                TesterantoComponent,
-                {
-                  ...initialProps,
-                  done: (reactElement) => {
-                    resolve({
-                      htmlElement,
-                      reactElement,
-                      domRoot,
-                    });
-                  },
-                },
-                []
-              )
-            );
-
-            // resolve({ htmlElement });
+            resolve({ domRoot, htmlElement });
           }
         });
       },
-      // beforeEach: async (
-      //   s,
-      //   initializer,
-      //   testResource,
-      //   artificer,
-      //   initialValues
-      // ): Promise<IStore> => {
-      //   return new Promise((resolve, rej) => {
-      //     console.log("beforeEach" + TesterantoComponent);
-
-      //     // const domRoot = ReactDom.createRoot(htmlElement);
-      //     // // Ignore these type errors
-      //     // domRoot.render(
-      //     //   createElement(
-      //     //     TesterantoComponent,
-      //     //     {
-      //     //       ...initializer,
-      //     //       done: (reactElement) => {
-      //     //         resolve({
-      //     //           htmlElement,
-      //     //           reactElement,
-      //     //           domRoot,
-      //     //         });
-      //     //       },
-      //     //     },
-      //     //     []
-      //     //   )
-      //     // );
-      //   });
-      // },
+      beforeEach: async (
+        { domRoot, htmlElement },
+        initialValues,
+        testResource,
+        artificer
+      ): Promise<IStore> => {
+        return new Promise(async (resolve, rej) => {
+          domRoot.render(
+            createElement(
+              TesterantoComponent,
+              {
+                ...initialValues,
+                done: (reactElement) => {
+                  resolve({
+                    htmlElement,
+                    reactElement,
+                    domRoot,
+                  });
+                },
+              },
+              []
+            )
+          );
+        });
+      },
       andWhen: function (s: IStore, whenCB): Promise<ISelection> {
         return whenCB(s);
       },

package/src/SubPackages/react-test-renderer/component/interface.ts

@@ -1,21 +1,18 @@
 import React from "react";
 import renderer, { act } from "react-test-renderer";
+
 import { ISelection, IStore } from ".";
 
 export const testInterface = {
   beforeEach: function (
     CComponent,
-    propsAndChildren
+    propsAndChildren: () => any
   ): Promise<renderer.ReactTestRenderer> {
-    function Link(props) {
-      const p = props.props;
-      const c = props.children;
-      return React.createElement(CComponent, p, c);
+    function Link(proper) {
+      return React.createElement(CComponent, proper(), []);
     }
     return new Promise((res, rej) => {
       act(async () => {
-        const p = propsAndChildren;
-        const y = new CComponent(p.props);
         const testRenderer = await renderer.create(Link(propsAndChildren));
         res(testRenderer);
       });
@@ -25,7 +22,6 @@ export const testInterface = {
     renderer: renderer.ReactTestRenderer,
     whenCB: any
   ): Promise<renderer.ReactTestRenderer> {
-    // console.log("andWhen", whenCB)
     await act(() => whenCB(renderer));
     return renderer;
   },
@@ -34,15 +30,12 @@ export const testInterface = {
   //   return whenCB()(s);
   // },
   butThen: async function (s: IStore, thenCB, tr): Promise<ISelection> {
-    console.log("butThen", thenCB.toString());
     return thenCB(s);
   },
   afterEach: async function (store: IStore, ndx, artificer) {
-    // console.log("afterEach", store);
     return {};
   },
   afterAll: (store: IStore, artificer) => {
-    // console.log("afterAll", store);
     return;
   },
 };

package/src/SubPackages/react-test-renderer/jsx/node.ts

@@ -5,7 +5,22 @@ import type { ITestImpl, ITestSpec } from "../jsx-promised";
 
 import { IInput, testInterface } from "./index.js";
 
-export default <ITestShape extends IBaseTest>(
+export default <
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+>(
   testImplementations: ITestImpl<ITestShape>,
   testSpecifications: ITestSpec<ITestShape>,
   testInput: IInput,