testeranto 0.62.0 → 0.70.0

package/src/lib/basebuilder.ts

@@ -1,45 +1,40 @@
+import {
+  ITTestResourceRequest,
+  ITestJob,
+  ITLog,
+  ILogWriter,
+  ITTestResourceConfiguration,
+} from ".";
+import { IBaseTest, ITestSpecification } from "../Types.js";
 
 import {
-  IBaseTest,
-  ICheckKlasser,
-  IGivenKlasser,
   ISuiteKlasser,
-  ITestSpecification,
+  IGivenKlasser,
+  IWhenKlasser,
   IThenKlasser,
+  ICheckKlasser,
   IUtils,
-  IWhenKlasser
-} from "../Types";
+} from "./types.js";
 
 import {
-
   BaseCheck,
   BaseSuite,
   BaseWhen,
   BaseThen,
-  BaseGiven
+  BaseGiven,
 } from "./abstractBase.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>[] = [];
@@ -52,7 +47,7 @@ export abstract class BaseBuilder<
   checkOverides: Record<keyof CheckExtensions, ICheckKlasser<ITestShape>>;
 
   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>>,
@@ -60,7 +55,7 @@ export abstract class BaseBuilder<
     checkOverides: Record<keyof CheckExtensions, ICheckKlasser<ITestShape>>,
     logWriter: ILogWriter,
     testResourceRequirement: ITTestResourceRequest,
-    testSpecification: any,
+    testSpecification: any
   ) {
     this.artifacts = [];
     this.testResourceRequirement = testResourceRequirement;
@@ -76,116 +71,109 @@ export abstract class BaseBuilder<
       this.Given(),
       this.When(),
       this.Then(),
-      this.Check(),
+      this.Check()
     );
 
-    const suiteRunner = (
-      suite: BaseSuite<ITestShape>,
-      utils: IUtils
-    ) =>
+    const suiteRunner =
+      (suite: BaseSuite<ITestShape>, utils: IUtils) =>
       async (
         testResourceConfiguration: ITTestResourceConfiguration,
         tLog: ITLog,
         utils: IUtils
-      ): Promise<BaseSuite<
-        ITestShape
-      >> => {
+      ): Promise<BaseSuite<ITestShape>> => {
         return await suite.run(
           input,
           testResourceConfiguration,
-          (
-            fPath: string,
-            value: unknown
-          ) =>
+          (fPath: string, value: unknown) =>
             logWriter.testArtiFactoryfileWriter(tLog, (p: Promise<void>) => {
               this.artifacts.push(p);
-            })(
-              testResourceConfiguration.fs + "/" + fPath,
-              value
-            ),
+            })(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,
+    this.testJobs = this.specs.map(
+      (suite: BaseSuite<ITestShape>, utils: IUtils) => {
+        const runner = suiteRunner(suite, utils);
 
-        toObj: () => {
-          return suite.toObj();
-        },
+        return {
+          test: suite,
+          testResourceRequirement,
 
-        runner,
-
-        receiveTestResourceConfig: async function (
-          testResourceConfiguration = {
-            name: "",
-            fs: ".",
-            ports: [],
-            scheduled: false
+          toObj: () => {
+            return suite.toObj();
           },
-          y: IUtils
-        ) {
-          console.log(
-            `testResourceConfiguration ${JSON.stringify(
+
+          runner,
+
+          receiveTestResourceConfig: async function (
+            testResourceConfiguration = {
+              name: "",
+              fs: ".",
+              ports: [],
+              scheduled: false,
+            },
+            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,
-              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);
-
-          const tLog = (...l: string[]) => {
-            // console.log(...l);
-            access.write(`${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 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;
-          console.log(`exiting gracefully with ${numberOfFailures} failures.`);
-          return {
-            failed: numberOfFailures,
-            artifacts: this.artifacts || [],
-            logPromise
-          };
-        },
-      };
-    });
+              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,
+            };
+          },
+        };
+      }
+    );
   }
 
   Specs() {
@@ -200,26 +188,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 +206,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 +221,8 @@ export abstract class BaseBuilder<
       whens,
       thens,
       x
-    ) => BaseCheck<
-      ITestShape
-    >
+    ) => BaseCheck<ITestShape>
   > {
     return this.checkOverides;
   }
-}
+}

package/src/lib/classBuilder.ts

@@ -1,39 +1,27 @@
-import type {
+import {
   IBaseTest,
-  ICheckKlasser,
-  IGivenKlasser,
-  ISuiteKlasser,
   ITestImplementation,
   ITestSpecification,
-  IThenKlasser,
-  IWhenKlasser,
-} from "../Types";
+} from "../Types.js";
 
+import { BaseBuilder } from "./basebuilder.js";
 
+import { ILogWriter, ITTestResourceRequest } from ".";
 import {
-  BaseBuilder
-} from "./basebuilder.js";
-
-import {
-  ILogWriter,
-  ITTestResourceRequest
-} from ".";
+  ISuiteKlasser,
+  IGivenKlasser,
+  IWhenKlasser,
+  IThenKlasser,
+  ICheckKlasser,
+} from "./types.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>,
@@ -56,28 +44,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]) => {
@@ -133,5 +115,4 @@ export abstract class ClassBuilder<
       testSpecification
     );
   }
-
-}
+}