testeranto 0.62.0 → 0.73.0

package/src/lib/core.ts

@@ -1,7 +1,11 @@
-import type {
-  IBaseTest, ITestImplementation, ITestInterface, ITestSpecification, IUtils
-} from "../Types";
+import { IStore } from "../SubPackages/react/jsx";
+import {
+  IBaseTest,
+  ITestSpecification,
+  ITestImplementation,
+} from "../Types.js";
 
+import { ITestInterface } from "./types.js";
 import {
   DefaultTestInterface,
   ILogWriter,
@@ -9,66 +13,92 @@ import {
   ITTestResourceRequest,
   ITestArtifactory,
   ITestJob,
-  defaultTestResourceRequirement
+  defaultTestResourceRequirement,
 } from "./index.js";
 import {
-  BaseSuite, BaseGiven, BaseWhen, BaseThen, BaseCheck
+  BaseSuite,
+  BaseGiven,
+  BaseWhen,
+  BaseThen,
+  BaseCheck,
 } from "./abstractBase.js";
-import {
-  ClassBuilder
-} from "./classBuilder.js";
-import { IStore } from "../SubPackages/react/jsx";
+import { ClassBuilder } from "./classBuilder.js";
+import { PM } from "../PM/index";
 
-export default abstract class Testeranto<ITestShape extends IBaseTest> extends ClassBuilder<ITestShape> {
+export default abstract class Testeranto<
+  ITestShape extends IBaseTest
+> extends ClassBuilder<ITestShape> {
   constructor(
-    input: ITestShape['iinput'],
+    input: ITestShape["iinput"],
     testSpecification: ITestSpecification<ITestShape>,
-    testImplementation: ITestImplementation<ITestShape, object>,
+    testImplementation: ITestImplementation<ITestShape>,
     testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
-    logWriter: ILogWriter,
-    testInterface: Partial<ITestInterface<ITestShape>>,
+    testInterface: Partial<ITestInterface<ITestShape>>
+    // puppetMaster: PM
   ) {
     const fullTestInterface = DefaultTestInterface(testInterface);
-
     super(
       testImplementation,
       testSpecification,
       input,
 
-      class extends BaseSuite<
-        ITestShape
-      > {
+      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);
         }
 
         async setup(
-          s: ITestShape['iinput'],
+          s: ITestShape["iinput"],
           artifactory: ITestArtifactory,
           tr,
-          // utils: ITestInterface<ITestShape>
-        ): Promise<
-          ITestShape['isubject']
-        > {
-          return (fullTestInterface.beforeAll || (async (
-            input: ITestShape['iinput'],
-            artifactory: ITestArtifactory,
-            tr,
-            // utils: ITestInterface<ITestShape>
-          ) => input as any))(
-            s,
-            this.testResourceConfiguration,
-            artifactory
-          );
+          pm
+        ): Promise<ITestShape["isubject"]> {
+          return (
+            fullTestInterface.beforeAll ||
+            (async (
+              input: ITestShape["iinput"],
+              artifactory: ITestArtifactory,
+              tr,
+              pm: PM
+            ) => input as any)
+          )(s, this.testResourceConfiguration, artifactory, pm);
         }
       } as any,
 
-      class Given extends BaseGiven<
-        ITestShape
-      > {
-
-        async givenThat(subject, testResource, artifactory, initializer) {
+      class Given extends BaseGiven<ITestShape> {
+        async givenThat(subject, testResource, artifactory, initializer, pm) {
           return fullTestInterface.beforeEach(
             subject,
             initializer,
@@ -77,60 +107,56 @@ export default abstract class Testeranto<ITestShape extends IBaseTest> extends C
               artifactory(`beforeEach/${fPath}`, value),
             testResource,
             this.initialValues,
-            // utils,
+            pm
           );
         }
 
         afterEach(
-          store: ITestShape['istore'],
+          store: ITestShape["istore"],
           key: string,
-          artifactory
+          artifactory,
+          pm
         ): Promise<unknown> {
           return new Promise((res) =>
-            res(fullTestInterface.afterEach(store, key, (fPath: string, value: unknown) =>
-              artifactory(`after/${fPath}`, value)))
-          );
-        }
-        afterAll(
-          store: IStore,
-          artifactory: ITestArtifactory,
-          utils: IUtils,
-        ) {
-          return fullTestInterface.afterAll(store, (fPath: string, value: unknown) =>
-          // TODO does not work?
-          { artifactory(`afterAll4-${this.name}/${fPath}`, value) },
-            utils
+            res(
+              fullTestInterface.afterEach(
+                store,
+                key,
+                (fPath: string, value: unknown) =>
+                  artifactory(`after/${fPath}`, value),
+                pm
+              )
+            )
           );
         }
       } as any,
 
-      class When extends BaseWhen<
-        ITestShape
-      > {
-        async andWhen(store, whenCB, testResource) {
-          return await fullTestInterface.andWhen(store, whenCB, testResource);
+      class When extends BaseWhen<ITestShape> {
+        async andWhen(store, whenCB, testResource, pm) {
+          return await fullTestInterface.andWhen(
+            store,
+            whenCB,
+            testResource,
+            pm
+          );
         }
       } as any,
 
-      class Then extends BaseThen<
-        ITestShape
-      > {
-
+      class Then extends BaseThen<ITestShape> {
         async butThen(
           store: any,
           thenCB,
           testResourceConfiguration?: any
-        ): Promise<ITestShape['iselection']> {
+        ): Promise<ITestShape["iselection"]> {
           return await fullTestInterface.butThen(
             store,
             thenCB,
-            testResourceConfiguration);
+            testResourceConfiguration
+          );
         }
       } as any,
 
-      class Check extends BaseCheck<
-        ITestShape
-      > {
+      class Check extends BaseCheck<ITestShape> {
         initialValues: any;
 
         constructor(
@@ -145,38 +171,43 @@ export default abstract class Testeranto<ITestShape extends IBaseTest> extends C
           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),
+            (fPath: string, value: unknown) =>
+              artifactory(`before/${fPath}`, value),
             testResourceConfiguration,
-            this.initialValues
+            this.initialValues,
+            pm
           );
         }
 
         afterEach(
-          store: ITestShape['istore'],
+          store: ITestShape["istore"],
           key: string,
-          artifactory
+          artifactory,
+          pm
         ): Promise<unknown> {
           return new Promise((res) =>
-            res(fullTestInterface.afterEach(store, key, (fPath: string, value: unknown) =>
-              // TODO does not work?
-              artifactory(`afterEach2-${this.name}/${fPath}`, value)))
+            res(
+              fullTestInterface.afterEach(
+                store,
+                key,
+                (fPath: string, value: unknown) =>
+                  // TODO does not work?
+                  artifactory(`afterEach2-${this.name}/${fPath}`, value),
+                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,29 +1,49 @@
+import { PM } from "../PM/index.js";
+import { IBaseTest } from "../Types.js";
 
-import { IBaseTest, ITestInterface, IUtils } from "../Types.js";
-import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen } from "./abstractBase.js";
+import {
+  IGivens,
+  BaseCheck,
+  BaseSuite,
+  BaseWhen,
+  BaseThen,
+} from "./abstractBase.js";
+import { ITestInterface } 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) { return subject as any; },
-  afterEach: (async (s) => s),
-  afterAll: ((store: IBaseTest['istore']) => undefined),
-  butThen: (async (store: IBaseTest['istore'], thenCb) => thenCb(store)),
-  andWhen: ((a) => a),
-  assertThis: (() => null),
+  beforeAll: async (s) => s,
+  beforeEach: async function (
+    subject: any,
+    initialValues: any,
+    x: any,
+    testResource: any,
+    pm: PM
+  ) {
+    return subject as any;
+  },
+  afterEach: async (s) => s,
+  afterAll: (store: IBaseTest["istore"]) => undefined,
+  butThen: async (store: IBaseTest["istore"], thenCb) => thenCb(store),
+  andWhen: (a) => a,
+  assertThis: () => null,
 };
 
-export const DefaultTestInterface = (p: Partial<ITestInterface<any>>): ITestInterface<any> => {
+export const DefaultTestInterface = (
+  p: Partial<ITestInterface<any>>
+): ITestInterface<any> => {
   return {
     ...BaseTestInterface,
-    ...p
-  }
-}
+    ...p,
+  };
+};
 
 export type ITTestResourceConfiguration = {
   name: string;
   fs: string;
   ports: number[];
-  scheduled: boolean;
+  browserWSEndpoint: string;
 };
 
 export type ITTestResourceRequirement = {
@@ -39,51 +59,44 @@ export type ITTestResourceRequest = {
 export type ITLog = (...string) => void;
 
 export type ILogWriter = {
-  createWriteStream: (line: string) => any | any,
-  writeFileSync: (fp: string, contents: string) => any
-  mkdirSync: (fp: string) => any
-  testArtiFactoryfileWriter: (tLog: ITLog, n: (Promise) => void) =>
-    (fPath: string, value: unknown) =>
-      void
-}
+  createWriteStream: (line: string) => any | any;
+  writeFileSync: (fp: string, contents: string) => any;
+  mkdirSync: () => any;
+  testArtiFactoryfileWriter: (
+    tLog: ITLog,
+    n: (Promise) => void
+  ) => (fPath: string, value: unknown) => void;
+};
 
 export type ITestArtificer = (key: string, data: any) => void;
 
 type ITest = {
   toObj(): object;
   name: string;
-  givens: IGivens<
-    IBaseTest
-  >;
-  checks: BaseCheck<
-    IBaseTest
-  >[];
+  givens: IGivens<IBaseTest>;
+  checks: BaseCheck<IBaseTest>[];
   testResourceConfiguration: ITTestResourceConfiguration;
 };
 
-export type ITestJob = {
+export type ITestJob<T = PM> = {
   toObj(): object;
   test: ITest;
-  runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<
-    BaseSuite<
-      IBaseTest
-    >
-  >;
+  runner: (
+    x: ITTestResourceConfiguration,
+    t: ITLog
+  ) => Promise<BaseSuite<IBaseTest>>;
   testResourceRequirement: ITTestResourceRequirement;
-  receiveTestResourceConfig: (
-    testResource,
-    utils: IUtils
-  ) => Promise<{
-    failed: number,
-    artifacts: Promise<unknown>[],
-    logPromise: Promise<unknown>
-  }>
+  receiveTestResourceConfig: (pm: PM) => Promise<{
+    failed: number;
+    artifacts: Promise<unknown>[];
+    logPromise: Promise<unknown>;
+  }>;
 };
 
 export type ITestResults = Promise<{ test: ITest }>[];
 
 export const defaultTestResourceRequirement: ITTestResourceRequest = {
-  ports: 0
+  ports: 0,
 };
 
 export type ITestArtifactory = (key: string, value: unknown) => unknown;
@@ -94,23 +107,12 @@ export type ITestCheckCallback<ITestShape extends IBaseTest> = {
     features: string[],
     callbackA: (
       whens: {
-        [K in keyof ITestShape["whens"]]: (
-          ...unknown
-        ) => BaseWhen<
-          ITestShape
-        >;
+        [K in keyof ITestShape["whens"]]: (...unknown) => BaseWhen<ITestShape>;
       },
       thens: {
-        [K in keyof ITestShape["thens"]]: (
-          ...unknown
-        ) => BaseThen<
-          ITestShape
-        >;
+        [K in keyof ITestShape["thens"]]: (...unknown) => BaseThen<ITestShape>;
       }
     ) => Promise<any>,
     ...xtrasA: ITestShape["checks"][K]
-  ) => BaseCheck<
-    ITestShape
-  >;
+  ) => BaseCheck<ITestShape>;
 };
-

package/src/lib/types.ts

@@ -0,0 +1,197 @@
+import { IBaseTest } from "../Types";
+
+// import puppeteer from "puppeteer-core";
+import {
+  IGivens,
+  BaseCheck,
+  BaseSuite,
+  BaseGiven,
+  BaseWhen,
+  BaseThen,
+} from "./abstractBase";
+import { ITTestResourceConfiguration, ITestArtificer } from ".";
+import { PM } from "../PM/index";
+
+export type IRunTime = `node` | `web`;
+
+export type ITestTypes = [string, IRunTime, { ports: number }, ITestTypes[]];
+
+export type IJsonConfig = {
+  outdir: string;
+  tests: ITestTypes[];
+  features: string;
+};
+
+export type IBaseConfig = {
+  clearScreen: boolean;
+  debugger: boolean;
+  devMode: boolean;
+  externals: string[];
+  features: string;
+  minify: boolean;
+  nodePlugins: any[];
+  outbase: string;
+  outdir: string;
+  ports: string[];
+  tests: ITestTypes[];
+  webPlugins: any[];
+};
+
+export type IBuiltConfig = { buildDir: string } & IBaseConfig;
+
+export type IWebTestInterface<ITestShape extends IBaseTest> = {
+  assertThis: (x: ITestShape["then"]) => void;
+
+  andWhen: (
+    store: ITestShape["istore"],
+    whenCB: ITestShape["when"],
+    testResource: ITTestResourceConfiguration
+  ) => Promise<ITestShape["istore"]>;
+  butThen: (
+    store: ITestShape["istore"],
+    thenCB,
+    testResource: ITTestResourceConfiguration
+  ) => Promise<ITestShape["iselection"]>;
+
+  afterAll: (
+    store: ITestShape["istore"],
+    artificer: ITestArtificer,
+    utils: PM
+  ) => any;
+  afterEach: (
+    store: ITestShape["istore"],
+    key: string,
+    artificer: ITestArtificer,
+    utils: PM
+  ) => Promise<unknown>;
+  beforeAll: (
+    input: ITestShape["iinput"],
+    testResource: ITTestResourceConfiguration,
+    artificer: ITestArtificer,
+    utils: PM
+  ) => Promise<ITestShape["isubject"]>;
+  beforeEach: (
+    subject: ITestShape["isubject"],
+    initializer: (c?) => ITestShape["given"],
+    artificer: ITestArtificer,
+    testResource: ITTestResourceConfiguration,
+    initialValues,
+    utils: PM
+  ) => Promise<ITestShape["istore"]>;
+};
+// & ITestInterface<ITestShape>;
+
+export type INodeTestInterface<ITestShape extends IBaseTest> = {
+  assertThis: (x: ITestShape["then"]) => void;
+  andWhen: (
+    store: ITestShape["istore"],
+    whenCB: ITestShape["when"],
+    testResource: ITTestResourceConfiguration
+  ) => Promise<ITestShape["istore"]>;
+  butThen: (
+    store: ITestShape["istore"],
+    thenCB,
+    testResource: ITTestResourceConfiguration
+  ) => Promise<ITestShape["iselection"]>;
+  afterAll: (
+    store: ITestShape["istore"],
+    artificer: ITestArtificer,
+    pm: PM
+  ) => any;
+  afterEach: (
+    store: ITestShape["istore"],
+    key: string,
+    artificer: ITestArtificer,
+    pm: PM
+  ) => Promise<unknown>;
+  beforeAll: (
+    input: ITestShape["iinput"],
+    testResource: ITTestResourceConfiguration,
+    artificer: ITestArtificer,
+    pm: PM
+  ) => Promise<ITestShape["isubject"]>;
+  beforeEach: (
+    subject: ITestShape["isubject"],
+    initializer: (c?) => ITestShape["given"],
+    artificer: ITestArtificer,
+    testResource: ITTestResourceConfiguration,
+    initialValues
+    // utils: IUtils
+  ) => Promise<ITestShape["istore"]>;
+};
+// & ITestInterface<ITestShape>;
+
+export type ITestInterface<ITestShape extends IBaseTest> = {
+  assertThis: (x: ITestShape["then"]) => void;
+
+  andWhen: (
+    store: ITestShape["istore"],
+    whenCB: ITestShape["when"],
+    testResource: ITTestResourceConfiguration,
+    pm: PM
+  ) => Promise<ITestShape["istore"]>;
+  butThen: (
+    store: ITestShape["istore"],
+    thenCB,
+    testResource: ITTestResourceConfiguration
+  ) => Promise<ITestShape["iselection"]>;
+
+  afterAll: (
+    store: ITestShape["istore"],
+    artificer: ITestArtificer,
+    pm: PM
+  ) => any;
+  afterEach: (
+    store: ITestShape["istore"],
+    key: string,
+    artificer: ITestArtificer,
+    pm: PM
+  ) => Promise<unknown>;
+  beforeAll: (
+    input: ITestShape["iinput"],
+    testResource: ITTestResourceConfiguration,
+    artificer: ITestArtificer,
+    pm: PM
+  ) => Promise<ITestShape["isubject"]>;
+  beforeEach: (
+    subject: ITestShape["isubject"],
+    initializer: (c?) => ITestShape["given"],
+    artificer: ITestArtificer,
+    testResource: ITTestResourceConfiguration,
+    initialValues,
+    pm: PM
+  ) => Promise<ITestShape["istore"]>;
+};
+
+export type ISuiteKlasser<ITestShape extends IBaseTest> = (
+  name: string,
+  index: number,
+  givens: IGivens<ITestShape>,
+  checks: BaseCheck<ITestShape>[]
+) => BaseSuite<ITestShape>;
+
+export type IGivenKlasser<ITestShape extends IBaseTest> = (
+  name,
+  features,
+  whens,
+  thens,
+  givenCB
+) => BaseGiven<ITestShape>;
+
+export type IWhenKlasser<ITestShape extends IBaseTest> = (
+  s,
+  o
+) => BaseWhen<ITestShape>;
+
+export type IThenKlasser<ITestShape extends IBaseTest> = (
+  s,
+  o
+) => BaseThen<ITestShape>;
+
+export type ICheckKlasser<ITestShape extends IBaseTest> = (
+  n,
+  f,
+  cb,
+  w,
+  t
+) => BaseCheck<ITestShape>;