testeranto 0.70.0 → 0.74.0

package/src/lib/basebuilder.ts

@@ -1,3 +1,5 @@
+import { PassThrough } from "stream";
+
 import {
   ITTestResourceRequest,
   ITestJob,
@@ -13,7 +15,7 @@ import {
   IWhenKlasser,
   IThenKlasser,
   ICheckKlasser,
-  IUtils,
+  // IUtils,
 } from "./types.js";
 
 import {
@@ -23,6 +25,7 @@ import {
   BaseThen,
   BaseGiven,
 } from "./abstractBase.js";
+import { PM } from "../PM/index.js";
 
 export abstract class BaseBuilder<
   ITestShape extends IBaseTest,
@@ -45,6 +48,7 @@ export abstract class BaseBuilder<
   whenOverides: Record<keyof WhenExtensions, IWhenKlasser<ITestShape>>;
   thenOverides: Record<keyof ThenExtensions, IThenKlasser<ITestShape>>;
   checkOverides: Record<keyof CheckExtensions, ICheckKlasser<ITestShape>>;
+  puppetMaster: PM;
 
   constructor(
     public readonly input: ITestShape["iinput"],
@@ -53,9 +57,9 @@ export abstract class BaseBuilder<
     whenOverides: Record<keyof WhenExtensions, IWhenKlasser<ITestShape>>,
     thenOverides: Record<keyof ThenExtensions, IThenKlasser<ITestShape>>,
     checkOverides: Record<keyof CheckExtensions, ICheckKlasser<ITestShape>>,
-    logWriter: ILogWriter,
     testResourceRequirement: ITTestResourceRequest,
     testSpecification: any
+    // puppetMaster: PM
   ) {
     this.artifacts = [];
     this.testResourceRequirement = testResourceRequirement;
@@ -65,6 +69,7 @@ export abstract class BaseBuilder<
     this.thenOverides = thenOverides;
     this.checkOverides = checkOverides;
     this.testSpecification = testSpecification;
+    // this.puppetMaster = puppetMaster;
 
     this.specs = testSpecification(
       this.Suites(),
@@ -74,106 +79,122 @@ export abstract class BaseBuilder<
       this.Check()
     );
 
-    const suiteRunner =
-      (suite: BaseSuite<ITestShape>, utils: IUtils) =>
-      async (
-        testResourceConfiguration: ITTestResourceConfiguration,
-        tLog: ITLog,
-        utils: IUtils
-      ): Promise<BaseSuite<ITestShape>> => {
-        return await suite.run(
-          input,
-          testResourceConfiguration,
-          (fPath: string, value: unknown) =>
-            logWriter.testArtiFactoryfileWriter(tLog, (p: Promise<void>) => {
-              this.artifacts.push(p);
-            })(testResourceConfiguration.fs + "/" + fPath, value),
-          tLog,
-          utils
-        );
-      };
-
-    this.testJobs = this.specs.map(
-      (suite: BaseSuite<ITestShape>, utils: IUtils) => {
-        const runner = suiteRunner(suite, utils);
-
-        return {
-          test: suite,
-          testResourceRequirement,
-
-          toObj: () => {
-            return suite.toObj();
-          },
-
-          runner,
-
-          receiveTestResourceConfig: async function (
-            testResourceConfiguration = {
-              name: "",
-              fs: ".",
-              ports: [],
-              scheduled: false,
+    this.testJobs = this.specs.map((suite: BaseSuite<ITestShape>) => {
+      const suiteRunner =
+        (suite: BaseSuite<ITestShape>) =>
+        async (
+          // testResourceConfiguration: ITTestResourceConfiguration,
+          puppetMaster: PM,
+          tLog: ITLog
+        ): Promise<BaseSuite<ITestShape>> => {
+          await puppetMaster.startPuppeteer(
+            {
+              browserWSEndpoint:
+                puppetMaster.testResourceConfiguration.browserWSEndpoint,
             },
-            y: IUtils
-          ) {
-            console.log(
-              `testResourceConfiguration ${JSON.stringify(
-                testResourceConfiguration,
-                null,
-                2
-              )}`
-            );
-
-            // await logWriter.mkdirSync(testResourceConfiguration.fs);
-            //  if (!fs.existsSync(destFolder)) {
-            //    fs.mkdirSync(destFolder, { recursive: true });
-            //  }
-
-            logWriter.writeFileSync(
-              `${testResourceConfiguration.fs}/tests.json`,
-              JSON.stringify(this.toObj(), null, 2)
-            );
-
-            const logFilePath = `${testResourceConfiguration.fs}/log.txt`;
-
-            const access = await logWriter.createWriteStream(logFilePath);
-
-            const tLog = (...l: string[]) => access.write(`${l.toString()}\n`);
-
-            const suiteDone: BaseSuite<ITestShape> = await runner(
-              testResourceConfiguration,
-              tLog,
-              y
-            );
-
-            const logPromise = new Promise((res, rej) => {
-              access.on("finish", () => {
-                res(true);
-              });
-            });
-            access.end();
-
-            const numberOfFailures = Object.keys(suiteDone.givens).filter(
-              (k) => {
-                return suiteDone.givens[k].error;
-              }
-            ).length;
-            logWriter.writeFileSync(
-              `${testResourceConfiguration.fs}/exitcode`,
-              numberOfFailures.toString()
-            );
-            console.log(
-              `exiting gracefully with ${numberOfFailures} failures.`
-            );
-            return {
-              failed: numberOfFailures,
-              artifacts: this.artifacts || [],
-              logPromise,
-            };
-          },
+            puppetMaster.testResourceConfiguration.fs
+          );
+
+          return await suite.run(
+            input,
+            puppetMaster.testResourceConfiguration,
+            (fPath: string, value: string | Buffer | PassThrough) =>
+              puppetMaster.testArtiFactoryfileWriter(
+                tLog,
+                (p: Promise<void>) => {
+                  this.artifacts.push(p);
+                }
+              )(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value),
+            tLog,
+            puppetMaster
+          );
         };
-      }
-    );
+
+      const runner = suiteRunner(suite);
+
+      return {
+        test: suite,
+        // testResourceRequirement,
+
+        toObj: () => {
+          return suite.toObj();
+        },
+
+        runner,
+
+        receiveTestResourceConfig: async function (
+          // testResourceConfiguration = {
+          //   name: "",
+          //   fs: ".",
+          //   ports: [],
+          //   browserWSEndpoint: "",
+          // },
+          puppetMaster: PM
+        ) {
+          // console.log(
+          //   `testResourceConfiguration! ${JSON.stringify(
+          //     testResourceConfiguration,
+          //     null,
+          //     2
+          //   )}`
+          // );
+          // console.log("puppetMaster", puppetMaster);
+
+          await puppetMaster
+            .mkdirSync
+            // ""
+            // puppetMaster.testResourceConfiguration.fs + "/"
+            ();
+          //  if (!puppetMaster.existsSync(destFolder)) {
+          //    puppetMaster.mkdirSync(destFolder, { recursive: true });
+          //  }
+
+          // puppetMaster.writeFileSync(
+          //   // puppetMaster.testResourceConfiguration.fs + `/tests.json`,
+          //   `tests.json`,
+          //   JSON.stringify(this.toObj(), null, 2)
+          // );
+
+          const logFilePath = "log.txt";
+          // puppetMaster.testResourceConfiguration.fs + `/log.txt`;
+
+          const access = await puppetMaster.createWriteStream(logFilePath);
+
+          // console.log("access", access);
+          const tLog = (...l: string[]) => {
+            // access.write(`${l.toString()}\n`);
+            // console.log("tLog", l);
+            puppetMaster.write(access, `${l.toString()}\n`);
+          };
+
+          const suiteDone: BaseSuite<ITestShape> = await runner(
+            puppetMaster,
+            tLog
+          );
+
+          const logPromise = new Promise((res, rej) => {
+            puppetMaster.end(access);
+            res(true);
+          });
+
+          const numberOfFailures = Object.keys(suiteDone.givens).filter((k) => {
+            return suiteDone.givens[k].error;
+          }).length;
+          puppetMaster.writeFileSync(`exitcode`, numberOfFailures.toString());
+
+          puppetMaster.writeFileSync(
+            `tests.json`,
+            JSON.stringify(this.toObj(), null, 2)
+          );
+          console.log(`exiting gracefully with ${numberOfFailures} failures.`);
+          return {
+            failed: numberOfFailures,
+            artifacts: this.artifacts || [],
+            logPromise,
+          };
+        },
+      };
+    });
   }
 
   Specs() {

package/src/lib/classBuilder.ts

@@ -6,7 +6,6 @@ import {
 
 import { BaseBuilder } from "./basebuilder.js";
 
-import { ILogWriter, ITTestResourceRequest } from ".";
 import {
   ISuiteKlasser,
   IGivenKlasser,
@@ -14,6 +13,8 @@ import {
   IThenKlasser,
   ICheckKlasser,
 } from "./types.js";
+import { PM } from "../PM/index.js";
+import { ITTestResourceRequest } from "./index.js";
 
 export abstract class ClassBuilder<
   ITestShape extends IBaseTest
@@ -27,8 +28,8 @@ export abstract class ClassBuilder<
     whenKlasser: IWhenKlasser<ITestShape>,
     thenKlasser: IThenKlasser<ITestShape>,
     checkKlasser: ICheckKlasser<ITestShape>,
-    testResourceRequirement: ITTestResourceRequest,
-    logWriter: ILogWriter
+    testResourceRequirement: ITTestResourceRequest
+    // puppetMaster: PM
   ) {
     const classySuites = Object.entries(testImplementation.suites).reduce(
       (a, [key], index) => {
@@ -110,9 +111,9 @@ export abstract class ClassBuilder<
       classyWhens,
       classyThens,
       classyChecks,
-      logWriter,
       testResourceRequirement,
       testSpecification
+      // puppetMaster
     );
   }
 }

package/src/lib/core.ts

@@ -5,7 +5,7 @@ import {
   ITestImplementation,
 } from "../Types.js";
 
-import { ITestInterface, IUtils } from "./types.js";
+import { ITestInterface } from "./types.js";
 import {
   DefaultTestInterface,
   ILogWriter,
@@ -23,6 +23,7 @@ import {
   BaseCheck,
 } from "./abstractBase.js";
 import { ClassBuilder } from "./classBuilder.js";
+import { PM } from "../PM/index";
 
 export default abstract class Testeranto<
   ITestShape extends IBaseTest
@@ -32,17 +33,48 @@ export default abstract class Testeranto<
     testSpecification: ITestSpecification<ITestShape>,
     testImplementation: ITestImplementation<ITestShape>,
     testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
-    logWriter: ILogWriter,
     testInterface: Partial<ITestInterface<ITestShape>>
+    // puppetMaster: PM
   ) {
     const fullTestInterface = DefaultTestInterface(testInterface);
-
     super(
       testImplementation,
       testSpecification,
       input,
 
       class extends BaseSuite<ITestShape> {
+        afterAll(store: IStore, artifactory: ITestArtifactory, pm: PM) {
+          // const pagesHandler = {
+          //   get(target, prop) {
+          //     console.log(`Getting pages property ${prop}`);
+          //     return target[prop];
+          //   },
+          // };
+
+          // const browserHandler = {
+          //   get(target, prop) {
+          //     console.log(`Getting browser property ${prop}`);
+          //     if (prop === "pages") {
+          //       // return target[prop];
+          //       return new Proxy(target[prop], pagesHandler);
+          //     } else {
+          //       return target[prop];
+          //     }
+          //   },
+          // };
+          // const proxy = new Proxy(utils.browser, browserHandler);
+
+          return fullTestInterface.afterAll(
+            store,
+            (fPath: string, value: unknown) =>
+              // TODO does not work?
+              {
+                artifactory(`afterAll4-${this.name}/${fPath}`, value);
+              },
+            pm
+          );
+        }
+
         assertThat(t) {
           fullTestInterface.assertThis(t);
         }
@@ -51,7 +83,7 @@ export default abstract class Testeranto<
           s: ITestShape["iinput"],
           artifactory: ITestArtifactory,
           tr,
-          utils
+          pm
         ): Promise<ITestShape["isubject"]> {
           return (
             fullTestInterface.beforeAll ||
@@ -59,14 +91,14 @@ export default abstract class Testeranto<
               input: ITestShape["iinput"],
               artifactory: ITestArtifactory,
               tr,
-              utils: ITestInterface<ITestShape>
+              pm: PM
             ) => input as any)
-          )(s, this.testResourceConfiguration, artifactory, utils);
+          )(s, this.testResourceConfiguration, artifactory, pm);
         }
       } as any,
 
       class Given extends BaseGiven<ITestShape> {
-        async givenThat(subject, testResource, artifactory, initializer) {
+        async givenThat(subject, testResource, artifactory, initializer, pm) {
           return fullTestInterface.beforeEach(
             subject,
             initializer,
@@ -74,8 +106,8 @@ export default abstract class Testeranto<
               // TODO does not work?
               artifactory(`beforeEach/${fPath}`, value),
             testResource,
-            this.initialValues
-            // utils,
+            this.initialValues,
+            pm
           );
         }
 
@@ -83,7 +115,7 @@ export default abstract class Testeranto<
           store: ITestShape["istore"],
           key: string,
           artifactory,
-          utils
+          pm
         ): Promise<unknown> {
           return new Promise((res) =>
             res(
@@ -92,51 +124,21 @@ export default abstract class Testeranto<
                 key,
                 (fPath: string, value: unknown) =>
                   artifactory(`after/${fPath}`, value),
-                utils
+                pm
               )
             )
           );
         }
-        afterAll(store: IStore, artifactory: ITestArtifactory, utils: IUtils) {
-          const pagesHandler = {
-            get(target, prop) {
-              console.log(`Getting pages property ${prop}`);
-              return target[prop];
-            },
-          };
-
-          const browserHandler = {
-            get(target, prop) {
-              console.log(`Getting browser property ${prop}`);
-              if (prop === "pages") {
-                // return target[prop];
-                return new Proxy(target[prop], pagesHandler);
-              } else {
-                return target[prop];
-              }
-            },
-          };
-          const proxy = new Proxy(utils.browser, browserHandler);
-
-          return fullTestInterface.afterAll(
-            store,
-            (fPath: string, value: unknown) =>
-              // TODO does not work?
-              {
-                artifactory(`afterAll4-${this.name}/${fPath}`, value);
-              },
-            utils
-            // {
-            //   ...utils,
-            //   browser: proxy,
-            // }
-          );
-        }
       } as any,
 
       class When extends BaseWhen<ITestShape> {
-        async andWhen(store, whenCB, testResource) {
-          return await fullTestInterface.andWhen(store, whenCB, testResource);
+        async andWhen(store, whenCB, testResource, pm) {
+          return await fullTestInterface.andWhen(
+            store,
+            whenCB,
+            testResource,
+            pm
+          );
         }
       } as any,
 
@@ -169,14 +171,15 @@ export default abstract class Testeranto<
           this.initialValues = initialValues;
         }
 
-        async checkThat(subject, testResourceConfiguration, artifactory) {
+        async checkThat(subject, testResourceConfiguration, artifactory, pm) {
           return fullTestInterface.beforeEach(
             subject,
             this.initialValues,
             (fPath: string, value: unknown) =>
               artifactory(`before/${fPath}`, value),
             testResourceConfiguration,
-            this.initialValues
+            this.initialValues,
+            pm
           );
         }
 
@@ -184,7 +187,7 @@ export default abstract class Testeranto<
           store: ITestShape["istore"],
           key: string,
           artifactory,
-          utils
+          pm
         ): Promise<unknown> {
           return new Promise((res) =>
             res(
@@ -194,21 +197,17 @@ export default abstract class Testeranto<
                 (fPath: string, value: unknown) =>
                   // TODO does not work?
                   artifactory(`afterEach2-${this.name}/${fPath}`, value),
-                utils
+                pm
               )
             )
           );
         }
       } as any,
 
-      testResourceRequirement,
-      logWriter
+      testResourceRequirement
+      // puppetMaster
     );
   }
 
