testeranto 0.90.0 → 0.94.0

package/dist/prebuild/build-tests.mjs

@@ -37,14 +37,12 @@ import fs from "fs";
 import path from "path";
 var otherInputs = {};
 var register = (entrypoint, sources) => {
-  console.log("register", entrypoint, sources);
   if (!otherInputs[entrypoint]) {
     otherInputs[entrypoint] = /* @__PURE__ */ new Set();
   }
   sources.forEach((s) => otherInputs[entrypoint].add(s));
 };
 function tree(meta, key) {
-  console.log("searching metafile for", key);
   const outputKey = Object.keys(meta.outputs).find((k) => {
     return meta.outputs[k].entryPoint === key;
   });
@@ -389,9 +387,12 @@ var compile = () => {
       logContent.push(...lines);
     });
     tsc.stderr.on("data", (data) => {
+      console.error(`stderr: ${data}`);
+      process.exit(-1);
     });
     tsc.on("close", (code) => {
       parseTsErrors();
+      console.log("tsc done");
       resolve(`tsc process exited with code ${code}`);
     });
   });
@@ -452,7 +453,6 @@ var ITProject = class {
         2
       )
     );
-    compile();
     Promise.resolve(
       Promise.all(
         [...this.getSecondaryEndpointsPoints("web")].map(
@@ -486,6 +486,7 @@ var ITProject = class {
       });
     });
     Promise.all([
+      compile(),
       esbuild.context(node_default(this.config, nodeEntryPoints)).then(async (nodeContext) => {
         if (this.config.devMode) {
           await nodeContext.watch().then((v) => {

package/dist/prebuild/run-tests.mjs

@@ -97,14 +97,17 @@ var PM_Main = class extends PM {
         process.exit(-1);
       }
       const builtfile = dest + ".mjs";
+      const webSideCares = [];
       await Promise.all(
-        testConfig[3].map((sidecar) => {
+        testConfig[3].map(async (sidecar) => {
           if (sidecar[1] === "web") {
-            return this.launchWebSideCar(
+            const s = await this.launchWebSideCar(
               sidecar[0],
               destinationOfRuntime(sidecar[0], "web", this.configs),
               sidecar
             );
+            webSideCares.push(s);
+            return s;
           }
           if (sidecar[1] === "node") {
             return this.launchNodeSideCar(
@@ -117,11 +120,13 @@ var PM_Main = class extends PM {
       );
       this.server[builtfile] = await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
         return module.default.then((defaultModule) => {
-          defaultModule.receiveTestResourceConfig(argz).then(async (features) => {
+          defaultModule.receiveTestResourceConfig(argz).then(async ({ features, failed }) => {
             this.receiveFeatures(features, destFolder);
+            console.log(`${src} completed with ${failed} errors`);
           }).catch((e) => {
-            console.log("catch", e);
+            console.log(`${src} errored with`, e);
           }).finally(() => {
+            webSideCares.forEach((webSideCar) => webSideCar.close());
             this.deregister(src);
           });
         });
@@ -136,12 +141,6 @@ var PM_Main = class extends PM {
       const d = dest + ".mjs";
       console.log("launchWebSideCar", src, dest, d);
       const destFolder = dest.replace(".mjs", "");
-      const webArgz = JSON.stringify({
-        name: dest,
-        ports: [].toString(),
-        fs: destFolder,
-        browserWSEndpoint: this.browser.wsEndpoint()
-      });
       const fileStreams2 = [];
       const doneFileStream2 = [];
       return new Promise((res, rej) => {
@@ -225,16 +224,6 @@ var PM_Main = class extends PM {
           page.exposeFunction("end", async (uid) => {
             return fileStreams2[uid].end();
           });
-          page.exposeFunction("customclose", (p, testName) => {
-            fs.writeFileSync(
-              p + "/manifest.json",
-              JSON.stringify(Array.from(files[testName]))
-            );
-            delete files[testName];
-            Promise.all(screenshots[testName] || []).then(() => {
-              delete screenshots[testName];
-            });
-          });
           return page;
         }).then(async (page) => {
           await page.goto(`file://${`${dest}.html`}`, {});
@@ -380,20 +369,7 @@ var PM_Main = class extends PM {
         page.exposeFunction(
           "writeFileSync",
           (fp, contents, testName) => {
-            const dir = path2.dirname(fp);
-            fs.mkdirSync(dir, {
-              recursive: true
-            });
-            const p = new Promise(async (res, rej) => {
-              fs.writeFileSync(fp, contents);
-              res(fp);
-            });
-            doneFileStream2.push(p);
-            if (!files[testName]) {
-              files[testName] = /* @__PURE__ */ new Set();
-            }
-            files[testName].add(fp);
-            return p;
+            return globalThis["writeFileSync"](fp, contents, testName);
           }
         );
         page.exposeFunction("existsSync", (fp, contents) => {
@@ -435,16 +411,6 @@ var PM_Main = class extends PM {
         page.exposeFunction("end", async (uid) => {
           return fileStreams2[uid].end();
         });
-        page.exposeFunction("customclose", (p, testName) => {
-          fs.writeFileSync(
-            p + "/manifest.json",
-            JSON.stringify(Array.from(files[testName]))
-          );
-          delete files[testName];
-          Promise.all(screenshots[testName] || []).then(() => {
-            delete screenshots[testName];
-          });
-        });
         page.exposeFunction("page", () => {
           return page.mainFrame()._id;
         });
@@ -488,12 +454,21 @@ var PM_Main = class extends PM {
         return page;
       }).then(async (page) => {
         const close = () => {
-          console.log("evaluation complete.", dest);
-          page.off("pageerror");
-          page.close();
-          this.deregister(t);
-          stderrStream.close();
-          stdoutStream.close();
+          if (!files[t]) {
+            files[t] = /* @__PURE__ */ new Set();
+          }
+          fs.writeFileSync(
+            dest + "/manifest.json",
+            JSON.stringify(Array.from(files[t]))
+          );
+          delete files[t];
+          Promise.all(screenshots[t] || []).then(() => {
+            delete screenshots[t];
+            page.close();
+            this.deregister(t);
+            stderrStream.close();
+            stdoutStream.close();
+          });
         };
         page.on("pageerror", (err) => {
           console.debug(`Error from ${t}: [${err.name}] `);
@@ -515,11 +490,11 @@ var PM_Main = class extends PM {
           stdoutStream.write(JSON.stringify(log.stackTrace()));
         });
         await page.goto(`file://${`${dest}.html`}`, {});
-        await page.evaluate(evaluation).then(async (features) => {
+        await page.evaluate(evaluation).then(async ({ failed, features }) => {
           this.receiveFeatures(features, destFolder);
+          console.log(`${t} completed with ${failed} errors`);
         }).catch((e) => {
-          console.log("evaluation failed.", dest);
-          console.log(e);
+          console.log(`${t} errored with`, e);
         }).finally(() => {
           close();
         });
@@ -527,7 +502,6 @@ var PM_Main = class extends PM {
       });
     };
     this.receiveFeatures = (features, destFolder) => {
-      console.log("this.receiveFeatures", features);
       features.reduce(async (mm, featureStringKey) => {
         const accum = await mm;
         const isUrl = isValidUrl(featureStringKey);
@@ -590,7 +564,7 @@ var PM_Main = class extends PM {
       return false;
     };
     globalThis["writeFileSync"] = (filepath, contents, testName) => {
-      const dir = path2.dirname(filepath.split("/").slice(0, -1).join("/"));
+      const dir = path2.dirname(filepath);
       fs.mkdirSync(dir, {
         recursive: true
       });
@@ -639,16 +613,6 @@ var PM_Main = class extends PM {
       await sPromise;
       return sPromise;
     };
-    globalThis["customclose"] = (p, testName) => {
-      if (!files[testName]) {
-        files[testName] = /* @__PURE__ */ new Set();
-      }
-      fs.writeFileSync(
-        p + "/manifest.json",
-        JSON.stringify(Array.from(files[testName]))
-      );
-      delete files[testName];
-    };
   }
   $(selector) {
     throw new Error("Method not implemented.");
@@ -813,7 +777,7 @@ var Puppeteer_default = async (partialConfig) => {
         // process.env.CHROMIUM_PATH || "/opt/homebrew/bin/chromium",
         "/opt/homebrew/bin/chromium"
       ),
-      headless: false,
+      headless: true,
       dumpio: true,
       // timeout: 0,
       devtools: true,

package/dist/types/src/Node.d.ts

@@ -4,7 +4,10 @@ import type { IBaseTest, ITestImplementation, ITestSpecification } from "./Types
 import { ITestInterface, INodeTestInterface } from "./lib/types.js";
 export declare class NodeTesteranto<TestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> extends Testeranto<TestShape> {
     constructor(input: TestShape["iinput"], testSpecification: ITestSpecification<TestShape>, testImplementation: ITestImplementation<TestShape>, testResourceRequirement: ITTestResourceRequest, testInterface: Partial<ITestInterface<TestShape>>);
-    receiveTestResourceConfig(partialTestResource: string): Promise<string[]>;
+    receiveTestResourceConfig(partialTestResource: string): Promise<{
+        features: string[];
+        failed: number;
+    }>;
 }
 declare const _default: <ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape, object>, testInterface: Partial<INodeTestInterface<ITestShape>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
 export default _default;

package/dist/types/src/PM/main.d.ts

@@ -7,6 +7,7 @@ import { PassThrough } from "stream";
 import { IBuiltConfig, ITestTypes } from "../lib/types";
 import { PM } from "./index.js";
 import { ITLog } from "../lib/index.js";
+import { Page } from "puppeteer-core/lib/esm/puppeteer";
 export declare class PM_Main extends PM {
     browser: Browser;
     shutdownMode: boolean;
@@ -42,7 +43,7 @@ export declare class PM_Main extends PM {
     register: (src: string) => void;
     deregister: (src: string) => void;
     launchNode: (src: string, dest: string) => Promise<void>;
-    launchWebSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<unknown>;
+    launchWebSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<Page>;
     launchNodeSideCar: (src: string, dest: string, testConfig: ITestTypes) => Promise<void>;
     launchWeb: (t: string, dest: string, sidecars: ITestTypes[]) => void;
     receiveFeatures: (features: string[], destFolder: string) => void;

package/dist/types/src/SubPackages/react/jsx/node.d.ts

@@ -1,4 +1,4 @@
 import { IPartialInterface } from "../../../Types";
 import { ITestImpl, ITestSpec, IInput } from "./index.js";
-declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface: Partial<import("../../../lib/types.js").ITestInterface<ITestShape>>) => Promise<import("../../../lib/core.js").default<ITestShape>>;
+declare const _default: <ITestShape extends any>(testImplementations: ITestImpl<ITestShape>, testSpecifications: ITestSpec<ITestShape>, testInput: IInput, testInterface?: Partial<import("../../../lib/types.js").ITestInterface<ITestShape>>) => Promise<import("../../../lib/core.js").default<ITestShape>>;
 export default _default;

package/dist/types/src/SubPackages/react-test-renderer/component/interface.d.ts

@@ -1,7 +1,7 @@
 import renderer from "react-test-renderer";
 import { ISelection, IStore } from ".";
 export declare const testInterface: {
-    beforeEach: (CComponent: any, propsAndChildren: any) => Promise<renderer.ReactTestRenderer>;
+    beforeEach: (CComponent: any, propsAndChildren: () => any) => Promise<renderer.ReactTestRenderer>;
     andWhen: (renderer: renderer.ReactTestRenderer, whenCB: any) => Promise<renderer.ReactTestRenderer>;
     butThen: (s: IStore, thenCB: any, tr: any) => Promise<ISelection>;
     afterEach: (store: IStore, ndx: any, artificer: any) => Promise<{}>;

package/dist/types/src/Web.d.ts

@@ -1,10 +1,10 @@
 import type { IBaseTest, ITestImplementation, ITestSpecification } from "./Types";
 import Testeranto from "./lib/core.js";
 import { ITTestResourceRequest } from "./lib/index.js";
-import { ITestInterface, IWebTestInterface } from "./lib/types";
+import { IFinalResults, ITestInterface, IWebTestInterface } from "./lib/types";
 export declare class WebTesteranto<TestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> extends Testeranto<TestShape> {
     constructor(input: TestShape["iinput"], testSpecification: ITestSpecification<TestShape>, testImplementation: ITestImplementation<TestShape>, testResourceRequirement: ITTestResourceRequest, testInterface: Partial<ITestInterface<TestShape>>);
-    receiveTestResourceConfig(partialTestResource: any): Promise<string[]>;
+    receiveTestResourceConfig(partialTestResource: any): Promise<IFinalResults>;
 }
 declare const _default: <ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape, object>, testInterface: Partial<IWebTestInterface<ITestShape>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<ITestShape>>;
 export default _default;

package/dist/types/src/lib/abstractBase.d.ts

@@ -15,6 +15,7 @@ export declare abstract class BaseSuite<ITestShape extends IBaseTest<unknown, un
     toObj(): {
         name: string;
         givens: {
+            key: string;
             name: string;
             whens: {
                 name: string;
@@ -46,9 +47,11 @@ export declare abstract class BaseGiven<ITestShape extends IBaseTest<unknown, un
     recommendedFsPath: string;
     givenCB: ITestShape["given"];
     initialValues: any;
+    key: string;
     constructor(name: string, features: string[], whens: BaseWhen<ITestShape>[], thens: BaseThen<ITestShape>[], givenCB: ITestShape["given"], initialValues: any);
-    beforeAll(store: ITestShape["istore"], artifactory: ITestArtifactory): ITestShape["istore"];
+    beforeAll(store: ITestShape["istore"], initializer: any, artifactory: any, testResource: any, initialValues: any, pm: any): ITestShape["istore"];
     toObj(): {
+        key: string;
         name: string;
         whens: {
             name: string;
@@ -61,8 +64,9 @@ export declare abstract class BaseGiven<ITestShape extends IBaseTest<unknown, un
         error: (string | Error | undefined)[] | null;
         features: string[];
     };
-    abstract givenThat(subject: ITestShape["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: ITestShape["given"], pm: PM): Promise<ITestShape["istore"]>;
+    abstract givenThat(subject: ITestShape["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: ITestShape["given"], initialValues: any, pm: PM): Promise<ITestShape["istore"]>;
     afterEach(store: ITestShape["istore"], key: string, artifactory: ITestArtifactory, pm: PM): Promise<unknown>;
+    abstract uberCatcher(e: any): any;
     give(subject: ITestShape["isubject"], key: string, testResourceConfiguration: ITTestResourceConfiguration, tester: (t: Awaited<ITestShape["then"]> | undefined) => boolean, artifactory: ITestArtifactory, tLog: ITLog, pm: PM, suiteNdx: number): Promise<ITestShape["istore"]>;
 }
 export declare abstract class BaseWhen<ITestShape extends IBaseTest> {

package/dist/types/src/lib/core.d.ts

@@ -1,8 +1,8 @@
 import { IBaseTest, ITestSpecification, ITestImplementation } from "../Types.js";
-import { ITestInterface } from "./types.js";
+import { IFinalResults, ITestInterface } from "./types.js";
 import { ITTestResourceRequest } from "./index.js";
 import { ClassBuilder } from "./classBuilder.js";
 export default abstract class Testeranto<ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> extends ClassBuilder<ITestShape> {
-    constructor(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape>, testResourceRequirement: ITTestResourceRequest | undefined, testInterface: Partial<ITestInterface<ITestShape>>);
-    abstract receiveTestResourceConfig(partialTestResource: string): Promise<string[]>;
+    constructor(input: ITestShape["iinput"], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape>, testResourceRequirement: ITTestResourceRequest | undefined, testInterface: Partial<ITestInterface<ITestShape>>, uberCatcher: (cb: any) => void);
+    abstract receiveTestResourceConfig(partialTestResource: string): Promise<IFinalResults>;
 }

package/dist/types/src/lib/types.d.ts

@@ -3,6 +3,10 @@ import type { Plugin } from "esbuild";
 import { IGivens, BaseCheck, BaseSuite, BaseGiven, BaseWhen, BaseThen } from "./abstractBase";
 import { ITTestResourceConfiguration, ITestArtificer } from ".";
 import { PM } from "../PM/index";
+export declare type IFinalResults = {
+    features: string[];
+    failed: number;
+};
 export declare type IRunTime = `node` | `web`;
 export declare type ITestTypes = [string, IRunTime, {
     ports: number;
@@ -55,7 +59,7 @@ export declare type ITestInterface<ITestShape extends IBaseTest<unknown, unknown
     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?: any) => ITestShape["given"], testResource: ITTestResourceConfiguration, initialValues: any, pm: PM) => Promise<ITestShape["istore"]>;
+    beforeEach: (subject: ITestShape["isubject"], initializer: (c?: any) => ITestShape["given"], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any, pm: PM) => Promise<ITestShape["istore"]>;
 };
 export declare type ISuiteKlasser<ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = (name: string, index: number, givens: IGivens<ITestShape>, checks: BaseCheck<ITestShape>[]) => BaseSuite<ITestShape>;
 export declare type IGivenKlasser<ITestShape extends IBaseTest<unknown, unknown, unknown, unknown, unknown, unknown, unknown, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>> = (name: any, features: any, whens: any, thens: any, givenCB: any) => BaseGiven<ITestShape>;