testeranto 0.140.2 → 0.146.0

package/src/Pure.test.ts

@@ -0,0 +1,299 @@
+import { Ibdd_in, Ibdd_out } from "./CoreTypes";
+import PureTesteranto from "./Pure";
+import { MockPMBase } from "./lib/pmProxy.test/mockPMBase";
+import { IPM } from "./lib/types";
+
+// Test types specific to PureTesteranto testing
+type PureI = Ibdd_in<
+  null, // No initial input needed
+  IPM, // Test subject is IPM
+  { pm: IPM }, // Store contains PM instance
+  { pm: IPM }, // Selection is same as store
+  () => IPM, // Given returns IPM
+  (store: { pm: IPM }) => { pm: IPM }, // When modifies store
+  (store: { pm: IPM }) => { pm: IPM } // Then verifies store
+>;
+
+type PureO = Ibdd_out<
+  { Default: [string] },
+  { Default: [] },
+  {
+    applyProxy: [string]; // When to apply a proxy
+    verifyCall: [string, any]; // Then to verify calls
+  },
+  {
+    verifyProxy: [string]; // Then to verify proxy behavior
+    verifyNoProxy: []; // Then to verify no proxy
+  },
+  { Default: [] }
+>;
+
+// Implementation for PureTesteranto tests
+const implementation = {
+  suites: {
+    Default: "PureTesteranto Test Suite",
+  },
+
+  givens: {
+    Default: () => ({
+      pm: new MockPMBase() as unknown as IPM,
+      config: {},
+      proxies: {
+        butThenProxy: (pm: IPM, path: string) => ({
+          ...pm,
+          writeFileSync: (p: string, c: string) => 
+            pm.writeFileSync(`${path}/butThen/${p}`, c)
+        }),
+        andWhenProxy: (pm: IPM, path: string) => ({
+          ...pm,
+          writeFileSync: (p: string, c: string) => 
+            pm.writeFileSync(`${path}/andWhen/${p}`, c)
+        }),
+        beforeEachProxy: (pm: IPM, suite: string) => ({
+          ...pm,
+          writeFileSync: (p: string, c: string) => 
+            pm.writeFileSync(`suite-${suite}/beforeEach/${p}`, c)
+        })
+      }
+    }),
+  },
+
+  whens: {
+    applyProxy: (proxyType: string) => (store) => {
+      switch (proxyType) {
+        case "invalidConfig":
+          throw new Error("Invalid configuration");
+        case "missingProxy":
+          return { ...store, pm: {} }; // Break proxy chain
+        case "largePayload":
+          return { 
+            ...store, 
+            largePayload: true,
+            pm: {
+              ...store.pm,
+              writeFileSync: (p: string, c: string) => {
+                if (c.length > 1e6) {
+                  return true;
+                }
+                throw new Error("Payload too small");
+              }
+            }
+          };
+        default:
+          return store;
+      }
+    },
+  },
+
+  thens: {
+    verifyProxy: (expectedPath: string) => (store) => {
+      const testPath = "expected";
+      const result = store.pm.writeFileSync(testPath, "content");
+      const actualPath = store.pm.getLastCall("writeFileSync")?.path;
+      if (actualPath !== expectedPath) {
+        throw new Error(`Expected path ${expectedPath}, got ${actualPath}`);
+      }
+      return store;
+    },
+    verifyNoProxy: () => (store) => {
+      if (store.pm.getCallCount("writeFileSync") > 0) {
+        throw new Error("Proxy was unexpectedly applied");
+      }
+      return store;
+    },
+    verifyError: (expectedError: string) => (store) => {
+      try {
+        store.pm.writeFileSync("test", "content");
+        throw new Error("Expected error but none was thrown");
+      } catch (error) {
+        if (!error.message.includes(expectedError)) {
+          throw new Error(`Expected error "${expectedError}", got "${error.message}"`);
+        }
+      }
+      return store;
+    },
+    verifyResourceConfig: () => (store) => {
+      if (!store.pm.testResourceConfiguration) {
+        throw new Error("Missing test resource configuration");
+      }
+      return store;
+    },
+    verifyLargePayload: () => (store) => {
+      const largeContent = "x".repeat(2e6); // 2MB payload
+      const result = store.pm.writeFileSync("large.txt", largeContent);
+      if (!result) {
+        throw new Error("Failed to handle large payload");
+      }
+      return store;
+    },
+    verifyTypeSafety: () => (store) => {
+      // TypeScript will catch these at compile time
+      return store;
+    },
+  },
+
+  checks: {
+    Default: () => ({} as IPM),
+  },
+};
+
+// Specification for PureTesteranto tests
+const specification = (Suite, Given, When, Then, Check) => [
+  Suite.Default("Core Functionality", {
+    initializationTest: Given.Default(
+      ["Should initialize with default configuration"],
+      [],
+      [Then.verifyNoProxy()]
+    ),
+    resourceConfigTest: Given.Default(
+      ["Should handle test resource configuration"],
+      [When.applyProxy("resourceConfig")],
+      [Then.verifyResourceConfig()]
+    ),
+  }),
+
+  Suite.Default("Proxy Integration", {
+    butThenProxyTest: Given.Default(
+      ["Should integrate with butThenProxy"],
+      [When.applyProxy("butThenProxy")],
+      [Then.verifyProxy("test/path/butThen/expected")]
+    ),
+    andWhenProxyTest: Given.Default(
+      ["Should integrate with andWhenProxy"],
+      [When.applyProxy("andWhenProxy")],
+      [Then.verifyProxy("test/path/andWhen/expected")]
+    ),
+    beforeEachProxyTest: Given.Default(
+      ["Should integrate with beforeEachProxy"],
+      [When.applyProxy("beforeEachProxy")],
+      [Then.verifyProxy("suite-1/beforeEach/expected")]
+    ),
+  }),
+
+  Suite.Default("Error Handling", {
+    invalidConfigTest: Given.Default(
+      ["Should handle invalid configuration"],
+      [When.applyProxy("invalidConfig")],
+      [Then.verifyError("Invalid configuration")]
+    ),
+    missingProxyTest: Given.Default(
+      ["Should handle missing proxy"],
+      [When.applyProxy("missingProxy")],
+      [Then.verifyError("Proxy not found")]
+    ),
+  }),
+
+  Suite.Default("Performance", {
+    multipleProxiesTest: Given.Default(
+      ["Should handle multiple proxies efficiently"],
+      [
+        When.applyProxy("butThenProxy"),
+        When.applyProxy("andWhenProxy"),
+        When.applyProxy("beforeEachProxy")
+      ],
+      [
+        Then.verifyProxy("test/path/butThen/expected"),
+        Then.verifyProxy("test/path/andWhen/expected"),
+        Then.verifyProxy("suite-1/beforeEach/expected")
+      ]
+    ),
+    largePayloadTest: Given.Default(
+      ["Should handle large payloads"],
+      [When.applyProxy("largePayload")],
+      [Then.verifyLargePayload()]
+    ),
+  }),
+
+  Suite.Default("Cross-Component Verification", {
+    proxyChainTest: Given.Default(
+      ["Proxies should chain correctly"],
+      [
+        When.applyProxy("butThenProxy"),
+        When.applyProxy("andWhenProxy")
+      ],
+      [
+        Then.verifyProxy("test/path/andWhen/butThen/expected")
+      ]
+    ),
+    errorPropagationTest: Given.Default(
+      ["Errors should propagate across components"],
+      [When.applyProxy("invalidConfig")],
+      [Then.verifyError("Invalid configuration")]
+    ),
+    resourceSharingTest: Given.Default(
+      ["Resources should be shared correctly"],
+      [When.applyProxy("resourceConfig")],
+      [Then.verifyResourceConfig()]
+    )
+  }),
+
+  Suite.Default("Type Safety", {
+    strictTypeTest: Given.Default(
+      ["Should enforce type safety"],
+      [When.applyProxy("typeSafe")],
+      [Then.verifyTypeSafety()]
+    ),
+    invalidTypeTest: Given.Default(
+      ["Should reject invalid types"],
+      [When.applyProxy("invalidType")],
+      [Then.verifyError("Type mismatch")]
+    ),
+  }),
+
+  Suite.Default("Integration Tests", {
+    // Verify builders work together
+    builderIntegration: Given.Default(
+      ["BaseBuilder and ClassBuilder should integrate properly"],
+      [],
+      [
+        Then.initializedProperly(),
+        Then.specsGenerated(),
+        Then.jobsCreated(),
+        Then.artifactsTracked()
+      ]
+    ),
+
+    // Verify PM proxy integration  
+    pmProxyIntegration: Given.Default(
+      ["PM proxies should work with test runners"],
+      [When.applyProxy("butThenProxy")],
+      [Then.verifyProxy("test/path/butThen/expected")]
+    ),
+
+    // Verify full test lifecycle
+    fullLifecycle: Given.Default(
+      ["Should complete full test lifecycle"],
+      [
+        When.addArtifact(Promise.resolve("test")),
+        When.setTestJobs([]),
+        When.modifySpecs((specs) => [...specs])
+      ],
+      [
+        Then.testRunSuccessful(),
+        Then.artifactsTracked(),
+        Then.specsModified(0)
+      ]
+    )
+  })
+];
+
+// Test interface for PureTesteranto
+const testInterface = {
+  beforeEach: async (subject, initializer) => {
+    return { pm: initializer() };
+  },
+  andWhen: async (store, whenCB) => whenCB(store),
+  butThen: async (store, thenCB) => thenCB(store),
+  afterEach: async (store) => store,
+  afterAll: async () => {},
+  beforeAll: async (input, testResource) => ({} as IPM),
+  assertThis: (x) => x,
+};
+
+// Export the test suite
+export default PureTesteranto<PureI, PureO, {}>(
+  null, // No initial input
+  specification,
+  implementation,
+  testInterface
+);

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,30 +1,30 @@
-import { BaseSuite } from "./BaseSuite";
-import { BaseGiven, BaseWhen, BaseThen, BaseCheck } from "./abstractBase";
-import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
-import { IPM } from "./types";
+import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from "..";
 import {
   Ibdd_in,
   Ibdd_out,
   ITestSpecification,
   ITestImplementation,
   ITestInterface,
-} from "../CoreTypes";
-import Testeranto from "../Node";
+} 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
@@ -33,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
   },
