testeranto 0.62.0 → 0.73.0

package/src/lib/basebuilder.ts

@@ -1,45 +1,43 @@
+import { PassThrough } from "stream";
+
+import {
+  ITTestResourceRequest,
+  ITestJob,
+  ITLog,
+  ILogWriter,
+  ITTestResourceConfiguration,
+} from ".";
+import { IBaseTest, ITestSpecification } from "../Types.js";
 
 import {
-  IBaseTest,
-  ICheckKlasser,
-  IGivenKlasser,
   ISuiteKlasser,
-  ITestSpecification,
+  IGivenKlasser,
+  IWhenKlasser,
   IThenKlasser,
-  IUtils,
-  IWhenKlasser
-} from "../Types";
+  ICheckKlasser,
+  // IUtils,
+} from "./types.js";
 
 import {
-
   BaseCheck,
   BaseSuite,
   BaseWhen,
   BaseThen,
-  BaseGiven
+  BaseGiven,
 } from "./abstractBase.js";
+import { PM } from "../PM/index.js";
 
-import {
-  ITTestResourceRequest,
-  ITestJob,
-  ITLog,
-  ILogWriter,
-  ITTestResourceConfiguration,
-} from ".";
 export abstract class BaseBuilder<
   ITestShape extends IBaseTest,
   SuiteExtensions,
   GivenExtensions,
   WhenExtensions,
   ThenExtensions,
-  CheckExtensions,
+  CheckExtensions
 > {
-
   specs: any;
 
-  assertThis: (t: any) => {
-
-  }
+  assertThis: (t: ITestShape["then"]) => {};
 
   testResourceRequirement: ITTestResourceRequest;
   artifacts: Promise<unknown>[] = [];
@@ -50,17 +48,18 @@ 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'],
+    public readonly input: ITestShape["iinput"],
     suitesOverrides: Record<keyof SuiteExtensions, ISuiteKlasser<ITestShape>>,
     givenOverides: Record<keyof GivenExtensions, IGivenKlasser<ITestShape>>,
     whenOverides: Record<keyof WhenExtensions, IWhenKlasser<ITestShape>>,
     thenOverides: Record<keyof ThenExtensions, IThenKlasser<ITestShape>>,
     checkOverides: Record<keyof CheckExtensions, ICheckKlasser<ITestShape>>,
-    logWriter: ILogWriter,
     testResourceRequirement: ITTestResourceRequest,
-    testSpecification: any,
+    testSpecification: any
+    // puppetMaster: PM
   ) {
     this.artifacts = [];
     this.testResourceRequirement = testResourceRequirement;
@@ -70,53 +69,52 @@ export abstract class BaseBuilder<
     this.thenOverides = thenOverides;
     this.checkOverides = checkOverides;
     this.testSpecification = testSpecification;
+    // this.puppetMaster = puppetMaster;
 
     this.specs = testSpecification(
       this.Suites(),
       this.Given(),
       this.When(),
       this.Then(),
-      this.Check(),
+      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>) => {
+      const suiteRunner =
+        (suite: BaseSuite<ITestShape>) =>
+        async (
+          // testResourceConfiguration: ITTestResourceConfiguration,
+          puppetMaster: PM,
+          tLog: ITLog
+        ): Promise<BaseSuite<ITestShape>> => {
+          await puppetMaster.startPuppeteer(
+            {
+              browserWSEndpoint:
+                puppetMaster.testResourceConfiguration.browserWSEndpoint,
+            },
+            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
+          );
+        };
 
-    this.testJobs = this.specs.map((
-      suite: BaseSuite<ITestShape>,
-      utils: IUtils
-    ) => {
-      const runner = suiteRunner(suite, utils);
+      const runner = suiteRunner(suite);
 
       return {
         test: suite,
-        testResourceRequirement,
+        // testResourceRequirement,
 
         toObj: () => {
           return suite.toObj();
@@ -125,63 +123,74 @@ export abstract class BaseBuilder<
         runner,
 
         receiveTestResourceConfig: async function (
-          testResourceConfiguration = {
-            name: "",
-            fs: ".",
-            ports: [],
-            scheduled: false
-          },
-          y: IUtils
+          // testResourceConfiguration = {
+          //   name: "",
+          //   fs: ".",
+          //   ports: [],
+          //   browserWSEndpoint: "",
+          // },
+          puppetMaster: PM
         ) {
-          console.log(
-            `testResourceConfiguration ${JSON.stringify(
-              testResourceConfiguration,
-              null,
-              2
-            )}`
-          );
-          await logWriter.mkdirSync(testResourceConfiguration.fs);
-          logWriter.writeFileSync(
-            `${testResourceConfiguration.fs}/tests.json`,
-            JSON.stringify(this.toObj(), null, 2)
-          );
-
-          const logFilePath = `${testResourceConfiguration.fs}/log.txt`;
-
-          const access = await logWriter.createWriteStream(logFilePath);
-
+          // 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[]) => {
-            // console.log(...l);
-            access.write(`${l.toString()}\n`);
+            // access.write(`${l.toString()}\n`);
+            // console.log("tLog", l);
+            puppetMaster.write(access, `${l.toString()}\n`);
           };
-          const suiteDone: BaseSuite<
-            ITestShape
-          > = await runner(testResourceConfiguration, tLog, y);
-          const resultsFilePath = (
-            `${testResourceConfiguration.fs}/results.json`
-          );
 
-          logWriter.writeFileSync(
-            resultsFilePath,
-            JSON.stringify(suiteDone.toObj(), null, 2)
+          const suiteDone: BaseSuite<ITestShape> = await runner(
+            puppetMaster,
+            tLog
           );
 
           const logPromise = new Promise((res, rej) => {
-            access.on("finish", () => { res(true); });
-          })
-          access.end();
-
-          const numberOfFailures = Object.keys(suiteDone.givens).filter(
-            (k) => {
-              // console.log(`suiteDone.givens[k].error`, suiteDone.givens[k].error);
-              return suiteDone.givens[k].error
-            }
-          ).length;
+            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
+            logPromise,
           };
         },
       };
@@ -200,26 +209,17 @@ export abstract class BaseBuilder<
     (
       name: string,
       features: string[],
-      whens: BaseWhen<
-        ITestShape
-      >[],
-      thens: BaseThen<
-        ITestShape
-      >[],
-      gcb,
-    ) => BaseGiven<
-      ITestShape
-    >
+      whens: BaseWhen<ITestShape>[],
+      thens: BaseThen<ITestShape>[],
+      gcb
+    ) => BaseGiven<ITestShape>
   > {
     return this.givenOverides;
   }
 
   When(): Record<
     keyof WhenExtensions,
-    (arg0: ITestShape['istore'], ...arg1: any) =>
-      BaseWhen<
-        ITestShape
-      >
+    (arg0: ITestShape["istore"], ...arg1: any) => BaseWhen<ITestShape>
   > {
     return this.whenOverides;
   }
@@ -227,11 +227,9 @@ export abstract class BaseBuilder<
   Then(): Record<
     keyof ThenExtensions,
     (
-      selection: ITestShape['iselection'],
+      selection: ITestShape["iselection"],
       expectation: any
-    ) => BaseThen<
-      ITestShape
-    >
+    ) => BaseThen<ITestShape>
   > {
     return this.thenOverides;
   }
@@ -244,10 +242,8 @@ export abstract class BaseBuilder<
       whens,
       thens,
       x
-    ) => BaseCheck<
-      ITestShape
-    >
+    ) => BaseCheck<ITestShape>
   > {
     return this.checkOverides;
   }
