testeranto 0.62.0 → 0.70.0

package/src/esbuildConfigs/report.ts

@@ -1,51 +1,15 @@
-// import { jsonc } from "jsonc";
-
-// import { IBaseConfig, IJsonConfig } from "../Types";
-
-// import baseEsBuildConfig from "./index.js";
-
-// import fs from "fs"
-// import { BuildOptions } from "esbuild";
-// // import { CssModulesPlugin } from 'esbuild-css-modules-plugin';
-// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
-
-// export default (config: IBaseConfig): BuildOptions => {
-//   return {
-//     bundle: true,
-//     entryPoints: ["./node_modules/testeranto/dist/module/report.js"],
-//     minify: config.minify === true,
-//     outbase: config.outbase,
-//     write: true,
-//     outfile: `${jsonConfig.outdir}/report.js`,
-//     external: [
-//       "tests.json",
-//       "features.test.js"
-//     ],
-//     // plugins: [
-//     //   CssModulesPlugin({
-//     //     // @see https://github.com/indooorsman/esbuild-css-modules-plugin/blob/main/index.d.ts for more details
-//     //     force: true,
-//     //     emitDeclarationFile: true,
-//     //     localsConvention: 'camelCaseOnly',
-//     //     namedExports: true,
-//     //     inject: false
-//     //   })
-//     // ]
-//   }
-//   // return {
-//   //   bundle: true,
-//   //   entryPoints: [
-//   //     "./node_modules/testeranto/dist/module/Report.js",
-//   //     jsonConfig.features
-//   //   ],
-//   //   minify: config.minify === true,
-//   //   outbase: ".",
-//   //   outdir: 'docs',
-//   //   write: true,
-//   //   // outfile: `${jsonConfig.outdir}/Report.js`,
-//   //   external: [
-//   //     "features.test.js",
-//   //     "testeranto.json"
-//   //   ]
-//   // }
-// }
+import { BuildOptions } from "esbuild";
+
+import { IBaseConfig } from "../lib/types";
+
+export default (config: IBaseConfig): BuildOptions => {
+  return {
+    bundle: true,
+    entryPoints: ["./node_modules/testeranto/dist/module/report.js"],
+    minify: config.minify === true,
+    outbase: config.outbase,
+    write: true,
+    outfile: `${config.outdir}/report.js`,
+    external: ["tests.json", "features.test.js"],
+  };
+};

package/src/esbuildConfigs/tests.ts

@@ -1,11 +1,5 @@
-import { jsonc } from "jsonc";
-
-import { IBaseConfig, IJsonConfig } from "../Types";
-
-import fs from "fs"
 import { BuildOptions } from "esbuild";
-
-// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
+import { IBaseConfig } from "../lib/types";
 
 export default (config: IBaseConfig): BuildOptions => {
   return {
@@ -16,5 +10,5 @@ export default (config: IBaseConfig): BuildOptions => {
     write: true,
     outfile: `${config.outdir}/tests.test.js`,
     // external: ["graphology"]
-  }
-}
+  };
+};

package/src/esbuildConfigs/web.ts

@@ -1,37 +1,34 @@
 import { BuildOptions } from "esbuild";
 import path from "path";
 
-import { IBaseConfig, IJsonConfig } from "../Types";
+import { IBaseConfig } from "../lib/types.js";
 
 import baseEsBuildConfig from "./index.js";
-import { jsonc } from "jsonc";
-import fs from "fs"
-
-// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
 
 export default (
   config: IBaseConfig,
   entryPoints: Set<string> | string[]
 ): BuildOptions => {
   return {
-
     ...baseEsBuildConfig(config),
 
-    // inject: ['./node_modules/testeranto/dist/cjs-shim.js'],
+    // inject: ["./node_modules/testeranto/dist/cjs-shim.js"],
     // banner: {
-    //   js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+    //   js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
     // },
 
+    // splitting: true,
+
     outdir: config.outdir + "/web",
 
     alias: {
-      react: path.resolve("./node_modules/react")
+      react: path.resolve("./node_modules/react"),
     },
 
     external: [
       "testeranto.json",
       "features.test.ts",
-      // "url", 
+      // "url",
 
       "react",
       "electron",
@@ -49,7 +46,7 @@ export default (
       "readline",
       "zlib",
       "crypto",
-      "https"
+      "https",
     ],
 
     platform: "browser",
@@ -59,15 +56,18 @@ export default (
     plugins: [
       ...(config.webPlugins || []),
       {
-        name: 'rebuild-notify',
+        name: "rebuild-notify",
         setup(build) {
-          build.onEnd(result => {
+          build.onEnd((result) => {
             console.log(`web build ended with ${result.errors.length} errors`);
-            console.log(result)
-            result.errors.length !== 0 && process.exit(-1);
-          })
-        }
+            if (result.errors.length > 0) {
+              console.log(result);
+            }
+            // console.log(result);
+            // result.errors.length !== 0 && process.exit(-1);
+          });
+        },
       },
     ],
   };
-}
+};