@@ -55,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[],
@@ -84,7 +84,7 @@ class MockGiven extends BaseGiven<I> {
   }
 
   uberCatcher(e: Error): void {
-    console.error("Given error:", e);
+    console.error("Given error 2:", e);
   }
 }
 
@@ -158,11 +158,11 @@ class TestableSuite extends BaseSuite<I, O> {
 }
 
 // 3. Enhanced Test Specification with more test cases
-const specification: ITestSpecification<I, O> = (
-  Suite: SuiteSpecification<I, O>,
-  Given: GivenSpecification<I, O>,
+export const specification: ITestSpecification<I, O> = (
+  Suite: ITestSpecification<I, O>,
+  Given: WhenSpecification<I, O>,
   When: WhenSpecification<I, O>,
-  Then: ThenSpecification<I, O>,
+  Then: WhenSpecification<I, O>,
   Check: ITestCheckCallback<I, O>
 ) => [
   Suite.Default(
@@ -219,10 +219,27 @@ const specification: ITestSpecification<I, O> = (
       // )
     ]
   ),
+
+  Suite.Default("Comprehensive Integration", {
+    fullStackTest: Given.Default(
+      ["All components should work together"],
+      [
+        When.addArtifact(Promise.resolve("test")),
+        When.modifySpecs((specs) => [...specs, "extra"]),
+        When.modifyJobs((jobs) => [...jobs, {}]),
+      ],
+      [
+        Then.specsModified(1),
+        Then.jobsModified(1),
+        Then.artifactsTracked(),
+        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,
   },
@@ -415,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"]
@@ -447,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
+);