-}
+}

package/src/lib/classBuilder.ts

@@ -1,46 +1,35 @@
-import type {
+import {
   IBaseTest,
-  ICheckKlasser,
-  IGivenKlasser,
-  ISuiteKlasser,
   ITestImplementation,
   ITestSpecification,
-  IThenKlasser,
-  IWhenKlasser,
-} from "../Types";
+} from "../Types.js";
 
+import { BaseBuilder } from "./basebuilder.js";
 
 import {
-  BaseBuilder
-} from "./basebuilder.js";
-
-import {
-  ILogWriter,
-  ITTestResourceRequest
-} from ".";
+  ISuiteKlasser,
+  IGivenKlasser,
+  IWhenKlasser,
+  IThenKlasser,
+  ICheckKlasser,
+} from "./types.js";
+import { PM } from "../PM/index.js";
+import { ITTestResourceRequest } from "./index.js";
 
 export abstract class ClassBuilder<
   ITestShape extends IBaseTest
-> extends BaseBuilder<
-  ITestShape,
-  any,
-  any,
-  any,
-  any,
-  any
-> {
-
+> extends BaseBuilder<ITestShape, any, any, any, any, any> {
   constructor(
     testImplementation: ITestImplementation<ITestShape, any>,
     testSpecification: ITestSpecification<ITestShape>,
-    input: ITestShape['iinput'],
+    input: ITestShape["iinput"],
     suiteKlasser: ISuiteKlasser<ITestShape>,
     givenKlasser: IGivenKlasser<ITestShape>,
     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) => {
@@ -56,28 +45,22 @@ export abstract class ClassBuilder<
       },
       {}
     );
-    const classyGivens = Object.entries(testImplementation.givens)
-      .reduce(
-        (a, [key, givEn]) => {
-          a[key] = (
+    const classyGivens = Object.entries(testImplementation.givens).reduce(
+      (a, [key, givEn]) => {
+        a[key] = (features, whens, thens, givEn) => {
+          return new givenKlasser.prototype.constructor(
+            key,
             features,
             whens,
             thens,
-            givEn,
-          ) => {
-            return new (givenKlasser.prototype).constructor(
-              key,
-              features,
-              whens,
-              thens,
-              testImplementation.givens[key],
-              givEn
-            );
-          };
-          return a;
-        },
-        {}
-      );
+            testImplementation.givens[key],
+            givEn
+          );
+        };
+        return a;
+      },
+      {}
+    );
 
     const classyWhens = Object.entries(testImplementation.whens).reduce(
       (a, [key, whEn]: [string, (x) => any]) => {
@@ -128,10 +111,9 @@ export abstract class ClassBuilder<
       classyWhens,
       classyThens,
       classyChecks,
-      logWriter,
       testResourceRequirement,
       testSpecification
+      // puppetMaster
     );
   }
-
-}
+}