-  abstract receiveTestResourceConfig(
-    t: ITestJob,
-    partialTestResource: ITTestResourceConfiguration,
-    utils: IUtils
-  );
+  abstract receiveTestResourceConfig(partialTestResource: string);
 }

package/src/lib/index.ts

@@ -1,3 +1,4 @@
+import { PM } from "../PM/index.js";
 import { IBaseTest } from "../Types.js";
 
 import {
@@ -7,15 +8,18 @@ import {
   BaseWhen,
   BaseThen,
 } from "./abstractBase.js";
+import { ITestInterface } from "./types.js";
 
-import { INodeUtils, ITestInterface, IUtils, IWebUtils } from "./types.js";
+// import { INodeUtils, ITestInterface, IUtils, IWebUtils } from "./types.js";
 
 export const BaseTestInterface: ITestInterface<IBaseTest> = {
   beforeAll: async (s) => s,
   beforeEach: async function (
     subject: any,
     initialValues: any,
-    testResource: any
+    x: any,
+    testResource: any,
+    pm: PM
   ) {
     return subject as any;
   },
@@ -39,7 +43,7 @@ export type ITTestResourceConfiguration = {
   name: string;
   fs: string;
   ports: number[];
-  scheduled: boolean;
+  browserWSEndpoint: string;
 };
 
 export type ITTestResourceRequirement = {
@@ -57,7 +61,7 @@ export type ITLog = (...string) => void;
 export type ILogWriter = {
   createWriteStream: (line: string) => any | any;
   writeFileSync: (fp: string, contents: string) => any;
-  mkdirSync: (fp: string) => any;
+  mkdirSync: () => any;
   testArtiFactoryfileWriter: (
     tLog: ITLog,
     n: (Promise) => void
@@ -74,7 +78,7 @@ type ITest = {
   testResourceConfiguration: ITTestResourceConfiguration;
 };
 
-export type ITestJob<T = INodeUtils | IWebUtils> = {
+export type ITestJob<T = PM> = {
   toObj(): object;
   test: ITest;
   runner: (
@@ -82,10 +86,7 @@ export type ITestJob<T = INodeUtils | IWebUtils> = {
     t: ITLog
   ) => Promise<BaseSuite<IBaseTest>>;
   testResourceRequirement: ITTestResourceRequirement;
-  receiveTestResourceConfig: (
-    testResource,
-    utils: T
-  ) => Promise<{
+  receiveTestResourceConfig: (pm: PM) => Promise<{
     failed: number;
     artifacts: Promise<unknown>[];
     logPromise: Promise<unknown>;