testeranto 0.134.0 → 0.135.0

package/src/PM/node.ts

@@ -241,16 +241,16 @@ export class PM_Node extends PM {
               console.error(`❗️testArtiFactory failed`, targetDir, error);
             }
 
-            fs.writeFileSync(
-              path.resolve(
-                targetDir.split("/").slice(0, -1).join("/"),
-                "manifest"
-              ),
-              fPaths.join(`\n`),
-              {
-                encoding: "utf-8",
-              }
-            );
+            // fs.writeFileSync(
+            //   path.resolve(
+            //     targetDir.split("/").slice(0, -1).join("/"),
+            //     "manifest"
+            //   ),
+            //   fPaths.join(`\n`),
+            //   {
+            //     encoding: "utf-8",
+            //   }
+            // );
 
             if (Buffer.isBuffer(value)) {
               fs.writeFileSync(fPath, value, "binary");

package/src/Types.ts

@@ -2,16 +2,42 @@
 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,
-  BaseSuite,
   BaseWhen,
   BaseThen,
   BaseGiven,
+  BaseCheck,
+  BaseSuite,
+  IGivens,
 } from "./lib/abstractBase.js";
-import { ITestCheckCallback } from "./lib/types.js";
+
+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>;
+};
 
 // Simplified test result summary
 export type TestSummary = {
@@ -82,16 +108,24 @@ export type ProjectConfig = {
   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> = {
+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>[],
@@ -100,35 +134,102 @@ export type GivenSpecification<I extends IT, O extends OT> = {
   ) => BaseGiven<I>;
 };
 
-export type WhenSpecification<I extends IT, O extends OT> = {
+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 IT, O extends OT> = {
+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>;
 };
 
-// Complete test specification
-export type ITestSpecification<I extends IT, O extends OT> = (
-  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> = {
+export type TestSuiteImplementation<
+  O extends Ibdd_out<
+    TestSuiteShape,
+    TestGivenShape,
+    TestWhenShape,
+    TestThenShape,
+    TestCheckShape
+  >
+> = {
   [K in keyof O["suites"]]: string;
 };
 
-export type TestGivenImplementation<I extends IT, O extends OT> = {
+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 TestWhenImplementation<I extends IT, O extends OT> = {
+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]
   ) => (
@@ -138,72 +239,50 @@ export type TestWhenImplementation<I extends IT, O extends OT> = {
   ) => Promise<I["when"]>;
 };
 
-export type TestThenImplementation<I extends IT, O extends OT> = {
+export type TestThenImplementation<
+  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"]]: (
     ...It: O["thens"][K]
   ) => (ssel: I["iselection"], utils: PM) => I["then"];
 };
 
-export type TestCheckImplementation<I extends IT, O extends OT> = {
+export type TestCheckImplementation<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
+    TestSuiteShape,
+    TestGivenShape,
+    TestWhenShape,
+    TestThenShape,
+    TestCheckShape
+  >
+> = {
   [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
 };
 
-// Complete test implementation
-export type ITestImplementation<
-  I extends IT,
-  O extends OT,
-  modifier = {
-    whens: TestWhenImplementation<I, O>;
-  }
-> = Modify<
-  {
-    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;
@@ -215,69 +294,6 @@ 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 TestSuiteShape = TestSuiteShape,
-  IGivens extends TestGivenShape = TestGivenShape,
-  IWhens extends TestWhenShape = TestWhenShape,
-  IThens extends TestThenShape = TestThenShape,
-  IChecks extends TestCheckShape = TestCheckShape
-> = {
-  suites: ISuites;
-  givens: IGivens;
-  whens: IWhens;
-  thens: IThens;
-  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, // 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 = (

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/build.ts

@@ -195,13 +195,14 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     <title>${pckge.name} - testeranto</title>
     <meta name="viewport" content="width=device-width, initial-scale=1" />
     <meta name="author" content="" />
+    <base href="https://adamwong246.github.io/spacetrash_v8" target="_blank">
 
     <script type="application/json" id="bigConfig">
       ${JSON.stringify(Object.keys(bigConfig.projects))}
     </script>
 
-    <link rel="stylesheet" href="Project.css" />
-    <script type="module" src="Project.js"></script>
+    <link rel="stylesheet" href="/reports/Project.css" />
+    <script type="module" src="/reports/Project.js"></script>
 
   </head>
 

package/src/esbuildConfigs/eslint-formatter-testeranto.ts

@@ -1,5 +1,21 @@
 import { LintResult } from "eslint/lib/linter";
 
 export default function (results: LintResult[]) {
-  return JSON.stringify(results, null, 2);
+  return results
+    .filter((r) => r.messages.length)
+    .map((r) => {
+      const path = r.filePath.replace(process.cwd() + "/", "");
+      return [
+        path,
+        ...r.messages.map((m) =>
+          [
+            `${m.line}:${m.column} ${m.message} (${m.ruleId || ""})`,
+            ...(m.suggestions?.map(
+              (s) => `- ${s.message}${s.fix ? " (fix)" : ""}`
+            ) || []),
+          ].join("\n")
+        ),
+      ].join("\n");
+    })
+    .join("\n\n");
 }

package/src/esbuildConfigs/node.ts

@@ -5,6 +5,7 @@ import { ITestconfig } from "../lib/index.js";
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
 import featuresPlugin from "./featuresPlugin";
+import rebuildPlugin from "./rebuildPlugin.js";
 
 export default (
   config: ITestconfig,
@@ -44,24 +45,7 @@ export default (
       featuresPlugin,
 
       inputFilesPluginFactory,
-      {
-        name: "rebuild-notify",
-        setup: (build) => {
-          build.onStart(() => {
-            console.log(`> node build starting...`);
-          });
-          build.onEnd((result) => {
-            console.log(
-              `> node build ended with ${result.errors.length} errors`
-            );
-            if (result.errors.length > 0) {
-              console.log(result);
-            }
-            // console.log(result);
-            // result.errors.length !== 0 && process.exit(-1);
-          });
-        },
-      },
+      rebuildPlugin("node"),
 
       ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
     ],

package/src/esbuildConfigs/pure.ts

@@ -8,6 +8,7 @@ import featuresPlugin from "./featuresPlugin.js";
 
 import { isBuiltin } from "node:module";
 import { consoleDetectorPlugin } from "./consoleDetectorPlugin.js";
+import rebuildPlugin from "./rebuildPlugin.js";
 
 export default (
   config: ITestconfig,
@@ -67,24 +68,7 @@ export default (
         },
       },
 
-      {
-        name: "rebuild-notify",
-        setup: (build) => {
-          build.onStart(() => {
-            console.log(`> pure build starting...`);
-          });
-          build.onEnd((result) => {
-            console.log(
-              `> pure build ended with ${result.errors.length} errors`
-            );
-            if (result.errors.length > 0) {
-              console.log(result);
-            }
-            // console.log(result);
-            // result.errors.length !== 0 && process.exit(-1);
-          });
-        },
-      },
+      rebuildPlugin("pure"),
 
       ...((config.nodePlugins || []).map((p) => p(register, entryPoints)) ||
         []),

package/src/esbuildConfigs/rebuildPlugin.ts

@@ -0,0 +1,23 @@
+import fs from "fs";
+
+import { IRunTime } from "../lib";
+
+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`);
+        if (result.errors.length > 0) {
+          fs.writeFileSync(
+            `./testeranto/reports${r}_build_errors`,
+            JSON.stringify(result, null, 2)
+          );
+        }
+      });
+    },
+  };
+};

package/src/esbuildConfigs/web.ts

@@ -8,6 +8,7 @@ import { ITestconfig } from "../lib/index.js";
 import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
 import featuresPlugin from "./featuresPlugin.js";
+import rebuildPlugin from "./rebuildPlugin.js";
 
 export default (
   config: ITestconfig,
@@ -68,24 +69,7 @@ export default (
         // }
       }),
 
-      {
-        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`
-            );
-            if (result.errors.length > 0) {
-              console.log(result);
-            }
-            // console.log(result);
-            // result.errors.length !== 0 && process.exit(-1);
-          });
-        },
-      },
+      rebuildPlugin("web"),
 
       ...((config.webPlugins || []).map((p) => p(register, entryPoints)) || []),
     ],

package/src/lib/abstractBase.ts

@@ -206,7 +206,12 @@ export abstract class BaseGiven<I extends IT = IT> {
     return {
       key: this.key,
       name: this.name,
-      whens: this.whens.map((w) => w.toObj()),
+      whens: this.whens.map((w) => {
+        if (w && w.toObj) return w.toObj();
+
+        console.error("w is not as expected!", w);
+        return {};
+      }),
       thens: this.thens.map((t) => t.toObj()),
       error: this.error ? [this.error, this.error.stack] : null,
       failed: this.failed,

package/src/lib/classBuilder.ts

@@ -63,7 +63,6 @@ export abstract class ClassBuilder<
     const classyGivens = Object.entries(testImplementation.givens).reduce(
       (a, [key, g]) => {
         a[key] = (features, whens, thens, ...initialValues) => {
-          // console.log("givEn", givEn.toString());
           return new givenKlasser.prototype.constructor(
             key,
             features,
@@ -80,10 +79,10 @@ export abstract class ClassBuilder<
 
     const classyWhens = Object.entries(testImplementation.whens).reduce(
       (a, [key, whEn]: [string, (x) => any]) => {
-        a[key] = (payload?: any) => {
+        a[key] = (...payload: any) => {
           return new whenKlasser.prototype.constructor(
             `${whEn.name}: ${payload && payload.toString()}`,
-            whEn(payload)
+            whEn(...payload)
           );
         };
         return a;
@@ -91,7 +90,9 @@ export abstract class ClassBuilder<
       {}
     );
 
-    const classyThens = Object.entries<(expected: any, ...x: any[]) => any>(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) => {
           return new thenKlasser.prototype.constructor(

package/src/lib/core.ts

@@ -1,12 +1,3 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import {
-  ITestSpecification,
-  ITestImplementation,
-  ITestInterface,
-  IT,
-  OT,
-} from "../Types.js";
-
 import {
   DefaultTestInterface,
   IFinalResults,
@@ -24,6 +15,11 @@ import {
 } from "./abstractBase.js";
 import { ClassBuilder } from "./classBuilder.js";
 import { IPM } from "./types";
+import {
+  ITestSpecification,
+  ITestImplementation,
+  ITestInterface,
+} from "../CoreTypes.js";
 
 export default abstract class Testeranto<
   I extends IT,