testeranto 0.129.0 → 0.135.0

package/src/Types.ts

@@ -1,178 +1,299 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { Plugin } from "esbuild";
-
 import { ITTestResourceConfiguration } from "./lib/index.js";
+import { PM } from "./PM/index.js";
+
 import {
-  IGivens,
-  BaseCheck,
-  BaseSuite,
   BaseWhen,
   BaseThen,
   BaseGiven,
+  BaseCheck,
+  BaseSuite,
+  IGivens,
 } from "./lib/abstractBase.js";
-import { IPM, ITestCheckCallback } from "./lib/types.js";
-import { PM } from "./PM/index.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>>;
+import { Ibdd_in, Ibdd_out } from "./CoreTypes.js";
 
-//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+export type SuiteSpecification<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    TestSuiteShape,
+    TestGivenShape,
+    TestWhenShape,
+    TestThenShape,
+    TestCheckShape
+  >
+> = {
+  [K in keyof O["suites"]]: (
+    name: string,
+    givens: IGivens<I>,
+    checks: BaseCheck<I>[]
+  ) => BaseSuite<I, O>;
+};
 
-export type IT = Ibdd_in<
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown,
-  unknown
->;
-
-export type OT = Ibdd_out<
-  Record<string, any>,
-  Record<string, any>,
-  Record<string, any>,
-  Record<string, any>,
-  Record<string, any>
->;
-
-// 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 };
-// }>;
-
-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>;
-  },
-  Check: ITestCheckCallback<I, O>
-) => any[];
+// 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>;
+
+  // Execution
+  executeStep?: (state: State) => Promise<State>;
+  verifyStep?: (state: State) => Promise<Selection>;
+
+  // 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;
+};
+
+// 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;
+};
+
+export type GivenSpecification<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    TestSuiteShape,
+    TestGivenShape,
+    TestWhenShape,
+    TestThenShape,
+    TestCheckShape
+  >
+> = {
+  [K in keyof O["givens"]]: (
+    features: string[],
+    whens: BaseWhen<I>[],
+    thens: BaseThen<I>[],
+    ...xtrasB: O["givens"][K]
+  ) => BaseGiven<I>;
+};
+
+export type WhenSpecification<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    TestSuiteShape,
+    TestGivenShape,
+    TestWhenShape,
+    TestThenShape,
+    TestCheckShape
+  >
+> = {
+  [K in keyof O["whens"]]: (...xtrasC: O["whens"][K]) => BaseWhen<I>;
+};
+
+export type ThenSpecification<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    TestSuiteShape,
+    TestGivenShape,
+    TestWhenShape,
+    TestThenShape,
+    TestCheckShape
+  >
+> = {
+  [K in keyof O["thens"]]: (...xtrasD: O["thens"][K]) => BaseThen<I>;
+};
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-export type ITestImplementation<
-  I extends IT,
-  O extends OT,
-  modifier = {}
-> = 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"];
-    };
-  },
-  modifier
->;
+// Base implementation types
+export type TestSuiteImplementation<
+  O extends Ibdd_out<
+    TestSuiteShape,
+    TestGivenShape,
+    TestWhenShape,
+    TestThenShape,
+    TestCheckShape
+  >
+> = {
+  [K in keyof O["suites"]]: string;
+};
 
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+export type TestGivenImplementation<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    TestSuiteShape,
+    TestGivenShape,
+    TestWhenShape,
+    TestThenShape,
+    TestCheckShape
+  >
+> = {
+  [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
+};
 
-export type Modify<T, R> = Omit<T, keyof R> & R;
+export type TestWhenImplementation<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    TestSuiteShape,
+    TestGivenShape,
+    TestWhenShape,
+    TestThenShape,
+    TestCheckShape
+  >
+> = {
+  [K in keyof O["whens"]]: (
+    ...Iw: O["whens"][K]
+  ) => (
+    zel: I["iselection"],
+    tr: ITTestResourceConfiguration,
+    utils: PM
+  ) => Promise<I["when"]>;
+};
 
-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>
+export type TestThenImplementation<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    TestSuiteShape,
+    TestGivenShape,
+    TestWhenShape,
+    TestThenShape,
+    TestCheckShape
+  >
 > = {
-  suites: ISuites;
-  givens: IGivens;
-  whens: IWhens;
-  thens: IThens;
-  checks: IChecks;
-};
-
-export type Ibdd_in<
-  IInput,
-  ISubject,
-  IStore,
-  ISelection,
-  IGiven,
-  IWhen,
-  IThen
+  [K in keyof O["thens"]]: (
+    ...It: O["thens"][K]
+  ) => (ssel: I["iselection"], utils: PM) => I["then"];
+};
+
+export type TestCheckImplementation<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    TestSuiteShape,
+    TestGivenShape,
+    TestWhenShape,
+    TestThenShape,
+    TestCheckShape
+  >
 > = {
-  iinput: IInput;
-  isubject: ISubject;
-  istore: IStore;
-  iselection: ISelection;
-  given: IGiven;
-  when: IWhen;
-  then: IThen;
+  [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
 };
 
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+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>;
+
 ///////////////////////////////////////////////
 
 export type IPluginFactory = (
@@ -180,7 +301,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 +309,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 +318,6 @@ export type ITestconfig = {
   src: string;
   tests: ITestTypes[];
   webPlugins: IPluginFactory[];
-  reportDomain: string;
 };
 
 export type IBuiltConfig = { buildDir: string } & ITestconfig;

package/src/Web.ts

@@ -1,11 +1,8 @@
 import { PM_Web } from "./PM/web";
 import type {
-  IT,
   ITestImplementation,
   ITestInterface,
   ITestSpecification,
-  IWebTestInterface,
-  OT,
 } from "./Types";
 import Testeranto from "./lib/core.js";
 import {

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;
+}