package/src/lib/abstractBase.ts

@@ -1,41 +1,27 @@
+import { IBaseTest } from "../Types";
+
 import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
-import { IBaseTest, IUtils } from "../Types";
+import { IUtils } from "./types";
 
-export type IGivens<
-  ITestShape extends IBaseTest
-> = Record<
+export type IGivens<ITestShape extends IBaseTest> = Record<
   string,
-  BaseGiven<
-    ITestShape
-  >
+  BaseGiven<ITestShape>
 >;
 
-export abstract class BaseSuite<
-  ITestShape extends IBaseTest
-> {
+export abstract class BaseSuite<ITestShape extends IBaseTest> {
   name: string;
-  givens: IGivens<
-    ITestShape
-  >;
-  checks: BaseCheck<
-    ITestShape
-  >[];
-  store: ITestShape['istore'];
-  fails: BaseGiven<
-    ITestShape
-  >[];
+  givens: IGivens<ITestShape>;
+  checks: BaseCheck<ITestShape>[];
+  store: ITestShape["istore"];
+  fails: BaseGiven<ITestShape>[];
   testResourceConfiguration: ITTestResourceConfiguration;
   index: number;
 
   constructor(
     name: string,
     index: number,
-    givens: IGivens<
-      ITestShape
-    > = {},
-    checks: BaseCheck<
-      ITestShape
-    >[] = []
+    givens: IGivens<ITestShape> = {},
+    checks: BaseCheck<ITestShape>[] = []
   ) {
     this.name = name;
     this.index = index;
@@ -53,38 +39,31 @@ export abstract class BaseSuite<
   }
 
   setup(
-    s: ITestShape['iinput'],
+    s: ITestShape["iinput"],
     artifactory: ITestArtifactory,
     tr: ITTestResourceConfiguration,
     utils: IUtils
-  ): Promise<ITestShape['isubject']> {
-    return new Promise((res) => res(s as unknown as ITestShape['isubject']));
+  ): Promise<ITestShape["isubject"]> {
+    return new Promise((res) => res(s as unknown as ITestShape["isubject"]));
   }
 
-  assertThat(t: ITestShape['then']): unknown {
+  assertThat(t: ITestShape["then"]): unknown {
     // console.log("base assertThat")
     return t;
   }
 
   async run(
-    input: ITestShape['iinput'],
+    input: ITestShape["iinput"],
     testResourceConfiguration: ITTestResourceConfiguration,
-    artifactory: (
-      fPath: string,
-      value: unknown
-    ) => void,
+    artifactory: (fPath: string, value: unknown) => void,
     tLog: (...string) => void,
     utils: IUtils
-  ): Promise<
-    BaseSuite<
-      ITestShape
-    >
-  > {
+  ): Promise<BaseSuite<ITestShape>> {
     this.testResourceConfiguration = testResourceConfiguration;
     tLog("test resources: ", testResourceConfiguration);
 
     const suiteArtifactory = (fPath: string, value: unknown) =>
-      artifactory(`suite-${this.index}-${this.name}/${fPath}`, value)
+      artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
     const subject = await this.setup(
       input,
       suiteArtifactory,
@@ -126,7 +105,14 @@ export abstract class BaseSuite<
     // @TODO fix me
     for (const k of Object.keys(this.givens)) {
       const giver = this.givens[k];
-      giver.afterAll(this.store, artifactory, utils);
+
+      try {
+        giver.afterAll(this.store, artifactory, utils);
+      } catch (e) {
+        console.error(e);
+        this.fails.push(giver);
+        return this;
+      }
     }
     ////////////////
 
@@ -134,33 +120,23 @@ export abstract class BaseSuite<
   }
 }
 
-export abstract class BaseGiven<
-  ITestShape extends IBaseTest
-> {
+export abstract class BaseGiven<ITestShape extends IBaseTest> {
   name: string;
   features: string[];
-  whens: BaseWhen<
-    ITestShape
-  >[];
-  thens: BaseThen<
-    ITestShape
-  >[];
+  whens: BaseWhen<ITestShape>[];
+  thens: BaseThen<ITestShape>[];
   error: Error;
-  store: ITestShape['istore'];
+  store: ITestShape["istore"];
   recommendedFsPath: string;
-  givenCB: ITestShape['given'];
+  givenCB: ITestShape["given"];
   initialValues: any;
 
   constructor(
     name: string,
     features: string[],
-    whens: BaseWhen<
-      ITestShape
-    >[],
-    thens: BaseThen<
-      ITestShape
-    >[],
-    givenCB: ITestShape['given'],
+    whens: BaseWhen<ITestShape>[],
+    thens: BaseThen<ITestShape>[],
+    givenCB: ITestShape["given"],
     initialValues: any
   ) {
     this.name = name;
@@ -171,16 +147,12 @@ export abstract class BaseGiven<
     this.initialValues = initialValues;
   }
 
-  beforeAll(
-    store: ITestShape['istore'],
-    artifactory: ITestArtifactory,
-
-  ) {
+  beforeAll(store: ITestShape["istore"], artifactory: ITestArtifactory) {
     return store;
   }
 
   afterAll(
-    store: ITestShape['istore'],
+    store: ITestShape["istore"],
     artifactory: ITestArtifactory,
     utils: IUtils
   ) {
@@ -198,22 +170,23 @@ export abstract class BaseGiven<
   }
 
   abstract givenThat(
-    subject: ITestShape['isubject'],
+    subject: ITestShape["isubject"],
     testResourceConfiguration,
     artifactory: ITestArtifactory,
-    givenCB: ITestShape['given']
-  ): Promise<ITestShape['istore']>;
+    givenCB: ITestShape["given"]
+  ): Promise<ITestShape["istore"]>;
 
   async afterEach(
-    store: ITestShape['istore'],
+    store: ITestShape["istore"],
     key: string,
-    artifactory: ITestArtifactory
+    artifactory: ITestArtifactory,
+    utils: IUtils
   ): Promise<unknown> {
     return store;
   }
 
   async give(
-    subject: ITestShape['isubject'],
+    subject: ITestShape["isubject"],
     key: string,
     testResourceConfiguration,
     tester,
@@ -224,7 +197,7 @@ export abstract class BaseGiven<
     tLog(`\n Given: ${this.name}`);
 
     const givenArtifactory = (fPath: string, value: unknown) =>
-      artifactory(`given-${key}/${fPath}`, value)
+      artifactory(`given-${key}/${fPath}`, value);
     try {
       this.store = await this.givenThat(
         subject,
@@ -235,12 +208,7 @@ export abstract class BaseGiven<
 
       // tLog(`\n Given this.store`, this.store);
       for (const whenStep of this.whens) {
-        await whenStep.test(
-          this.store,
-          testResourceConfiguration,
-          tLog,
-          utils
-        );
+        await whenStep.test(this.store, testResourceConfiguration, tLog, utils);
       }
       for (const thenStep of this.thens) {
         const t = await thenStep.test(
@@ -258,7 +226,7 @@ export abstract class BaseGiven<
       // throw e;
     } finally {
       try {
-        await this.afterEach(this.store, key, givenArtifactory);
+        await this.afterEach(this.store, key, givenArtifactory, utils);
       } catch (e) {
         console.error("afterEach failed! no error will be recorded!", e);
       }
@@ -267,23 +235,22 @@ export abstract class BaseGiven<
   }
 }
 
-export abstract class BaseWhen<
-  ITestShape extends IBaseTest
-> {
+export abstract class BaseWhen<ITestShape extends IBaseTest> {
   public name: string;
-  whenCB: (x: ITestShape['iselection']) => ITestShape['then'];
+  whenCB: (x: ITestShape["iselection"]) => ITestShape["then"];
   error: boolean;
 
   constructor(
     name: string,
-    whenCB: (xyz: ITestShape['iselection']) => ITestShape['then']) {
+    whenCB: (xyz: ITestShape["iselection"]) => ITestShape["then"]
+  ) {
     this.name = name;
     this.whenCB = whenCB;
   }
 
   abstract andWhen(
-    store: ITestShape['istore'],
-    whenCB: (x: ITestShape['iselection']) => ITestShape['then'],
+    store: ITestShape["istore"],
+    whenCB: (x: ITestShape["iselection"]) => ITestShape["then"],
     testResource
   );
 
@@ -295,18 +262,14 @@ export abstract class BaseWhen<
   }
 
   async test(
-    store: ITestShape['istore'],
+    store: ITestShape["istore"],
     testResourceConfiguration,
     tLog: ITLog,
     utils: IUtils
   ) {
     tLog(" When:", this.name);
     try {
-      return await this.andWhen(
-        store,
-        this.whenCB,
-        testResourceConfiguration
-      );
+      return await this.andWhen(store, this.whenCB, testResourceConfiguration);
     } catch (e) {
       this.error = true;
       throw e;
@@ -314,14 +277,15 @@ export abstract class BaseWhen<
   }
 }
 
-export abstract class BaseThen<
-  ITestShape extends IBaseTest
-> {
+export abstract class BaseThen<ITestShape extends IBaseTest> {
   public name: string;
-  thenCB: (storeState: ITestShape['iselection']) => ITestShape['then'];
+  thenCB: (storeState: ITestShape["iselection"]) => ITestShape["then"];
   error: boolean;
 
-  constructor(name: string, thenCB: (val: ITestShape['iselection']) => ITestShape['then']) {
+  constructor(
+    name: string,
+    thenCB: (val: ITestShape["iselection"]) => ITestShape["then"]
+  ) {
     this.name = name;
     this.thenCB = thenCB;
   }
@@ -334,24 +298,24 @@ export abstract class BaseThen<
   }
 
   abstract butThen(
-    store: ITestShape['istore'],
+    store: ITestShape["istore"],
     thenCB,
     testResourceConfiguration?
-  ): Promise<ITestShape['iselection']>;
+  ): Promise<ITestShape["iselection"]>;
 
   async test(
-    store: ITestShape['istore'],
+    store: ITestShape["istore"],
     testResourceConfiguration,
     tLog: ITLog,
     utils: IUtils
-  ): Promise<ITestShape['then'] | undefined> {
+  ): Promise<ITestShape["then"] | undefined> {
     tLog(" Then:", this.name);
     try {
-      const x = (await this.butThen(
+      const x = await this.butThen(
         store,
         this.thenCB,
         testResourceConfiguration
-      ));
+      );
       return x;
     } catch (e) {
       console.log("test failed", e);
@@ -361,27 +325,15 @@ export abstract class BaseThen<
   }
 }
 
-export abstract class BaseCheck<
-  ITestShape extends IBaseTest
-> {
+export abstract class BaseCheck<ITestShape extends IBaseTest> {
   name: string;
   features: string[];
   checkCB: (whens, thens) => any;
   whens: {
-    [K in keyof ITestShape["whens"]]: (
-      p,
-      tc
-    ) => BaseWhen<
-      ITestShape
-    >;
+    [K in keyof ITestShape["whens"]]: (p, tc) => BaseWhen<ITestShape>;
   };
   thens: {
-    [K in keyof ITestShape["thens"]]: (
-      p,
-      tc
-    ) => BaseThen<
-      ITestShape
-    >;
+    [K in keyof ITestShape["thens"]]: (p, tc) => BaseThen<ITestShape>;
   };
 
   constructor(
@@ -399,21 +351,22 @@ export abstract class BaseCheck<
   }
 
   abstract checkThat(
-    subject: ITestShape['isubject'],
+    subject: ITestShape["isubject"],
     testResourceConfiguration,
     artifactory: ITestArtifactory
-  ): Promise<ITestShape['istore']>;
+  ): Promise<ITestShape["istore"]>;
 
   async afterEach(
-    store: ITestShape['istore'],
+    store: ITestShape["istore"],
     key: string,
-    cb?
+    cb,
+    utils: IUtils
   ): Promise<unknown> {
     return;
   }
 
   async check(
-    subject: ITestShape['isubject'],
+    subject: ITestShape["isubject"],
     key: string,
     testResourceConfiguration,
     tester,
@@ -453,7 +406,7 @@ export abstract class BaseCheck<
       }, {})
     );
 
-    await this.afterEach(store, key);
+    await this.afterEach(store, key, () => {}, utils);
     return;
   }
 }