testeranto 0.62.0 → 0.70.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testeranto",
   "description": "teeny tiny tightly-typed typescript tests",
-  "version": "0.62.0",
+  "version": "0.70.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",
@@ -235,6 +235,7 @@
     "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,4 +1,3 @@
-import http from "http";
 import puppeteer from "puppeteer-core";
 
 import Testeranto from "./lib/core.js";
@@ -11,46 +10,22 @@ import {
 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";
-
-
-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();
-});
+import puppeteerConfiger from "./puppeteerConfiger.js";
 
-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,
@@ -58,8 +33,7 @@ class NodeTesteranto<TestShape extends IBaseTest> extends Testeranto<TestShape>
       testImplementation,
       testResourceRequirement,
       NodeWriter,
-      testInterface,
-
+      testInterface
     );
 
     if (process.argv[2]) {
@@ -71,7 +45,6 @@ class NodeTesteranto<TestShape extends IBaseTest> extends Testeranto<TestShape>
         ) as ITTestResourceConfiguration;
 
         this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
-
       } catch (e) {
         console.error(e);
         // process.exit(-1);
@@ -85,44 +58,41 @@ class NodeTesteranto<TestShape extends IBaseTest> extends Testeranto<TestShape>
     t: ITestJob,
     partialTestResource: ITTestResourceConfiguration
   ) {
-
-    const browser = await readJson("2999").then(async (json) => {
+    const browser = await puppeteerConfiger("2999").then(async (json) => {
       const b = await puppeteer.connect({
         browserWSEndpoint: json.webSocketDebuggerUrl,
         defaultViewport: null,
       });
       console.log("connected!", b.isConnected());
-      return b
-    })
+      return b;
+    });
 
-    const {
-      failed,
-      artifacts,
-      logPromise
-    } = await t.receiveTestResourceConfig(
+    const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(
       partialTestResource,
-      new TBrowser(browser)
+      {
+        browser,
+        ipc: process.parentPort,
+      }
     );
 
     Promise.all([...artifacts, logPromise]).then(async () => {
-      // process.exit(await failed ? 1 : 0);
-    })
+      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/NodeWriter.ts

@@ -8,22 +8,22 @@ type IFPaths = string[];
 const fPaths: IFPaths = [];
 
 export const NodeWriter: ILogWriter = {
-  createWriteStream: (filepath: string): fs.WriteStream => {
-    return fs.createWriteStream(filepath);
-  },
-  writeFileSync: (fp: string, contents: string) => {
-    fs.writeFileSync(
-      fp,
-      contents
-    );
-  },
-  mkdirSync: async (fp: string) => {
-    await fs.mkdirSync(fp, { recursive: true });
+  createWriteStream: (filepath: string): fs.WriteStream =>
+    fs.createWriteStream(filepath),
+
+  writeFileSync: (fp: string, contents: string) =>
+    fs.writeFileSync(fp, contents),
+
+  mkdirSync: async (destFolder: string) => {
+    if (!fs.existsSync(destFolder)) {
+      fs.mkdirSync(destFolder, { recursive: true });
+    }
   },
   testArtiFactoryfileWriter:
     (tLog: ITLog, callback: (Promise) => void) =>
-      (fPath, value: string | Buffer | PassThrough) => {
-        callback(new Promise<void>((res, rej) => {
+    (fPath, value: string | Buffer | PassThrough) => {
+      callback(
+        new Promise<void>((res, rej) => {
           tLog("testArtiFactory =>", fPath);
 
           const cleanPath = path.resolve(fPath);
@@ -37,7 +37,10 @@ export const NodeWriter: ILogWriter = {
             }
 
             fs.writeFileSync(
-              path.resolve(targetDir.split("/").slice(0, -1).join("/"), "manifest"),
+              path.resolve(
+                targetDir.split("/").slice(0, -1).join("/"),
+                "manifest"
+              ),
               fPaths.join(`\n`),
               {
                 encoding: "utf-8",
@@ -63,7 +66,7 @@ export const NodeWriter: ILogWriter = {
               });
             }
           });
-        }))
-
-      }
-}
+        })
+      );
+    },
+};