testeranto 0.143.0 → 0.146.0

package/src/Pure.ts

@@ -41,7 +41,13 @@ export class PureTesteranto<
   async receiveTestResourceConfig(partialTestResource: string) {
     const t: ITTestResourceConfiguration = JSON.parse(partialTestResource);
     const pm = new PM_Pure(t);
-    return await this.testJobs[0].receiveTestResourceConfig(pm);
+
+    try {
+      return await this.testJobs[0].receiveTestResourceConfig(pm);
+    } catch (e) {
+      return -2;
+    }
+
     // const { failed, artifacts, logPromise, features, fails } =
     //   await this.testJobs[0].receiveTestResourceConfig(pm);
     // // pm.customclose();
@@ -55,7 +61,7 @@ export default async <I extends Ibdd_in_any, O extends Ibdd_out, M>(
   testImplementation: ITestImplementation<I, O, M>,
   testInterface: Partial<ITestInterface<I>>,
   testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement
-): Promise<Testeranto<I, O, M>> => {
+): Promise<number | Testeranto<I, O, M>> => {
   return new PureTesteranto<I, O, M>(
     input,
     testSpecification,
@@ -63,4 +69,16 @@ export default async <I extends Ibdd_in_any, O extends Ibdd_out, M>(
     testResourceRequirement,
     testInterface
   );
+
+  // try {
+  //   return new PureTesteranto<I, O, M>(
+  //     input,
+  //     testSpecification,
+  //     testImplementation,
+  //     testResourceRequirement,
+  //     testInterface
+  //   );
+  // } catch (e) {
+  //   return -1;
+  // }
 };

package/src/Types.ts

@@ -17,11 +17,11 @@ import { BaseSuite } from "./lib/BaseSuite.js";
 export type ISummary = Record<
   string,
   {
-    runTimeError: string;
-    typeErrors: number;
-    staticErrors: number;
-    prompt: string;
-    failingFeatures: object;
+    runTimeErrors: number | "?" | undefined;
+    typeErrors: number | "?" | undefined;
+    staticErrors: number | "?" | undefined;
+    prompt: string | "?" | undefined;
+    failingFeatures: object | undefined;
   }
 >;
 

package/src/Web.ts

@@ -87,7 +87,7 @@ export default async <I extends Ibdd_in_any, O extends Ibdd_out, M>(
   input: I["iinput"],
   testSpecification: ITestSpecification<I, O>,
   testImplementation: ITestImplementation<I, O, M>,
-  testInterface: Partial<IWebTestInterface<I>>,
+  testInterface: Partial<ITestInterface<I>>,
   testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement
 ): Promise<Testeranto<I, O, M>> => {
   return new WebTesteranto<I, O, M>(

package/src/build.ts

@@ -238,7 +238,6 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
   ];
 
   x.forEach(async ([runtime, keys]) => {
-    console.log(runtime, keys);
     keys.forEach(async (k) => {
       const folder = `testeranto/reports/${testName}/${k
         .split(".")

package/src/esbuildConfigs/consoleDetectorPlugin.ts

@@ -1,29 +1,43 @@
-import type { Plugin } from 'esbuild';
+import type { Plugin } from "esbuild";
+
+import fs from "fs";
 
 export const consoleDetectorPlugin: Plugin = {
-  name: 'console-detector',
+  name: "console-detector",
   setup(build) {
     build.onLoad({ filter: /\.(js|ts)$/ }, async (args) => {
-      const contents = await require('fs').promises.readFile(args.path, 'utf8');
-      
-      const consolePattern = /console\.(log|error|warn|info|debug|trace|dir|dirxml|table|group|groupEnd|clear|count|countReset|assert|profile|profileEnd|time|timeLog|timeEnd|timeStamp|context|memory)/g;
+      const contents = await fs.promises.readFile(args.path, "utf8");
+
+      const consolePattern =
+        /console\.(log|error|warn|info|debug|trace|dir|dirxml|table|group|groupEnd|clear|count|countReset|assert|profile|profileEnd|time|timeLog|timeEnd|timeStamp|context|memory)/g;
       const matches = contents.match(consolePattern);
 
       if (matches) {
         const uniqueMethods = [...new Set(matches)];
         return {
-          warnings: uniqueMethods.map(method => ({
-            text: `Detected ${method} call - Pure runtime does not allow IO operations. Use Node runtime instead.`,
-            location: {
-              file: args.path,
-              line: contents.split('\n').findIndex(line => line.includes(method)) + 1,
-              column: 0
-            }
-          }))
+          warnings: uniqueMethods.map((method) => ({
+            text: `call of "${method}" was detected, which is not supported in the pure runtime.`,
+            // location: {
+            //   file: args.path,
+            //   line:
+            //     contents
+            //       .split("\n")
+            //       .findIndex((line) => line.includes(method)) + 1,
+            //   column: 0,
+            // },
+          })),
         };
       }
 
       return null;
     });
-  }
+    build.onEnd((buildResult) => {
+      if (
+        buildResult.warnings.find((br) => br.pluginName === "console-detector")
+      )
+        console.warn(
+          `Warning: An unsupported method call was detected in a source file used to build for the pure runtime. It is possible that this method call is in a comment block. If you really want to use this function, change this test to the "node" runtime.`
+        );
+    });
+  },
 };

package/src/esbuildConfigs/nativeImportDetectorPlugin.ts

@@ -0,0 +1,26 @@
+import type { Plugin } from "esbuild";
+
+import { isBuiltin } from "node:module";
+
+export const nativeImportDetectorPlugin: Plugin = {
+  name: "native-node-import-filter",
+  setup(build) {
+    build.onResolve({ filter: /fs/ }, (args) => {
+      if (isBuiltin(args.path)) {
+        return {
+          warnings: [
+            {
+              text: `cannot use native node package "${args.path}" in a "pure" test. If you really want to use this package, convert this test from "pure" to "node"`,
+            },
+          ],
+        };
+
+        // throw new Error(
+        //   `cannot use native node package "${args.path}" in a "pure" test. If you really want to use this package, convert this test from "pure" to "node"`
+        // );
+      }
+
+      return { path: args.path };
+    });
+  },
+};

package/src/esbuildConfigs/pure.ts

@@ -9,6 +9,7 @@ import featuresPlugin from "./featuresPlugin.js";
 import { isBuiltin } from "node:module";
 import { consoleDetectorPlugin } from "./consoleDetectorPlugin.js";
 import rebuildPlugin from "./rebuildPlugin.js";
+import { nativeImportDetectorPlugin } from "./nativeImportDetectorPlugin.js";
 
 export default (
   config: ITestconfig,
@@ -53,13 +54,14 @@ export default (
 
       consoleDetectorPlugin,
 
+      // nativeImportDetectorPlugin,
       {
         name: "native-node-import-filter",
         setup(build) {
           build.onResolve({ filter: /fs/ }, (args) => {
             if (isBuiltin(args.path)) {
               throw new Error(
-                `cannot use native node package "${args.path}" in a "pure" test. If you really want to use this package, convert this test from "pure" to "node"`
+                `You attempted to import a node module "${args.path}" into a "pure" test, which is not allowed. If you really want to use this package, convert this test from "pure" to "node"`
               );
             }
 

package/src/esbuildConfigs/rebuildPlugin.ts

@@ -6,11 +6,8 @@ export default (r: IRunTime) => {
   return {
     name: "rebuild-notify",
     setup: (build) => {
-      build.onStart(() => {
-        console.log(`> web build starting...`);
-      });
       build.onEnd((result) => {
-        console.log(`> web build ended with ${result.errors.length} errors`);
+        console.log(`${r} > build ended with ${result.errors.length} errors`);
         if (result.errors.length > 0) {
           fs.writeFileSync(
             `./testeranto/reports${r}_build_errors`,

package/src/lib/BaseSuite.test/node.test.ts

@@ -0,0 +1,12 @@
+import Testeranto from "../../Node";
+
+import { BaseSuite } from "../BaseSuite";
+
+import { I, implementation, O, specification, testInterface } from "./test";
+
+export default Testeranto<I, O, {}>(
+  BaseSuite,
+  specification,
+  implementation,
+  testInterface
+);

package/src/lib/BaseSuite.test/pure.test.ts

@@ -0,0 +1,12 @@
+import Testeranto from "../../Pure";
+
+import { BaseSuite } from "../BaseSuite";
+
+import { I, implementation, O, specification, testInterface } from "./test";
+
+export default Testeranto<I, O, {}>(
+  BaseSuite,
+  specification,
+  implementation,
+  testInterface
+);

package/src/lib/{BaseSuite.test.ts → BaseSuite.test/test.ts}

@@ -1,32 +1,30 @@
-import Testeranto from "../Node";
-
-import { BaseSuite } from "./BaseSuite";
-import { BaseGiven, BaseWhen, BaseThen, BaseCheck } from "./abstractBase";
-import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
-import { IPM, ITestCheckCallback } from "./types";
+import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from "..";
 import {
   Ibdd_in,
   Ibdd_out,
   ITestSpecification,
   ITestImplementation,
   ITestInterface,
-} from "../CoreTypes";
-import { WhenSpecification } from "../Types";
+} from "../../CoreTypes";
+import { WhenSpecification } from "../../Types";
+import { BaseGiven, BaseWhen, BaseThen, BaseCheck } from "../abstractBase";
+import { BaseSuite } from "../BaseSuite";
+import { IPM, ITestCheckCallback } from "../types";
 
 // 1. Define our test types with full type safety
-type TestStore = {
+export type TestStore = {
   testStore: boolean;
   testSelection?: boolean;
   error?: Error;
 };
 
-type TestSelection = {
+export type TestSelection = {
   testSelection: boolean;
   error?: boolean;
 };
 
-type I = Ibdd_in<
-  null, // iinput
+export type I = Ibdd_in<
+  typeof BaseSuite,
   BaseSuite<any, any>, // isubject
   TestStore, // istore
   TestSelection, // iselection
@@ -35,7 +33,7 @@ type I = Ibdd_in<
   (store: TestStore) => Promise<TestSelection> // then
 >;
 
-type O = Ibdd_out<
+export type O = Ibdd_out<
   {
     Default: [string]; // Suite names
   },
@@ -57,7 +55,7 @@ type O = Ibdd_out<
 >;
 
 // 2. Mock implementations with proper typing
-class MockGiven extends BaseGiven<I> {
+export class MockGiven extends BaseGiven<I> {
   constructor(
     name: string,
     features: string[],
@@ -86,7 +84,7 @@ class MockGiven extends BaseGiven<I> {
   }
 
   uberCatcher(e: Error): void {
-    console.error("Given error:", e);
+    console.error("Given error 2:", e);
   }
 }
 
@@ -160,7 +158,7 @@ class TestableSuite extends BaseSuite<I, O> {
 }
 
 // 3. Enhanced Test Specification with more test cases
-const specification: ITestSpecification<I, O> = (
+export const specification: ITestSpecification<I, O> = (
   Suite: ITestSpecification<I, O>,
   Given: WhenSpecification<I, O>,
   When: WhenSpecification<I, O>,
@@ -228,20 +226,20 @@ const specification: ITestSpecification<I, O> = (
       [
         When.addArtifact(Promise.resolve("test")),
         When.modifySpecs((specs) => [...specs, "extra"]),
-        When.modifyJobs((jobs) => [...jobs, {}])
+        When.modifyJobs((jobs) => [...jobs, {}]),
       ],
       [
         Then.specsModified(1),
         Then.jobsModified(1),
         Then.artifactsTracked(),
-        Then.testRunSuccessful()
+        Then.testRunSuccessful(),
       ]
-    )
-  })
+    ),
+  }),
 ];
 
 // 4. Enhanced Test Implementation with more operations
-const implementation: ITestImplementation<I, O> = {
+export const implementation: ITestImplementation<I, O> = {
   suites: {
     Default: "BaseSuite Comprehensive Test Suite" as const,
   },
@@ -434,7 +432,7 @@ const implementation: ITestImplementation<I, O> = {
 };
 
 // 5. Fully typed Test Interface
-const testInterface: ITestInterface<I> = {
+export const testInterface: ITestInterface<I> = {
   beforeEach: async (
     subject: I["isubject"],
     initializer: (context?: any) => I["given"]
@@ -466,11 +464,3 @@ const testInterface: ITestInterface<I> = {
     pm: IPM
   ): Promise<I["isubject"]> => input as unknown as I["isubject"],
 };
-
-// 6. Run the tests
-export default Testeranto<I, O, {}>(
-  BaseSuite.prototype,
-  specification,
-  implementation,
-  testInterface
-);

package/src/lib/BaseSuite.test/web.test.ts

@@ -0,0 +1,12 @@
+import Testeranto from "../../Web";
+
+import { BaseSuite } from "../BaseSuite";
+
+import { I, implementation, O, specification, testInterface } from "./test";
+
+export default Testeranto<I, O, {}>(
+  BaseSuite,
+  specification,
+  implementation,
+  testInterface
+);

package/src/lib/BaseSuite.ts

@@ -95,21 +95,23 @@ export abstract class BaseSuite<I extends Ibdd_in_any, O extends Ibdd_out_any> {
 
     for (const [gKey, g] of Object.entries(this.givens)) {
       const giver = this.givens[gKey];
-      this.store = await giver.give(
-        subject,
-        gKey,
-        testResourceConfiguration,
-        this.assertThat,
-        suiteArtifactory,
-        tLog,
-        pm,
-        sNdx
-      ).catch((e) => {
-        this.failed = true;
-        this.fails = this.fails + 1;
-        console.error("Given error:", e);
-        throw e;
-      });
+      this.store = await giver
+        .give(
+          subject,
+          gKey,
+          testResourceConfiguration,
+          this.assertThat,
+          suiteArtifactory,
+          tLog,
+          pm,
+          sNdx
+        )
+        .catch((e) => {
+          this.failed = true;
+          this.fails = this.fails + 1;
+          console.error("Given error 1:", e);
+          throw e;
+        });
     }
 
     for (const [ndx, thater] of this.checks.entries()) {

package/src/lib/abstractBase.ts

@@ -214,7 +214,6 @@ export abstract class BaseWhen<I extends Ibdd_in_any> {
       testResourceConfiguration,
       andWhenProxy(pm, filepath)
     ).catch((e: Error) => {
-      console.log("MARK9", e);
       this.error = e;
       throw e;
     });
@@ -271,7 +270,6 @@ export abstract class BaseThen<I extends Ibdd_in_any> {
       testResourceConfiguration,
       butThenProxy(pm, filepath)
     ).catch((e) => {
-      console.log("test failed 3", e);
       this.error = e;
       throw e;
     });

package/src/lib/baseBuilder.test/baseBuilder.test.implementation.ts

@@ -4,7 +4,8 @@ import { ITestImplementation } from "../../CoreTypes";
 import { TestBaseBuilder } from "./TestBaseBuilder";
 
 import { I, O } from "./baseBuilder.test.types";
-import { TestBaseBuilder } from "./TestBaseBuilder";
+import { ITTestResourceRequest } from "..";
+import { BaseBuilder } from "../basebuilder";
 
 // Define our test subject type
 type TestSubject = TestBaseBuilder<any, any, any, any, any, any>;

package/src/lib/baseBuilder.test/baseBuilder.test.node.ts

@@ -0,0 +1,14 @@
+import Testeranto from "../../Pure";
+
+import { specification } from "./baseBuilder.test.specification";
+import { implementation } from "./baseBuilder.test.implementation";
+import { testInterface } from "./baseBuilder.test.interface";
+import { I, O } from "./baseBuilder.test.types";
+import { BaseBuilder } from "../basebuilder";
+
+export default Testeranto<I, O, {}>(
+  BaseBuilder.prototype,
+  specification,
+  implementation,
+  testInterface
+);

package/src/lib/baseBuilder.test/baseBuilder.test.pure.ts

@@ -0,0 +1,14 @@
+import Testeranto from "../../Pure";
+
+import { specification } from "./baseBuilder.test.specification";
+import { implementation } from "./baseBuilder.test.implementation";
+import { testInterface } from "./baseBuilder.test.interface";
+import { I, O } from "./baseBuilder.test.types";
+import { BaseBuilder } from "../basebuilder";
+
+export default Testeranto<I, O, {}>(
+  BaseBuilder.prototype,
+  specification,
+  implementation,
+  testInterface
+);

package/src/lib/baseBuilder.test/{baseBuilder.test.ts → baseBuilder.test.web.ts}

@@ -1,9 +1,10 @@
-import Testeranto from "../../Node";
+import Testeranto from "../../Web";
 
 import { specification } from "./baseBuilder.test.specification";
 import { implementation } from "./baseBuilder.test.implementation";
 import { testInterface } from "./baseBuilder.test.interface";
 import { I, O } from "./baseBuilder.test.types";
+import { BaseBuilder } from "../basebuilder";
 
 export default Testeranto<I, O, {}>(
   BaseBuilder.prototype,

package/src/lib/basebuilder.ts

@@ -114,8 +114,9 @@ export abstract class BaseBuilder<
             logFilePath
           );
 
+          // deprecated?
           const tLog = async (...l: string[]) => {
-            // console.log("x", x);
+            //
           };
 
           const suiteDone: BaseSuite<I, O> = await runner(puppetMaster, tLog);

package/src/lib/classBuilder.test/classBuilder.test.implementation.ts

@@ -1,8 +1,12 @@
-import { ITestImplementation } from "../../CoreTypes";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { PassThrough } from "stream";
+
+import { ITestImplementation, ITestSpecification } from "../../CoreTypes";
 import { TestClassBuilder } from "./TestClassBuilder";
 import { I, O, M } from "./classBuilder.test.types";
-import { PassThrough } from "stream";
+
 import { ITTestResourceRequest } from "..";
+import { specification } from "./classBuilder.test.specification";
 
 export const implementation: ITestImplementation<I, O, M> = {
   suites: {

package/src/lib/classBuilder.test/classBuilder.test.interface.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { ITestInterface } from "../../CoreTypes";
 import { I } from "../baseBuilder.test/baseBuilder.test.types";
 

package/src/lib/classBuilder.test/classBuilder.test.specification.ts

@@ -1,3 +1,4 @@
+import { ITestJob } from "..";
 import { ITestSpecification } from "../../CoreTypes";
 import { I, O } from "./classBuilder.test.types";
 
@@ -55,7 +56,7 @@ export const specification: ITestSpecification<I, O> = (
             Then.givensOverridesConfigured(),
             Then.whensOverridesConfigured(),
             Then.thensOverridesConfigured(),
-            Then.checksOverridesConfigured()
+            Then.checksOverridesConfigured(),
           ]
         ),
       },
@@ -101,12 +102,12 @@ export const specification: ITestSpecification<I, O> = (
           ["Should complete a full test run successfully"],
           [],
           [Then.testRunSuccessful()]
-        )
+        ),
       },
       [
         Check.ImplementationCheck((impl) => impl !== null),
-        Check.SpecificationCheck((spec) => spec !== null)
+        Check.SpecificationCheck((spec) => spec !== null),
       ]
-    )
+    ),
   ];
 };

package/src/lib/classBuilder.test/classBuilder.test.types.ts

@@ -1,6 +1,12 @@
-import { Ibdd_in, Ibdd_out } from "../../CoreTypes";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import {
+  Ibdd_in,
+  Ibdd_out,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../CoreTypes";
 import { ClassBuilder } from "../classBuilder";
-import { ITTestResourceRequest } from "..";
+import { ITestJob, ITTestResourceRequest } from "..";
 
 export type I = Ibdd_in<
   {}, // iinput
@@ -61,12 +67,18 @@ export type O = Ibdd_out<
 
 export type M = {
   givens: {
-    [K in keyof O["givens"]]: (...args: O["givens"][K]) => ClassBuilder<any, any, any>;
+    [K in keyof O["givens"]]: (
+      ...args: O["givens"][K]
+    ) => ClassBuilder<any, any, any>;
   };
   whens: {
-    [K in keyof O["whens"]]: (...args: O["whens"][K]) => (builder: ClassBuilder<any, any, any>) => ClassBuilder<any, any, any>;
+    [K in keyof O["whens"]]: (
+      ...args: O["whens"][K]
+    ) => (builder: ClassBuilder<any, any, any>) => ClassBuilder<any, any, any>;
   };
   thens: {
-    [K in keyof O["thens"]]: (...args: O["thens"][K]) => (builder: ClassBuilder<any, any, any>) => ClassBuilder<any, any, any>;
+    [K in keyof O["thens"]]: (
+      ...args: O["thens"][K]
+    ) => (builder: ClassBuilder<any, any, any>) => ClassBuilder<any, any, any>;
   };
 };

package/src/lib/core.ts

@@ -120,16 +120,6 @@ export default abstract class TesterantoCore<
             testResource,
             pm
           );
-          // try {
-          //   return await fullTestInterface.andWhen(
-          //     store,
-          //     whenCB,
-          //     testResource,
-          //     pm
-          //   );
-          // } catch (e) {
-          //   console.log("mark22", e);
-          // }
         }
       } as any,
 

package/src/lib/pmProxy.test/interface.ts

@@ -25,7 +25,6 @@ export const testInterface: ITestInterface<I> = {
   },
 
   butThen: async (store, thenCB, testResource, pm) => {
-    console.log("mark2 butThen", store, thenCB.toString());
     const proxiedPM = butThenProxy(pm, "some/path");
     return thenCB(store, proxiedPM);
   },

package/src/run.ts

@@ -7,7 +7,9 @@ import { ITestconfig, IBuiltConfig, IProject } from "./Types";
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
 
-console.log(ansiC.inverse("Press 'x' to shutdown forcefully."));
+console.log(ansiC.inverse("Press 'q' to initiate a graceful shutdown."));
+console.log(ansiC.inverse("Press 'x' to quit forcefully."));
+
 process.stdin.on("keypress", (str, key) => {
   if (key.name === "x") {
     console.log(ansiC.inverse("Shutting down forcefully..."));
@@ -15,7 +17,7 @@ process.stdin.on("keypress", (str, key) => {
   }
 });
 
-const testName = process.argv[2];
+const projectName = process.argv[2];
 
 const mode = process.argv[3] as "once" | "dev";
 if (mode !== "once" && mode !== "dev") {
@@ -23,19 +25,17 @@ if (mode !== "once" && mode !== "dev") {
   process.exit(-1);
 }
 
-console.log("testeranto is running", testName, mode);
-
 import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
   const bigConfig: IProject = module.default;
 
-  const rawConfig: ITestconfig = bigConfig.projects[testName];
+  const rawConfig: ITestconfig = bigConfig.projects[projectName];
 
   const config: IBuiltConfig = {
     ...rawConfig,
-    buildDir: process.cwd() + "/" + `testeranto/${testName}.json`,
+    buildDir: process.cwd() + "/" + `testeranto/${projectName}.json`,
   };
 
-  const pm = new PM_Main(config, testName, mode);
+  const pm = new PM_Main(config, projectName, mode);
   pm.start();
 
   process.stdin.on("keypress", (str, key) => {