testeranto 0.62.0 → 0.73.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testeranto",
   "description": "teeny tiny tightly-typed typescript tests",
-  "version": "0.62.0",
+  "version": "0.73.0",
   "type": "module",
   "types": "./dist/index.d.mts",
   "module": "dist/module/index.js",
@@ -127,8 +127,8 @@
       "require": "./dist/common/Project.js"
     },
     "./src/Web": {
-      "import": "./dist/module/Web.js",
-      "require": "./dist/common/Web.js"
+      "import": "./src/Web.ts",
+      "require": "./src/Web.ts"
     },
     "./src/Node": {
       "import": "./src/Node.ts",
@@ -227,14 +227,13 @@
     "ipc": "^0.0.1",
     "jsonc": "^2.0.0",
     "npm-watch": "^0.11.0",
-    "puppeteer": "19.2.2",
-    "puppeteer-core": "19.2.2",
-    "puppeteer-in-electron": "^3.0.5",
-    "react-bootstrap": "^2.7.0",
+    "puppeteer-core": "^23.6.0",
+    "react-bootstrap": "2.10.6",
     "react-sigma": "^1.2.35",
     "react-test-renderer": "18.2.0",
     "selenium-webdriver": "^4.25.0",
     "url": "^0.11.4",
+    "uuid": "^10.0.0",
     "ws": "^8.16.0"
   }
 }

package/src/Node.ts

@@ -1,128 +1,73 @@
-import http from "http";
-import puppeteer from "puppeteer-core";
-
 import Testeranto from "./lib/core.js";
 import {
   defaultTestResourceRequirement,
-  ITestJob,
   ITTestResourceConfiguration,
   ITTestResourceRequest,
 } from "./lib/index.js";
-import { NodeWriter } from "./NodeWriter.js";
+
 import type {
   IBaseTest,
-  INodeTestInterface,
   ITestImplementation,
-  ITestInterface,
   ITestSpecification,
 } from "./Types.js";
+import { ITestInterface, INodeTestInterface } from "./lib/types.js";
 
-import {
-  TBrowser,
-} from "./Types.js";
-
+import { PM_Node } from "./PM/node.js";
 
-const readJson = async (port: string): Promise<any> => new Promise((resolve, reject) => {
-  let json = "";
-  const request = http.request(
-    {
-      host: "127.0.0.1",
-      path: "/json/version",
-      port,
-    },
-    (response) => {
-      response.on("error", reject);
-      response.on("data", (chunk: Buffer) => {
-        json += chunk.toString();
-      });
-      response.on("end", () => {
-        resolve(JSON.parse(json))
-      });
-    }
-  );
-  request.on("error", reject);
-  request.end();
-});
-
-class NodeTesteranto<TestShape extends IBaseTest> extends Testeranto<TestShape> {
+class NodeTesteranto<
+  TestShape extends IBaseTest
+> extends Testeranto<TestShape> {
   constructor(
     input: TestShape["iinput"],
     testSpecification: ITestSpecification<TestShape>,
-    testImplementation: ITestImplementation<TestShape, object>,
+    testImplementation: ITestImplementation<TestShape>,
     testResourceRequirement: ITTestResourceRequest,
-    testInterface: Partial<ITestInterface<TestShape>>,
+    testInterface: Partial<ITestInterface<TestShape>>
   ) {
     super(
       input,
       testSpecification,
       testImplementation,
       testResourceRequirement,
-      NodeWriter,
-      testInterface,
-
+      testInterface
     );
-
-    if (process.argv[2]) {
-      const testResourceArg = process.argv[2];
-
-      try {
-        const partialTestResource = JSON.parse(
-          testResourceArg
-        ) as ITTestResourceConfiguration;
-
-        this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
-
-      } catch (e) {
-        console.error(e);
-        // process.exit(-1);
-      }
-    } else {
-      // no-op
-    }
   }
 
   async receiveTestResourceConfig(
-    t: ITestJob,
-    partialTestResource: ITTestResourceConfiguration
+    // t: ITestJob,
+    partialTestResource: string
   ) {
+    console.log(
+      "receiveTestResourceConfig!!",
+      this.testJobs[0].receiveTestResourceConfig
+    );
 
-    const browser = await readJson("2999").then(async (json) => {
-      const b = await puppeteer.connect({
-        browserWSEndpoint: json.webSocketDebuggerUrl,
-        defaultViewport: null,
-      });
-      console.log("connected!", b.isConnected());
-      return b
-    })
+    const t: ITTestResourceConfiguration = JSON.parse(partialTestResource);
+    const pm = new PM_Node(t);
+    const { failed, artifacts, logPromise } =
+      await this.testJobs[0].receiveTestResourceConfig(pm);
 
-    const {
-      failed,
-      artifacts,
-      logPromise
-    } = await t.receiveTestResourceConfig(
-      partialTestResource,
-      new TBrowser(browser)
-    );
+    console.log("test is done, awaiting test result write to fs");
+    pm.customclose();
 
-    Promise.all([...artifacts, logPromise]).then(async () => {
-      // process.exit(await failed ? 1 : 0);
-    })
+    // Promise.all([...artifacts, logPromise]).then(async () => {
+    //   // process.exit((await failed) ? 1 : 0);
+    // });
   }
-
-};
+}
 
 export default async <ITestShape extends IBaseTest>(
-  input: ITestShape['iinput'],
+  input: ITestShape["iinput"],
   testSpecification: ITestSpecification<ITestShape>,
-  testImplementation: ITestImplementation<ITestShape, object>,
+  testImplementation: ITestImplementation<ITestShape>,
   testInterface: Partial<INodeTestInterface<ITestShape>>,
-  testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
+  testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement
 ): Promise<Testeranto<ITestShape>> => {
   return new NodeTesteranto<ITestShape>(
     input,
     testSpecification,
     testImplementation,
     testResourceRequirement,
-    testInterface,
-  )
+    testInterface
+  );
 };

