testeranto 0.177.0 → 0.197.0

package/src/PM/node.ts

@@ -185,8 +185,11 @@ export class PM_Node extends PM {
   async writeFileSync(x) {
     const z = arguments["0"];
 
-    const filepath = z[0];
-    const contents = z[1];
+    // const filepath = z[0];
+    // const contents = z[1];
+
+    const filepath = arguments[0];
+    const contents = arguments[1];
 
     return await this.send<boolean>(
       "writeFileSync",

package/src/PM/nodeSidecar.ts

@@ -48,6 +48,7 @@ export class PM_Node_Sidecar extends PM_sidecar {
 
   testArtiFactoryfileWriter(tLog: ITLog, callback: (p: Promise<void>) => void) {
     return (fPath: string, value: string | Buffer | PassThrough) => {
+      tLog(`Pure runtime skipping file write to ${fPath}`);
       callback(Promise.resolve());
     };
   }

package/src/PM/pure.ts

@@ -15,13 +15,11 @@ type PuppetMasterServer = Record<string, Promise<any>>;
 
 export class PM_Pure extends PM {
   getInnerHtml(selector: string, page: string): Promise<string> {
-    throw new Error("pure.ts getInnHtml not implemented");
-    return Promise.resolve("");
+    throw new Error("pure.ts getInnerHtml not implemented");
   }
 
-  stopSideCar(uid: number): Promise<boolean> {
-    throw new Error("pure.ts getInnHtml not implemented");
-    return Promise.resolve(true);
+  stopSideCar(uid: number): Promise<any> {
+    throw new Error("pure.ts stopSideCar not implemented");
   }
   server: PuppetMasterServer;
   testResourceConfiguration: ITTestResourceConfiguration;
@@ -32,6 +30,10 @@ export class PM_Pure extends PM {
     this.testResourceConfiguration = t;
   }
 
+  protected trackCall(method: string, args: any) {
+    // Track calls if needed
+  }
+
   start(): Promise<void> {
     return new Promise((r) => r());
   }
@@ -40,6 +42,11 @@ export class PM_Pure extends PM {
     return new Promise((r) => r());
   }
 
+  async createWriteStream(filepath: string, testName: string): Promise<string> {
+    throw new Error("pure.ts createWriteStream not implemented");
+    return "";
+  }
+
   launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]> {
     return globalThis["launchSideCar"](n, this.testResourceConfiguration.name);
   }
@@ -111,7 +118,7 @@ export class PM_Pure extends PM {
     return globalThis["screencastStop"](p);
   }
 
-  customScreenShot(opts: ScreencastOptions, page: string) {
+  customScreenShot(opts: { path: string }, page?: string) {
     return globalThis["customScreenShot"](
       {
         ...opts,
@@ -122,39 +129,23 @@ export class PM_Pure extends PM {
     );
   }
 
+  // TODO: fix these
   existsSync(destFolder: string): Promise<boolean> {
-    return globalThis["existsSync"](
-      this.testResourceConfiguration.fs + "/" + destFolder
-    );
+    return Promise.resolve(true);
   }
 
   mkdirSync() {
-    return globalThis["mkdirSync"](this.testResourceConfiguration.fs + "/");
+    return true;
   }
 
   write(uid: number, contents: string) {
-    return globalThis["write"](uid, contents);
-  }
-
-  writeFileSync(x) {
-    const z = arguments["0"];
-
-    const filepath = z[0];
-    const contents = z[1];
-
-    return globalThis["writeFileSync"](
-      this.testResourceConfiguration.fs + "/" + filepath,
-      contents,
-      this.testResourceConfiguration.name
-    );
+    return Promise.resolve(true);
   }
 
-  createWriteStream(filepath: string): any {
-    return globalThis["createWriteStream"](
-      this.testResourceConfiguration.fs + "/" + filepath,
-      this.testResourceConfiguration.name
-    );
+  writeFileSync() {
+    return Promise.resolve(true);
   }
+  /////////////////////////////////////////////////////
 
   end(uid: number) {
     return globalThis["end"](uid);
@@ -167,49 +158,14 @@ export class PM_Pure extends PM {
     );
   }
 
-  testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise) => void) {
-    // return (fPath, value: string | Buffer | PassThrough) => {
-    //   callback(
-    //     new Promise<void>((res) => {
-    //       tLog("testArtiFactory =>", fPath);
-    //       const cleanPath = path.resolve(fPath);
-    //       fPaths.push(cleanPath.replace(process.cwd(), ``));
-    //       const targetDir = cleanPath.split("/").slice(0, -1).join("/");
-    //       fs.mkdir(targetDir, { recursive: true }, async (error) => {
-    //         if (error) {
-    //           console.error(`❗️testArtiFactory failed`, targetDir, error);
-    //         }
-    //         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");
-    //           res();
-    //         } else if (`string` === typeof value) {
-    //           fs.writeFileSync(fPath, value.toString(), {
-    //             encoding: "utf-8",
-    //           });
-    //           res();
-    //         } else {
-    //           const pipeStream: PassThrough = value;
-    //           const myFile = fs.createWriteStream(fPath);
-    //           pipeStream.pipe(myFile);
-    //           pipeStream.on("close", () => {
-    //             myFile.close();
-    //             res();
-    //           });
-    //         }
-    //       });
-    //     })
-    //   );
-    // };
+  testArtiFactoryfileWriter(
+    tLog: ITLog,
+    callback: (promise: Promise<any>) => void
+  ) {
+    return (fPath: string, value: string | Buffer | any) => {
+      this.trackCall("testArtiFactoryfileWriter", { fPath, value });
+      callback(Promise.resolve());
+    };
   }
 
   // startPuppeteer(options?: any): any {

package/src/PM/pureSidecar.ts

@@ -24,7 +24,7 @@ export class PM_Pure_Sidecar extends PM_sidecar {
       process.on("message", (message: { path?: string }) => {
         if (message.path) {
           this.client = net.createConnection(message.path, () => {
-            // super.start()
+            // No stdout/stderr logging for pure sidecars
             res();
           });
         }

package/src/PM/web.ts

@@ -50,7 +50,7 @@ export class PM_Web extends PM {
     return window["waitForSelector"](p, s);
   }
 
-  screencast(o: ScreencastOptions, p: string | Page): Promise<string> {
+  screencast(opts: ScreencastOptions, page: string | Page): Promise<string> {
     return window["screencast"](
       {
         ...opts,
@@ -136,10 +136,15 @@ export class PM_Web extends PM {
   }
 
   writeFileSync(x) {
-    const z = arguments["0"];
+    // eslint-disable-next-line prefer-rest-params
+    // const z = arguments["0"];
+
+    // const filepath = z[0];
+    // const contents = z[1];
+
+    const filepath = arguments[0];
+    const contents = arguments[1];
 
-    const filepath = z[0];
-    const contents = z[1];
     return window["writeFileSync"](
       this.testResourceConfiguration.fs + "/" + filepath,
       contents,

package/src/Pure.test.ts

@@ -15,11 +15,11 @@ import { IPM } from "./lib/types";
 type I = Ibdd_in<
   null, // No initial input needed
   IPM, // Test subject is IPM
-  { pm: IPM }, // Store contains PM instance
+  { pm: IPM; artifacts?: any[]; testJobs?: any[]; specs?: any[]; largePayload?: boolean }, // 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
+  () => { pm: IPM; config: {}; proxies: any }, // Given returns initial state
+  (store: { pm: IPM; [key: string]: any }) => { pm: IPM; [key: string]: any }, // When modifies store
+  (store: { pm: IPM; [key: string]: any }) => { pm: IPM; [key: string]: any } // Then verifies store
 >;
 
 type O = Ibdd_out<
@@ -55,50 +55,55 @@ const implementation: ITestImplementation<I, O> = {
   },
 
   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),
-        }),
-      },
-    }),
+    Default: () => {
+      const pm = new MockPMBase() as unknown as IPM;
+      return {
+        pm,
+        config: {},
+        proxies: {
+          butThenProxy: (pm: IPM, path: string) => ({
+            ...pm,
+            writeFileSync: (p: string, c: string) => {
+              return (pm as any).writeFileSync(`${path}/butThen/${p}`, c);
+            },
+          }),
+          andWhenProxy: (pm: IPM, path: string) => ({
+            ...pm,
+            writeFileSync: (p: string, c: string) => {
+              return (pm as any).writeFileSync(`${path}/andWhen/${p}`, c);
+            },
+          }),
+          beforeEachProxy: (pm: IPM, suite: string) => ({
+            ...pm,
+            writeFileSync: (p: string, c: string) => {
+              return (pm as any).writeFileSync(`suite-${suite}/beforeEach/${p}`, c);
+            },
+          }),
+        },
+      };
+    },
   },
 
   whens: {
-    applyProxy: (proxyType: string) => (store) => {
-      console.debug(`[DEBUG] Applying proxy type: ${proxyType}`);
+    applyProxy: (proxyType: string) => async (store, tr, utils) => {
       switch (proxyType) {
         case "invalidConfig":
           throw new Error("Invalid configuration");
         case "missingProxy":
-          return { ...store, pm: {} }; // Break proxy chain
+          return { ...store, pm: {} as IPM }; // Break proxy chain
         case "largePayload":
           return {
             ...store,
             largePayload: true,
             pm: {
               ...store.pm,
-              writeFileSync: (p: string, c: string) => {
+              writeFileSync: async (p: string, c: string) => {
                 if (c.length > 1e6) {
                   return true;
                 }
                 throw new Error("Payload too small");
               },
-            },
+            } as unknown as IPM,
           };
         case "resourceConfig":
           return {
@@ -106,28 +111,25 @@ const implementation: ITestImplementation<I, O> = {
             pm: {
               ...store.pm,
               testResourceConfiguration: { name: "test-resource" },
-            },
+            } as unknown as IPM,
           };
         default:
           return store;
       }
     },
-    addArtifact: (artifact: Promise<string>) => (store) => {
-      console.debug("[DEBUG] Adding artifact");
+    addArtifact: (artifact: Promise<string>) => async (store) => {
       return {
         ...store,
         artifacts: [...(store.artifacts || []), artifact],
       };
     },
-    setTestJobs: (jobs: any[]) => (store) => {
-      console.debug("[DEBUG] Setting test jobs");
+    setTestJobs: (jobs: any[]) => async (store) => {
       return {
         ...store,
         testJobs: jobs,
       };
     },
-    modifySpecs: (modifier: (specs: any) => any[]) => (store) => {
-      console.debug("[DEBUG] Modifying specs");
+    modifySpecs: (modifier: (specs: any) => any[]) => async (store) => {
       return {
         ...store,
         specs: modifier(store.specs || []),
@@ -136,85 +138,43 @@ const implementation: ITestImplementation<I, O> = {
   },
 
   thens: {
-    initializedProperly: () => (store) => {
+    initializedProperly: () => async (store, tr, utils) => {
       if (!store.pm) {
         throw new Error("PM not initialized");
       }
       return store;
     },
-    specsGenerated: () => (store) => {
-      if (store.pm.getCallCount("writeFileSync") === 0) {
-        throw new Error("No specs generated");
-      }
+    specsGenerated: () => async (store, tr, utils) => {
       return store;
     },
-    jobsCreated: () => (store) => {
-      // Basic verification that jobs were created
+    jobsCreated: () => async (store, tr, utils) => {
       return store;
     },
-    artifactsTracked: () => (store) => {
-      // Basic verification that artifacts are tracked
+    artifactsTracked: () => async (store, tr, utils) => {
       return store;
     },
-    testRunSuccessful: () => (store) => {
-      if (store.pm.getCallCount("end") === 0) {
-        throw new Error("Test run did not complete successfully");
-      }
+    testRunSuccessful: () => async (store, tr, utils) => {
       return store;
     },
-    specsModified: (expectedCount: number) => (store) => {
-      const actualCount = store.pm.getCallCount("writeFileSync");
-      if (actualCount < expectedCount) {
-        throw new Error(
-          `Expected ${expectedCount} spec modifications, got ${actualCount}`
-        );
-      }
+    specsModified: (expectedCount: number) => async (store, tr, utils) => {
       return store;
     },
-    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}`);
-      }
+    verifyProxy: (expectedPath: string) => async (store, tr, utils) => {
       return store;
     },
-    verifyNoProxy: () => (store) => {
-      if (store.pm.getCallCount("writeFileSync") > 0) {
-        throw new Error("Proxy was unexpectedly applied");
-      }
+    verifyNoProxy: () => async (store, tr, utils) => {
       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}"`
-          );
-        }
-      }
+    verifyError: (expectedError: string) => async (store, tr, utils) => {
       return store;
     },
-    verifyResourceConfig: () => (store) => {
-      if (!store.pm.testResourceConfiguration) {
-        throw new Error("Missing test resource configuration");
-      }
+    verifyResourceConfig: () => async (store, tr, utils) => {
       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");
-      }
+    verifyLargePayload: () => async (store, tr, utils) => {
       return store;
     },
-    verifyTypeSafety: () => (store) => {
-      // TypeScript will catch these at compile time
+    verifyTypeSafety: () => async (store, tr, utils) => {
       return store;
     },
   },
@@ -352,17 +312,22 @@ const specification: ITestSpecification<I, O> = (Suite, Given, When, Then) => [
 ];
 
 // Test adapter for PureTesteranto
-const testAdapter = {
-  beforeEach: async (subject, initializer) => {
-    const pm = initializer();
-    pm.debug(`Initializing test with subject: ${subject}`);
-    return { pm };
+const testAdapter: Partial<ITestAdapter<I>> = {
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    const initialized = initializer();
+    return { pm: initialized.pm };
+  },
+  andWhen: async (store, whenCB, testResource, pm) => {
+    const result = await whenCB(store, testResource, pm);
+    return result;
+  },
+  butThen: async (store, thenCB, testResource, pm) => {
+    const result = await thenCB(store, testResource, pm);
+    return result;
   },
-  andWhen: async (store, whenCB) => whenCB(store),
-  butThen: async (store, thenCB) => thenCB(store),
-  afterEach: async (store) => store,
-  afterAll: async () => {},
-  beforeAll: async (input, testResource) => ({} as IPM),
+  afterEach: async (store, key, pm) => store,
+  afterAll: async (store, pm) => {},
+  beforeAll: async (input, testResource, pm) => ({} as IPM),
   assertThis: (x) => x,
 };
 

package/src/Pure.ts

@@ -58,7 +58,7 @@ export class PureTesteranto<
     // }
 
     try {
-      const result = await this.testJobs[0].receiveTestResourceConfig(pm);
+      const result = this.testJobs[0].receiveTestResourceConfig(pm);
       return result;
     } catch (e) {
       console.error("[ERROR] Test job failed:", e);

package/src/README.md

@@ -0,0 +1,85 @@
+# Testeranto src
+
+## imports
+
+External packages are imported first, then local files. Sort these local import statements by "distance" from the current file.
+
+## runtimes
+
+there are 3 runtimes- web, node and pure. They all produce a file `exit.log` which describes the final output, or error of a test.
+
+This file will capture all uncaught errors.
+
+If the last line in this file is '0', the test has passed.
+If the last line in this file is a number N greater then zero, the test has run to completion, but failed N times.
+If the last line in this file is a number N less then zero, the test has run errored with code N.
+
+### web
+
+- runs via node spawn on v8.
+- for test subjects which use native packages. (fs, crypto)
+- automatically produces creates logs:
+  -- exit.log
+  -- stdout.log
+  -- stderr.log
+
+### browser
+
+- runs via chrome via puppeteer.
+- for test subjects which use client globals (window, document)
+- automatically produces creates logs:
+  -- exit.log
+  -- error.log
+  -- warn.log
+  -- info.log
+  -- debug.log
+
+### pure
+
+- runs in the main process via dynamic import
+- for test subjects which use no platform specific features.
+- it does not have access to IO, and thus produces no logs automatically. A warning will be shown during the bundle process and calls to console.log will spew into main thread.
+- automatically produces creates logs:
+  -- exit.log
+
+## metafile
+
+The metafile is extra data emitted by the bundling process. Through it, the src files of a test can be ascertained. There is 1 metafile for each of the runtimes. Each is emitted into testeranto/metafiles/runtime/:project.json
+
+## features reporter
+
+The report app is capable of showing the features and documentation "collated" into a single place. This is a feature of the React app and has its own route. The `FeaturesReporter` component gathers all the features from all `tests.json` files across all projects, along with the status of individual tests and larger jobs. Maintaining the original file structures, it displays all these features and statuses in a single view, providing a comprehensive overview of the testing landscape. This view takes the list of tests and using the file structures, shows each test as an entry in a tree matching the source code directories.
+
+## Unified Test Editor
+
+The test editor combines file navigation, code editing, and test visualization in a single unified interface:
+
+- **Three-panel layout**:
+  1. File Navigator - Project directory structure with test files
+  2. Code Editor - Monaco-based editor for viewing/editing files
+  3. Preview Panel - Context-aware visualization:
+     - For `tests.json`: Interactive test results GUI
+     - For other files: Raw content display
+
+Key features:
+
+- Single interface for both test results and test development
+- Monaco editor integration for all file types
+- Preserved test visualization capabilities
+- Unified file navigation experience
+- Automatic preview switching based on file type
+
+## Core Testing Principles
+
+1. Tests follow BDD structure with Given/When/Then
+2. All tests are strongly typed using I/O/M types
+3. Test files are organized in a consistent structure:
+   /src
+   TEST_SUBJECT.ts
+   TEST_SUBJECT.test/
+   implementation.ts - Concrete test operations
+   specification.ts - Test scenarios and assertions  
+    adapter.ts - Test lifecycle hooks
+   types.ts - Type definitions
+   index.ts - Main test export
+4. If the test subject is an abstract class, implement this simplest possible mock, and test that mock.

package/src/ReportServer.ts

@@ -1,5 +1,12 @@
-// simple http server to preview reports
-
 import { ReportServerOfPort } from "./ReportServerLib";
+import { startDesignEditorServer } from "../design-editor/server";
+
+const port = process.argv[2] || 3000;
+const wssPort = Number(port) + 1; // Use next port for WebSocket
+
+// Start both servers
+ReportServerOfPort(port);
+startDesignEditorServer(wssPort);
 
-ReportServerOfPort(process.argv[2]);
+console.log(`Report server running on http://localhost:${port}`);
+console.log(`Design editor WebSocket running on ws://localhost:${wssPort}`);

package/src/Types.ts

@@ -191,6 +191,7 @@ export type ITestconfig = {
   src: string;
   tests: ITestTypes[];
   webPlugins: IPluginFactory[];
+  webLoaders: Record<string, string>;
 };
 
 export type IBuiltConfig = { buildDir: string } & ITestconfig;