testeranto 0.129.0 → 0.134.0

package/src/esbuildConfigs/consoleDetectorPlugin.ts

@@ -0,0 +1,29 @@
+import type { Plugin } from 'esbuild';
+
+export const consoleDetectorPlugin: Plugin = {
+  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 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
+            }
+          }))
+        };
+      }
+
+      return null;
+    });
+  }
+};

package/src/esbuildConfigs/pure.ts

@@ -6,6 +6,9 @@ import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
 import featuresPlugin from "./featuresPlugin.js";
 
+import { isBuiltin } from "node:module";
+import { consoleDetectorPlugin } from "./consoleDetectorPlugin.js";
+
 export default (
   config: ITestconfig,
   entryPoints: string[],
@@ -18,7 +21,7 @@ export default (
   return {
     ...baseEsBuildConfig(config),
 
-    drop: ["console", "debugger"],
+    drop: [],
 
     splitting: true,
 
@@ -46,6 +49,24 @@ export default (
       featuresPlugin,
 
       inputFilesPluginFactory,
+
+      consoleDetectorPlugin,
+
+      {
+        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"`
+              );
+            }
+
+            return { path: args.path };
+          });
+        },
+      },
+
       {
         name: "rebuild-notify",
         setup: (build) => {

package/src/esbuildConfigs/web.ts

@@ -1,3 +1,5 @@
+import { polyfillNode } from "esbuild-plugin-polyfill-node";
+
 import { BuildOptions } from "esbuild";
 import path from "path";
 
@@ -20,6 +22,7 @@ export default (
   return {
     ...baseEsBuildConfig(config),
 
+    treeShaking: true,
     outdir: `testeranto/bundles/web/${testName}`,
 
     alias: {
@@ -55,6 +58,16 @@ export default (
     plugins: [
       featuresPlugin,
       inputFilesPluginFactory,
+
+      polyfillNode({
+        // You might need to configure specific Node.js modules you want to polyfill
+        // Example:
+        // modules: {
+        //   'util': true,
+        //   'fs': false,
+        // }
+      }),
+
       {
         name: "rebuild-notify",
         setup: (build) => {

package/src/lib/Sidecar.ts

@@ -0,0 +1,6 @@
+import { ITTestResourceConfiguration } from ".";
+
+export abstract class Sidecar {
+  abstract start(t: ITTestResourceConfiguration);
+  abstract stop();
+}

package/src/lib/TEST_ADAPTER_RENAME.md

@@ -0,0 +1,48 @@
+# Test Adapter Rename Proposal
+
+## Current Problems
+1. `interface` is:
+   - Too vague/overloaded term
+   - Conflicts with TypeScript keyword
+   - Doesn't convey the wrapping/mediation purpose
+
+## Proposed Solution
+Rename to `TestAdapter` because:
+- Standard pattern name in testing frameworks
+- Precisely describes the wrapping/adaptation role
+- Avoids language conflicts
+- Matches industry terminology
+
+## Required Changes
+### File Renames:
+- `testInterface.ts` → `testAdapter.ts`
+
+### Type Changes:
+- `ITestInterface` → `ITestAdapter`
+- All related interface types
+
+### Documentation Updates:
+- Update all JSDoc references
+- Update README examples
+
+## Benefits
+1. Clearer code intent
+2. Better pattern alignment
+3. Reduced naming collisions
+4. More discoverable architecture
+
+## Risks/Mitigations
+1. Breaking change → Major version bump
+2. Need to update all test files → Codemod script
+3. Documentation updates → Batch update before release
+
+## Implementation Plan
+1. First create new types alongside old ones
+2. Deprecate old names with warnings
+3. Provide migration guide
+4. Remove old names in next major version
+
+## References
+- [xUnit Test Patterns](http://xunitpatterns.com/)
+- [VS Test Adapters](https://devblogs.microsoft.com/devops/how-to-write-a-visual-studio-test-adapter/)
+- [JUnit TestEngine](https://junit.org/junit5/docs/current/user-guide/)

package/src/lib/abstractBase.ts

@@ -1,4 +1,6 @@
-import { IT, OT } from "../Types.js";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { IT, OT } from "../Types.js";
 
 import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
 import { IPM } from "./types.js";
@@ -118,7 +120,7 @@ export abstract class BaseSuite<I extends IT = IT, O extends OT = OT> {
       } catch (e) {
         this.failed = true;
         this.fails = this.fails + 1;
-        // console.error(e);
+        console.error(e);
         // this.fails.push(giver);
         // return this;
       }
@@ -292,8 +294,7 @@ export abstract class BaseGiven<I extends IT = IT> {
           pm,
           `suite-${suiteNdx}/given-${key}/then-${thenNdx}`
         );
-
-        return tester(t);
+        tester(t);
         // ((t) => {
         //   return tester(t);
         // })();
@@ -326,7 +327,7 @@ export abstract class BaseGiven<I extends IT = IT> {
 export abstract class BaseWhen<I extends IT> {
   public name: string;
   whenCB: (x: I["iselection"]) => I["then"];
-  error: boolean;
+  error: Error;
 
   constructor(name: string, whenCB: (xyz: I["iselection"]) => I["then"]) {
     this.name = name;
@@ -341,9 +342,10 @@ export abstract class BaseWhen<I extends IT> {
   ): Promise<any>;
 
   toObj() {
+    console.log("toObj error", this.error);
     return {
       name: this.name,
-      error: this.error,
+      error: this.error && this.error.name + this.error.stack,
     };
   }
 
@@ -361,9 +363,10 @@ export abstract class BaseWhen<I extends IT> {
       this.whenCB,
       testResourceConfiguration,
       andWhenProxy(pm, filepath)
-    ).catch((e) => {
-      this.error = true;
-      // throw e;
+    ).catch((e: Error) => {
+      console.log("MARK9", e);
+      this.error = e;
+      throw e;
     });
   }
 }

package/src/lib/basebuilder.ts

@@ -1,3 +1,7 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { PassThrough } from "stream";
 
 import { IT, ITestSpecification, OT } from "../Types.js";
@@ -105,21 +109,18 @@ export abstract class BaseBuilder<
         receiveTestResourceConfig: async function (
           puppetMaster: IPM
         ): Promise<IFinalResults> {
-          const start = await puppetMaster.start();
-
           const logFilePath = "log.txt";
           const access: number = await puppetMaster.createWriteStream(
             logFilePath
           );
 
           const tLog = async (...l: string[]) => {
-            const x = await puppetMaster.write(access, `${l.toString()}\n`);
             // console.log("x", x);
           };
 
           const suiteDone: BaseSuite<I, O> = await runner(puppetMaster, tLog);
 
-          const logPromise = new Promise(async (res, rej) => {
+          const logPromise = new Promise(async (res) => {
             await puppetMaster.end(access);
             res(true);
           });

package/src/lib/classBuilder.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { IT, ITestImplementation, ITestSpecification, OT } from "../Types.js";
 
 import { BaseBuilder } from "./basebuilder.js";
@@ -27,7 +29,13 @@ export abstract class ClassBuilder<
   IExtenstions
 > {
   constructor(
-    testImplementation: ITestImplementation<I, O, M>,
+    testImplementation: ITestImplementation<I, O, M> & {
+      suites: Record<string, any>;
+      givens: Record<string, any>;
+      whens: Record<string, any>;
+      thens: Record<string, any>;
+      checks: Record<string, any>;
+    },
     testSpecification: ITestSpecification<I, O>,
     input: I["iinput"],
     suiteKlasser: ISuiteKlasser<I, O>,
@@ -54,15 +62,15 @@ export abstract class ClassBuilder<
 
     const classyGivens = Object.entries(testImplementation.givens).reduce(
       (a, [key, g]) => {
-        a[key] = (features, whens, thens) => {
+        a[key] = (features, whens, thens, ...initialValues) => {
           // console.log("givEn", givEn.toString());
           return new givenKlasser.prototype.constructor(
             key,
             features,
             whens,
             thens,
-            testImplementation.givens[key]
-            // givEn
+            testImplementation.givens[key],
+            initialValues
           );
         };
         return a;
@@ -83,23 +91,12 @@ export abstract class ClassBuilder<
       {}
     );
 
-    const classyThens = Object.entries(testImplementation.thens).reduce(
+    const classyThens = Object.entries<(expected: any, ...x: any[]) => any>(testImplementation.thens).reduce(
       (a, [key, thEn]: [string, (s: I["iselection"]) => I["isubject"]]) => {
-        a[key] = (expected, x) => {
+        a[key] = (expected, ...x) => {
           return new thenKlasser.prototype.constructor(
             `${thEn.name}: ${expected && expected.toString()}`,
-            // () => {
-            //   thEn(expected);
-            //   // return new Promise((res), rej) => {
-
-            //   // }
-            //   // try {
-            //   //   thEn(expected);
-            //   // } catch (c) {
-            //   //   console.log("mark99");
-            //   // }
-            // },
-            thEn(expected)
+            thEn(expected, ...x)
           );
         };
         return a;

package/src/lib/core.ts

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import {
   ITestSpecification,
   ITestImplementation,
@@ -32,7 +33,13 @@ export default abstract class Testeranto<
   constructor(
     input: I["iinput"],
     testSpecification: ITestSpecification<I, O>,
-    testImplementation: ITestImplementation<I, O, M>,
+    testImplementation: ITestImplementation<I, O, M> & {
+      suites: Record<string, any>;
+      givens: Record<string, any>;
+      whens: Record<string, any>;
+      thens: Record<string, any>;
+      checks: Record<string, any>;
+    },
     testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
     testInterface: Partial<ITestInterface<I>>,
     uberCatcher: (cb: () => void) => void
@@ -111,16 +118,22 @@ export default abstract class Testeranto<
 
       class When extends BaseWhen<I> {
         async andWhen(store, whenCB, testResource, pm) {
-          try {
-            return await fullTestInterface.andWhen(
-              store,
-              whenCB,
-              testResource,
-              pm
-            );
-          } catch (e) {
-            throw e;
-          }
+          return await fullTestInterface.andWhen(
+            store,
+            whenCB,
+            testResource,
+            pm
+          );
+          // try {
+          //   return await fullTestInterface.andWhen(
+          //     store,
+          //     whenCB,
+          //     testResource,
+          //     pm
+          //   );
+          // } catch (e) {
+          //   console.log("mark22", e);
+          // }
         }
       } as any,
 

package/src/lib/index.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { PM_Pure } from "../PM/pure.js";
 
 import { PM_Node } from "../PM/node.js";
@@ -16,32 +18,44 @@ import {
 import { IGivens, BaseCheck, BaseSuite } from "./abstractBase.js";
 import { IPM } from "./types.js";
 
-export const BaseTestInterface: ITestInterface<IT> = {
-  beforeAll: async (s) => s,
+export const BaseTestInterface = <T extends IT>(): ITestInterface<T> => ({
+  beforeAll: async (s: T["istore"]) => s,
   beforeEach: async function (
-    subject: any,
-    initialValues: any,
-    x: any,
-    testResource: any,
+    subject: T["isubject"],
+    initialValues: T["iinitialValues"],
+    x: unknown,
+    testResource: ITTestResourceConfiguration,
     pm: IPM
-  ) {
-    return subject as any;
+  ): Promise<T["isubject"]> {
+    return subject;
   },
-  afterEach: async (s) => s,
-  afterAll: (store: IT["istore"]) => undefined,
+  afterEach: async (s: T["istore"]) => s,
+  afterAll: (store: T["istore"]) => undefined,
   butThen: async (
     store: IT["istore"],
     thenCb: (s: IT["iselection"]) => Promise<IT["isubject"]>
   ) => {
     return thenCb(store);
   },
-  andWhen: async (a) => a,
-  assertThis: (x: any) => null,
-};
+  andWhen: async (
+    store: IT["istore"],
+    whenCB: IT["when"],
+    testResource: ITTestResourceConfiguration,
+    pm: IPM
+  ) => {
+    try {
+      await whenCB(store, testResource, pm);
+    } catch (error) {
+      console.error("Error in andWhen:", error);
+      throw error; // Re-throw to maintain test failure
+    }
+  },
+  assertThis: (x: any) => x,
+});
 
-export const DefaultTestInterface = (
-  p: Partial<ITestInterface<any>>
-): ITestInterface<any> => {
+export const DefaultTestInterface = <T extends IT>(
+  p: Partial<ITestInterface<T>>
+): ITestInterface<T> => {
   return {
     ...BaseTestInterface,
     ...p,
@@ -52,7 +66,10 @@ export type ITTestResourceConfiguration = {
   name: string;
   fs: string;
   ports: number[];
-  browserWSEndpoint: string;
+  browserWSEndpoint?: string;
+  timeout?: number;
+  retries?: number;
+  environment?: Record<string, string>;
 };
 
 export type ITTestResourceRequirement = {
@@ -112,8 +129,11 @@ export type { ITestconfig, IBuiltConfig, IRunTime, ITestTypes };
 
 export type IRunnables = {
   nodeEntryPoints: Record<string, string>;
+  nodeEntryPointSidecars: Record<string, string>;
   webEntryPoints: Record<string, string>;
-  importEntryPoints: Record<string, string>;
+  webEntryPointSidecars: Record<string, string>;
+  pureEntryPoints: Record<string, string>;
+  pureEntryPointSidecars: Record<string, string>;
 };
 
 export type IFinalResults = {

package/src/lib/pmProxy.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { IPM } from "./types";
 
 const prxy = function (pm: IPM, mappings: [string, (...x) => any][]) {
@@ -8,7 +10,7 @@ const prxy = function (pm: IPM, mappings: [string, (...x) => any][]) {
         const arger = mapping[1];
 
         if (prop === method) {
-          return (x) => target[prop](arger(x));
+          return (...x) => target[prop](arger(...x));
         }
       }
 

package/src/lib/types.ts

@@ -1,7 +1,8 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { PM_Node } from "../PM/node";
 import { PM_Pure } from "../PM/pure";
 import { PM_Web } from "../PM/web";
-import { IT, OT } from "../Types";
+import type { IT, OT } from "../Types";
 
 import {
   IGivens,
@@ -14,11 +15,23 @@ import {
 
 export type IPM = PM_Node | PM_Web | PM_Pure;
 
+export type TestPhase = 'beforeAll' | 'beforeEach' | 'test' | 'afterEach' | 'afterAll';
+
+export type TestError = {
+  phase: TestPhase;
+  error: Error;
+  testName: string;
+  timestamp: number;
+  stackTrace?: string;
+  additionalInfo?: Record<string, unknown>;
+  isRetryable?: boolean;
+};
+
 export type ITestCheckCallback<I extends IT, O extends OT> = {
   [K in keyof O["checks"]]: (
     name: string,
     features: string[],
-    checkCallback: (store: I["istore"], pm: IPM) => Promise<any>,
+    checkCallback: (store: I["istore"], pm: IPM) => Promise<O["checks"][K]>,
 
     ...xtrasA: O["checks"][K]
   ) => BaseCheck<I>;

package/src/mothership/index.ts

@@ -0,0 +1,15 @@
+import express from "express";
+
+const app = express();
+
+app.get("/", (req, res) => {
+  res.send("Hello World!");
+});
+
+export default (port: number) => {
+  app.listen(port, () => {
+    console.log(`Example app listening on port ${port}`);
+  });
+
+  return app;
+};

package/src/mothership/test.ts

@@ -0,0 +1,137 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { ITTestResourceConfiguration } from "../lib";
+import { IPM } from "../lib/types";
+import Testeranto from "../Node";
+import { PM } from "../PM";
+
+import {
+  Ibdd_out,
+  ITestSpecification,
+  IT,
+  ITestImplementation,
+  Ibdd_in,
+  IPartialNodeInterface,
+} from "../Types";
+
+import appFactory from "./index";
+
+import type { Express } from "express";
+
+type I = Ibdd_in<
+  (port: number) => Express,
+  (port: number) => Express,
+  any,
+  any,
+  any,
+  any,
+  any
+>;
+
+type O = Ibdd_out<
+  {
+    TheMothership: [null];
+  },
+  {
+    ItIsRunning: [];
+  },
+  {
+    IClaimTheResource: [string];
+    IReleaseTheResource: [string];
+    IResetTheResource: [string];
+  },
+  {
+    TheResourceIsClaimed: [string];
+    TheResourceIsUnClaimed: [string];
+  },
+  {
+    AnEmptyState;
+  }
+>;
+
+const specification: ITestSpecification<IT, O> = (Suite, Given, When, Then) => {
+  console.log("Suite", Suite);
+  return [
+    Suite.TheMothership(
+      "the mothership allows the coordination of test resources",
+      {
+        test0: Given.ItIsRunning(
+          [`a resource can be claimed`],
+          [When.IClaimTheResource("test")],
+          [
+            // Then.TheResourceIsClaimed("test")
+          ]
+        ),
+      },
+      []
+    ),
+  ];
+};
+
+const implementation: ITestImplementation<I, O> = {
+  suites: { TheMothership: (x) => x },
+  givens: { ItIsRunning: () => undefined },
+  whens: {
+    IClaimTheResource: (resource) => async (i, tr, p) => {
+      fetch(`http://localhost:${tr.ports[0]}/claim?${resource}`);
+    },
+    IReleaseTheResource: function (
+      resource: string
+    ): (zel, tr, utils) => Promise<any> {
+      throw new Error("Function not implemented.");
+    },
+    IResetTheResource: function (
+      Iw_0: string
+    ): (zel: any, tr, utils: PM) => Promise<any> {
+      throw new Error("Function not implemented.");
+    },
+  },
+  thens: {
+    TheResourceIsClaimed: (resource) => async (z, u) => {
+      throw new Error("Function not implemented.");
+    },
+    TheResourceIsUnClaimed: function (
+      It_0: string
+    ): (ssel: any, utils: PM) => any {
+      throw new Error("Function not implemented.");
+    },
+  },
+  checks: { AnEmptyState: () => "any" },
+};
+
+const testInterface: IPartialNodeInterface<I> = {
+  // assertThis: function (x: any) {
+  //   throw new Error("Function not implemented.");
+  // },
+  // andWhen: function (store: any, whenCB: any, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
+  //   throw new Error("Function not implemented.");
+  // },
+  // butThen: function (store: any, thenCB: any, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
+  //   throw new Error("Function not implemented.");
+  // },
+  // afterAll: function (store: any, pm: IPM) {
+  //   throw new Error("Function not implemented.");
+  // },
+  // afterEach: function (store: any, key: string, pm: IPM): Promise<unknown> {
+  //   throw new Error("Function not implemented.");
+  // },
+  // beforeAll: function (input: Express, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
+  //   throw new Error("Function not implemented.");
+  // },
+  beforeEach: async (
+    subject,
+    initializer: (c?: any) => any,
+    testResource: ITTestResourceConfiguration,
+    initialValues: any,
+    pm: IPM
+  ) => {
+    return subject(testResource.ports[0]);
+  },
+};
+
+export default Testeranto(
+  appFactory,
+  specification,
+  implementation,
+  testInterface
+);

package/src/run.ts

@@ -1,6 +1,5 @@
 import ansiC from "ansi-colors";
 import readline from "readline";
-import path from "path";
 
 import { PM_Main } from "./PM/main";
 import { ITestconfig, IBuiltConfig, IProject } from "./Types";