package/src/PM/index.ts

@@ -0,0 +1,102 @@
+// import {
+//   Browser,
+//   BrowserContext,
+//   BrowserContextOptions,
+//   DebugInfo,
+//   Page,
+//   PuppeteerNode,
+//   Target,
+// } from "puppeteer-core";
+
+import { Browser } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+import { ChildProcess } from "child_process";
+import { PuppeteerLaunchOptions } from "puppeteer-core/lib/esm/puppeteer";
+// import { ILogWriter, ITLog } from "./lib";
+
+type IFPaths = string[];
+const fPaths: IFPaths = [];
+
+export abstract class PM {
+  server: any;
+  browser: Browser;
+  testResourceConfiguration: ITTestResourceConfiguration;
+
+  // constructor(testResourceConfiguration: ITTestResourceConfiguration) {
+  //   this.testResourceConfiguration = testResourceConfiguration;
+  //   console.log("mkdirsync2", this.testResourceConfiguration);
+  // }
+
+  abstract startPuppeteer(options: any, destfolder: string): Promise<Browser>;
+
+  abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise) => void);
+  abstract createWriteStream(filepath: string): any;
+  abstract writeFileSync(fp: string, contents: string);
+  abstract mkdirSync();
+  abstract existsSync(fp: string): boolean;
+  abstract write(accessObject: { uid: number }, contents: string): boolean;
+  abstract end(accessObject: { uid: number }): boolean;
+
+  // pages(): Promise<Page[]>;
+  // pages(): Promise<Page[]> {
+  //   return new Promise<Page[]>((res, rej) => {
+  //     res(super.pages());
+  //   });
+  // }
+}
+
+// export class PuppetMasterBrowser extends Browser {
+//   process(): ChildProcess | null {
+//     return super.process();
+//   }
+//   createBrowserContext(
+//     options?: BrowserContextOptions
+//   ): Promise<BrowserContext> {
+//     throw new Error("Method not implemented.");
+//   }
+//   browserContexts(): BrowserContext[] {
+//     throw new Error("Method not implemented.");
+//   }
+//   defaultBrowserContext(): BrowserContext {
+//     throw new Error("Method not implemented.");
+//   }
+//   wsEndpoint(): string {
+//     throw new Error("Method not implemented.");
+//   }
+//   newPage(): Promise<Page> {
+//     throw new Error("Method not implemented.");
+//   }
+//   targets(): Target[] {
+//     throw new Error("Method not implemented.");
+//   }
+//   target(): Target {
+//     throw new Error("Method not implemented.");
+//   }
+//   version(): Promise<string> {
+//     throw new Error("Method not implemented.");
+//   }
+//   userAgent(): Promise<string> {
+//     throw new Error("Method not implemented.");
+//   }
+//   close(): Promise<void> {
+//     throw new Error("Method not implemented.");
+//   }
+//   disconnect(): Promise<void> {
+//     throw new Error("Method not implemented.");
+//   }
+//   get connected(): boolean {
+//     throw new Error("Method not implemented.");
+//   }
+//   get debugInfo(): DebugInfo {
+//     throw new Error("Method not implemented.");
+//   }
+//   constructor(...z: []) {
+//     super(...z);
+//   }
+//   // pages(): Promise<Page[]>;
+//   pages(): Promise<Page[]> {
+//     return new Promise<Page[]>((res, rej) => {
+//       res(super.pages());
+//     });
+//   }
+// }