testeranto 0.128.0 → 0.134.0

package/src/Types.ts

@@ -1,6 +1,8 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Plugin } from "esbuild";
-
 import { ITTestResourceConfiguration } from "./lib/index.js";
+import { PM } from "./PM/index.js";
+import { IT, OT } from "../dist/types/src/Types.js";
 import {
   IGivens,
   BaseCheck,
@@ -9,144 +11,217 @@ import {
   BaseThen,
   BaseGiven,
 } from "./lib/abstractBase.js";
-import { IPM, ITestCheckCallback } from "./lib/types.js";
-import { PM } from "./PM/index.js";
+import { ITestCheckCallback } from "./lib/types.js";
 
-export type ITestInterface<I extends IT = IT> = {
-  assertThis: (x: I["then"]) => any;
-  andWhen: (
-    store: I["istore"],
-    whenCB: I["when"],
-    testResource: ITTestResourceConfiguration,
-    pm: IPM
-  ) => Promise<I["istore"]>;
-  butThen: (
-    store: I["istore"],
-    thenCB: I["then"],
-    testResource: ITTestResourceConfiguration,
-    pm: IPM
-  ) => Promise<I["iselection"]>;
-  afterAll: (store: I["istore"], pm: IPM) => any;
-  afterEach: (store: I["istore"], key: string, pm: IPM) => Promise<unknown>;
-  beforeAll: (
-    input: I["iinput"],
-    testResource: ITTestResourceConfiguration,
-    pm: IPM
-  ) => Promise<I["isubject"]>;
-  beforeEach: (
-    subject: I["isubject"],
-    initializer: (c?) => I["given"],
-    testResource: ITTestResourceConfiguration,
-    initialValues,
-    pm: IPM
-  ) => Promise<I["istore"]>;
-};
-
-export type IWebTestInterface<I extends IT> = ITestInterface<I>;
-
-export type INodeTestInterface<I extends IT> = ITestInterface<I>;
-
-export type IPartialInterface<I extends IT> = Partial<ITestInterface<I>>;
-
-export type IPartialNodeInterface<I extends IT> = Partial<
-  INodeTestInterface<I>
->;
-export type IPartialWebInterface<I extends IT> = Partial<IWebTestInterface<I>>;
+// Simplified test result summary
+export type TestSummary = {
+  testName: string;
+  errors?: {
+    runtime?: number;
+    type?: number;
+    static?: number;
+  };
+  prompt?: string;
+  failedFeatures: string[];
+};
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+// Core test lifecycle hooks
+export type TestLifecycle<Subject, State, Selection> = {
+  // Setup
+  beforeAll?: (input: any) => Promise<Subject>;
+  beforeEach?: (subject: Subject) => Promise<State>;
 
-export type IT = Ibdd_in<
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown
->;
+  // Execution
+  executeStep?: (state: State) => Promise<State>;
+  verifyStep?: (state: State) => Promise<Selection>;
 
-export type OT = Ibdd_out<
-  Record<string, any>,
-  Record<string, any>,
-  Record<string, any>,
-  Record<string, any>,
-  Record<string, any>
->;
+  // Cleanup
+  afterEach?: (state: State) => Promise<void>;
+  afterAll?: (state: State) => Promise<void>;
+
+  // Assertions
+  assert?: (result: Selection) => void;
+};
+
+// BDD Test Structure
+export type TestDefinition<Subject, State, Selection> = {
+  // Test subject
+  subject: Subject;
+
+  // Test steps
+  given?: (input: any) => State;
+  when?: (state: State) => State | Promise<State>;
+  then?: (state: State) => Selection | Promise<Selection>;
+
+  // Configuration
+  resources?: ITTestResourceConfiguration;
+  pm?: typeof PM;
+};
 
-// export type MT<O extends OT> = Partial<{
-//   suites: { [K in keyof O["suites"]]: unknown };
-//   givens: { [K in keyof O["givens"]]: unknown };
-//   whens: { [K in keyof O["whens"]]: unknown };
-//   thens: { [K in keyof O["thens"]]: unknown };
-//   checks: { [K in keyof O["checks"]]: unknown };
-// }>;
+// Test Suite Organization
+export type TestSuite = {
+  name: string;
+  tests: TestDefinition<any, any, any>[];
+  features?: string[];
+};
+
+// Runtime Configuration
+export type RuntimeConfig = {
+  type: "node" | "web" | "pure" | "spawn";
+  ports?: number[];
+  plugins?: Plugin[];
+};
+
+// Project Configuration
+export type ProjectConfig = {
+  name: string;
+  sourceDir: string;
+  testSuites: TestSuite[];
+  runtime: RuntimeConfig;
+  minify?: boolean;
+  debug?: boolean;
+};
+
+// Specification component types
+export type SuiteSpecification<I extends IT, O extends OT> = {
+  [K in keyof O["suites"]]: (
+    name: string,
+    givens: IGivens<I>,
+    checks: BaseCheck<I>[]
+  ) => BaseSuite<I, O>;
+};
+
+export type GivenSpecification<I extends IT, O extends OT> = {
+  [K in keyof O["givens"]]: (
+    features: string[],
+    whens: BaseWhen<I>[],
+    thens: BaseThen<I>[],
+    ...xtrasB: O["givens"][K]
+  ) => BaseGiven<I>;
+};
+
+export type WhenSpecification<I extends IT, O extends OT> = {
+  [K in keyof O["whens"]]: (...xtrasC: O["whens"][K]) => BaseWhen<I>;
+};
+
+export type ThenSpecification<I extends IT, O extends OT> = {
+  [K in keyof O["thens"]]: (...xtrasD: O["thens"][K]) => BaseThen<I>;
+};
 
+// Complete test specification
 export type ITestSpecification<I extends IT, O extends OT> = (
-  Suite: {
-    [K in keyof O["suites"]]: (
-      name: string,
-      givens: IGivens<I>,
-      checks: BaseCheck<I>[]
-    ) => BaseSuite<I, O>;
-  },
-  Given: {
-    [K in keyof O["givens"]]: (
-      features: string[],
-      whens: BaseWhen<I>[],
-      thens: BaseThen<I>[],
-      ...xtrasB: O["givens"][K]
-    ) => BaseGiven<I>;
-  },
-  When: {
-    [K in keyof O["whens"]]: (...xtrasC: O["whens"][K]) => BaseWhen<I>;
-  },
-  Then: {
-    [K in keyof O["thens"]]: (...xtrasD: O["thens"][K]) => BaseThen<I>;
-  },
+  Suite: SuiteSpecification<I, O>,
+  Given: GivenSpecification<I, O>,
+  When: WhenSpecification<I, O>,
+  Then: ThenSpecification<I, O>,
   Check: ITestCheckCallback<I, O>
 ) => any[];
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+// Base implementation types
+export type TestSuiteImplementation<O extends OT> = {
+  [K in keyof O["suites"]]: string;
+};
+
+export type TestGivenImplementation<I extends IT, O extends OT> = {
+  [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
+};
+
+export type TestWhenImplementation<I extends IT, O extends OT> = {
+  [K in keyof O["whens"]]: (
+    ...Iw: O["whens"][K]
+  ) => (
+    zel: I["iselection"],
+    tr: ITTestResourceConfiguration,
+    utils: PM
+  ) => Promise<I["when"]>;
+};
+
+export type TestThenImplementation<I extends IT, O extends OT> = {
+  [K in keyof O["thens"]]: (
+    ...It: O["thens"][K]
+  ) => (ssel: I["iselection"], utils: PM) => I["then"];
+};
+
+export type TestCheckImplementation<I extends IT, O extends OT> = {
+  [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
+};
+
+// Complete test implementation
 export type ITestImplementation<
   I extends IT,
   O extends OT,
-  modifier = {}
+  modifier = {
+    whens: TestWhenImplementation<I, O>;
+  }
 > = Modify<
   {
-    suites: {
-      [K in keyof O["suites"]]: string;
-    };
-    givens: {
-      [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
-    };
-    whens: {
-      [K in keyof O["whens"]]: (
-        ...Iw: O["whens"][K]
-      ) => (zel: I["iselection"], utils: PM) => Promise<I["when"]>;
-    };
-    thens: {
-      [K in keyof O["thens"]]: (
-        ...It: O["thens"][K]
-      ) => (ssel: I["iselection"], utils: PM) => I["then"];
-    };
-    checks: {
-      [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
-    };
+    suites: TestSuiteImplementation<O>;
+    givens: TestGivenImplementation<I, O>;
+    whens: TestWhenImplementation<I, O>;
+    thens: TestThenImplementation<I, O>;
+    checks: TestCheckImplementation<I, O>;
   },
   modifier
 >;
 
+// export type ITestImplementation<
+//   I extends IT,
+//   O extends OT,
+//   modifier = Partial<{
+//     // givens: string;
+//     givens: {
+//       [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
+//     };
+//   }>
+// > = Modify<
+//   {
+//     // suites: {
+//     //   // [K in keyof O["suites"]]: unknown;
+//     //   [K in keyof O["suites"]]: (...Ig: O["suites"][K]) => I["suites"];
+//     // };
+//     // suites: [];
+
+//     // givens: {
+//     //   [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
+//     // };
+
+//     whens: {
+//       [K in keyof O["whens"]]: (
+//         ...Iw: O["whens"][K]
+//       ) => (zel: I["iselection"], utils: PM) => Promise<I["when"]>;
+//     };
+//     thens: {
+//       [K in keyof O["thens"]]: (
+//         ...It: O["thens"][K]
+//       ) => (ssel: I["iselection"], utils: PM) => I["then"];
+//     };
+//     checks: {
+//       [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
+//     };
+//   },
+//   modifier
+// >;
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 export type Modify<T, R> = Omit<T, keyof R> & R;
 
+// Individual output shape components
+export type TestSuiteShape = Record<string, any>;
+export type TestGivenShape = Record<string, any>;
+export type TestWhenShape = Record<string, any>;
+export type TestThenShape = Record<string, any>;
+export type TestCheckShape = Record<string, any>;
+
+// Complete BDD output shape
 export type Ibdd_out<
-  ISuites extends Record<string, any> = Record<string, any>,
-  IGivens extends Record<string, any> = Record<string, any>,
-  IWhens extends Record<string, any> = Record<string, any>,
-  IThens extends Record<string, any> = Record<string, any>,
-  IChecks extends Record<string, any> = Record<string, any>
+  ISuites extends TestSuiteShape = TestSuiteShape,
+  IGivens extends TestGivenShape = TestGivenShape,
+  IWhens extends TestWhenShape = TestWhenShape,
+  IThens extends TestThenShape = TestThenShape,
+  IChecks extends TestCheckShape = TestCheckShape
 > = {
   suites: ISuites;
   givens: IGivens;
@@ -155,24 +230,54 @@ export type Ibdd_out<
   checks: IChecks;
 };
 
+/**
+ * Defines the input shape for BDD test definitions.
+ * This is the core type that structures all test operations.
+ */
 export type Ibdd_in<
-  IInput,
-  ISubject,
-  IStore,
-  ISelection,
-  IGiven,
-  IWhen,
-  IThen
+  IInput, // Type of initial test input
+  ISubject, // Type of object being tested
+  IStore, // Type for storing test state between steps
+  ISelection, // Type for selecting state for assertions
+  IGiven, // Type for Given step functions
+  IWhen, // Type for When step functions
+  IThen // Type for Then step functions
 > = {
+  /** Initial input required to start tests */
   iinput: IInput;
+
+  /** The subject being tested (class, function, etc) */
   isubject: ISubject;
+
+  /** Complete test state storage */
   istore: IStore;
+
+  /** Selected portion of state for assertions */
   iselection: ISelection;
+
+  /** Function type for Given steps */
   given: IGiven;
+
+  /** Function type for When steps */
   when: IWhen;
+
+  /** Function type for Then steps */
   then: IThen;
 };
 
+// Example usage:
+/*
+type CounterTest = Ibdd_in<
+  number,                     // Initial count value
+  Counter,                    // Test subject is Counter class
+  { counter: Counter, env: any }, // Store counter + environment
+  number,                     // Assert against current count
+  (init: number) => Counter,  // Given creates Counter
+  (delta: number) => (c: Counter) => void, // When modifies Counter
+  (expected: number) => (c: Counter) => void // Then asserts count
+>;
+*/
+
 ///////////////////////////////////////////////
 
 export type IPluginFactory = (
@@ -180,7 +285,7 @@ export type IPluginFactory = (
   entrypoints?: string[]
 ) => Plugin;
 
-export type IRunTime = `node` | `web` | "pure";
+export type IRunTime = `node` | `web` | "pure" | `spawn`;
 
 export type ITestTypes = [string, IRunTime, { ports: number }, ITestTypes[]];
 
@@ -188,6 +293,7 @@ export type ITestconfig = {
   clearScreen: boolean;
   debugger: boolean;
   externals: string[];
+  externalTests: Record<string, { watch: string[]; exec: string }>;
   featureIngestor: (s: string) => Promise<string>;
   importPlugins: IPluginFactory[];
   minify: boolean;
@@ -196,7 +302,6 @@ export type ITestconfig = {
   src: string;
   tests: ITestTypes[];
   webPlugins: IPluginFactory[];
-  reportDomain: string;
 };
 
 export type IBuiltConfig = { buildDir: string } & ITestconfig;

package/src/WebSidecar.ts

@@ -0,0 +1,14 @@
+import { ITTestResourceConfiguration } from "./lib";
+import { Sidecar } from "./lib/Sidecar";
+import { PM_Web_Sidecar } from "./PM/webSidecar";
+// import { PM_Node_Sidecar } from "./PM/nodeSidecar";
+
+export class WebSideCar extends Sidecar {
+  start(t: ITTestResourceConfiguration) {
+    throw new Error("Method not implemented.");
+  }
+  stop() {
+    throw new Error("Method not implemented.");
+  }
+  pm: PM_Web_Sidecar;
+}

package/src/build.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import ansiC from "ansi-colors";
 import fs, { watch } from "fs";
 import path from "path";
@@ -21,7 +23,7 @@ import {
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
 
-let testName = process.argv[2];
+const testName = process.argv[2];
 
 let mode = process.argv[3] as "once" | "dev";
 if (mode !== "once" && mode !== "dev") {
@@ -58,6 +60,24 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     return Array.from(meta(config.tests, new Set()));
   };
 
+  const getSideCars = (runtime?: IRunTime): string[] => {
+    return Array.from(
+      new Set(
+        config.tests
+          .reduce((mm, t) => {
+            mm = mm.concat(t[3]);
+            return mm;
+          }, [] as ITestTypes[])
+          .filter((t) => {
+            return t[1] === runtime;
+          })
+          .map((t) => {
+            return t[0];
+          })
+      )
+    );
+  };
+
   const config: IBuiltConfig = {
     ...rawConfig,
     buildDir: process.cwd() + "/testeranto/bundles/" + testName,
@@ -86,10 +106,19 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
 
   let status: "build" | "built" = "build";
 
-  const { nodeEntryPoints, webEntryPoints, importEntryPoints } = getRunnables(
-    config.tests,
-    testName
-  );
+  const {
+    nodeEntryPoints,
+    nodeEntryPointSidecars,
+    webEntryPoints,
+    webEntryPointSidecars,
+    pureEntryPoints,
+    pureEntryPointSidecars,
+  } = getRunnables(config.tests, testName);
+
+  // const { nodeEntryPointsSidecars, webEntryPointsSidecars, importEntryPointsSideCars } = getRunnableSidecars(
+  //   config.tests,
+  //   testName
+  // );
 
   const onNodeDone = () => {
     nodeDone = true;
@@ -116,6 +145,7 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     }
   };
 
+  console.log(`testeranto/reports/${testName}`);
   if (!fs.existsSync(`testeranto/reports/${testName}`)) {
     fs.mkdirSync(`testeranto/reports/${testName}`);
   }
@@ -224,12 +254,25 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
   // });
 
   const x: [IRunTime, string[]][] = [
-    ["pure", Object.keys(importEntryPoints)],
+    ["pure", Object.keys(pureEntryPoints)],
     ["node", Object.keys(nodeEntryPoints)],
     ["web", Object.keys(webEntryPoints)],
+    // [
+    //   "pure",
+    //   [...Object.keys(pureEntryPoints), ...Object.keys(pureEntryPointSidecars)],
+    // ],
+    // [
+    //   "node",
+    //   [...Object.keys(nodeEntryPoints), ...Object.keys(nodeEntryPointSidecars)],
+    // ],
+    // [
+    //   "web",
+    //   [...Object.keys(webEntryPoints), ...Object.keys(webEntryPointSidecars)],
+    // ],
   ];
 
   x.forEach(async ([runtime, keys]) => {
+    console.log(runtime, keys);
     keys.forEach(async (k) => {
       const folder = `testeranto/reports/${testName}/${k
         .split(".")
@@ -250,8 +293,8 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <meta name="author" content="" />
 
-  <link rel="stylesheet" href="../../../../../TestReport.css" />
-  <script src="../../../../../TestReport.js"></script>
+  <link rel="stylesheet" href="../../../../../../TestReport.css" />
+  <script src="../../../../../../TestReport.js"></script>
 
 </head>
 
@@ -263,16 +306,60 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     });
   });
 
+  [
+    [pureEntryPoints, pureEntryPointSidecars, "pure"],
+    [webEntryPoints, webEntryPointSidecars, "web"],
+    [nodeEntryPoints, nodeEntryPointSidecars, "node"],
+  ].forEach(
+    ([eps, eps2, runtime]: [
+      Record<string, string>,
+      Record<string, string>,
+      IRunTime
+    ]) => {
+      [...Object.keys(eps), ...Object.keys(eps2)].forEach((ep) => {
+        const fp = path.resolve(
+          `testeranto`,
+          `reports`,
+          testName,
+          ep.split(".").slice(0, -1).join("."),
+          runtime
+        );
+        fs.mkdirSync(fp, { recursive: true });
+      });
+    }
+  );
+
   await Promise.all([
     ...(
       [
-        [esbuildImportConfiger, importEntryPoints, onImportDone],
-        [esbuildNodeConfiger, nodeEntryPoints, onNodeDone],
-        [esbuildWebConfiger, webEntryPoints, onWebDone],
-      ] as [(a, b, c) => any, Record<string, string>, () => void][]
-    ).map(([configer, entryPoints, done]) => {
+        [
+          esbuildImportConfiger,
+          pureEntryPoints,
+          pureEntryPointSidecars,
+          onImportDone,
+        ],
+        [
+          esbuildNodeConfiger,
+          nodeEntryPoints,
+          nodeEntryPointSidecars,
+          onNodeDone,
+        ],
+        [esbuildWebConfiger, webEntryPoints, webEntryPointSidecars, onWebDone],
+      ] as [
+        (a, b, c) => any,
+        Record<string, string>,
+        Record<string, string>,
+        () => void
+      ][]
+    ).map(([configer, entryPoints, sidecars, done]) => {
       esbuild
-        .context(configer(config, Object.keys(entryPoints), testName))
+        .context(
+          configer(
+            config,
+            [...Object.keys(entryPoints), ...Object.keys(sidecars)],
+            testName
+          )
+        )
         .then(async (ctx) => {
           if (mode === "dev") {
             await ctx.watch().then((v) => {

package/src/defaultConfig.ts

@@ -11,6 +11,7 @@ const config: ITestconfig = {
   nodePlugins: [],
   webPlugins: [],
   importPlugins: [],
+  externalTests: {},
   featureIngestor: function (s: string): Promise<string> {
     throw new Error("Function not implemented.");
   },

package/src/esbuildConfigs/README.md

@@ -0,0 +1,46 @@
+# Console Detector Plugin
+
+## Purpose
+This esbuild plugin detects usage of `console.*` methods in code that will run under the Pure runtime. Since Pure runtime doesn't allow IO operations, these calls will fail silently. The plugin provides warnings during build time to alert developers.
+
+## Why This Exists
+1. **Pure Runtime Constraints**: 
+   - Pure runtime has no access to IO operations
+   - Console methods are IO operations
+   - Failed calls won't throw errors, just silently fail
+
+2. **Developer Experience**:
+   - Catches issues at build time rather than runtime
+   - Clearly indicates which files/lines need attention
+   - Guides developers to use Node runtime when IO is needed
+
+## Usage
+```javascript
+import { consoleDetectorPlugin } from './consoleDetectorPlugin';
+
+// Add to your esbuild config
+esbuild.build({
+  plugins: [consoleDetectorPlugin],
+  // ... other config
+});
+```
+
+## Behavior
+- Scans all .js and .ts files
+- Detects any `console.*` method calls
+- Generates warnings with file locations
+- Doesn't fail the build (just warns)
+
+## Recommendations
+1. For Pure runtime code:
+   - Remove all console.* calls
+   - Use alternative debugging methods
+
+2. When you need console output:
+   - Switch to Node runtime
+   - Use the appropriate test interface
+
+## Implementation Notes
+- Uses esbuild's onLoad hook
+- Checks for 20+ different console methods
+- Provides exact line numbers for warnings