testeranto 0.177.0 → 0.189.0

package/src/PM/pure.ts

@@ -123,37 +123,31 @@ export class PM_Pure extends PM {
   }
 
   existsSync(destFolder: string): Promise<boolean> {
-    return globalThis["existsSync"](
-      this.testResourceConfiguration.fs + "/" + destFolder
-    );
+    // Pure runtime doesn't need filesystem checks
+    return Promise.resolve(true);
   }
 
   mkdirSync() {
-    return globalThis["mkdirSync"](this.testResourceConfiguration.fs + "/");
+    // Pure runtime doesn't need directories
+    return true;
   }
 
   write(uid: number, contents: string) {
-    return globalThis["write"](uid, contents);
+    // Pure runtime doesn't need file writing
+    return Promise.resolve(true);
   }
 
-  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
-    );
+  writeFileSync() {
+    // Pure runtime doesn't need file writing
+    return Promise.resolve(true);
   }
 
-  createWriteStream(filepath: string): any {
-    return globalThis["createWriteStream"](
-      this.testResourceConfiguration.fs + "/" + filepath,
-      this.testResourceConfiguration.name
-    );
+  createWriteStream() {
+    // Pure runtime doesn't need file streams
+    return {
+      write: () => true,
+      end: () => {}
+    };
   }
 
   end(uid: number) {

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,6 +136,7 @@ export class PM_Web extends PM {
   }
 
   writeFileSync(x) {
+    // eslint-disable-next-line prefer-rest-params
     const z = arguments["0"];
 
     const filepath = z[0];

package/src/Pure.test.ts

@@ -80,7 +80,6 @@ const implementation: ITestImplementation<I, O> = {
 
   whens: {
     applyProxy: (proxyType: string) => (store) => {
-      console.debug(`[DEBUG] Applying proxy type: ${proxyType}`);
       switch (proxyType) {
         case "invalidConfig":
           throw new Error("Invalid configuration");
@@ -113,21 +112,18 @@ const implementation: ITestImplementation<I, O> = {
       }
     },
     addArtifact: (artifact: Promise<string>) => (store) => {
-      console.debug("[DEBUG] Adding artifact");
       return {
         ...store,
         artifacts: [...(store.artifacts || []), artifact],
       };
     },
     setTestJobs: (jobs: any[]) => (store) => {
-      console.debug("[DEBUG] Setting test jobs");
       return {
         ...store,
         testJobs: jobs,
       };
     },
     modifySpecs: (modifier: (specs: any) => any[]) => (store) => {
-      console.debug("[DEBUG] Modifying specs");
       return {
         ...store,
         specs: modifier(store.specs || []),
@@ -187,16 +183,16 @@ const implementation: ITestImplementation<I, O> = {
       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}"`
-          );
-        }
-      }
+      // 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) => {
@@ -353,13 +349,18 @@ 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 };
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    const initializedPm = initializer();
+    return { pm: initializedPm };
+  },
+  andWhen: async (store, whenCB) => {
+    whenCB(store);
+    return store;
+  },
+  butThen: async (store, thenCB) => {
+    thenCB(store);
+    return store;
   },
-  andWhen: async (store, whenCB) => whenCB(store),
-  butThen: async (store, thenCB) => thenCB(store),
   afterEach: async (store) => store,
   afterAll: async () => {},
   beforeAll: async (input, testResource) => ({} as IPM),

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,66 @@
+# 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
+
+## 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.
+
+## 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/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;

package/src/build.ts

@@ -6,25 +6,15 @@ import path from "path";
 import readline from "readline";
 import esbuild from "esbuild";
 
-import esbuildNodeConfiger from "./esbuildConfigs/node.js";
-import esbuildWebConfiger from "./esbuildConfigs/web.js";
-import esbuildImportConfiger from "./esbuildConfigs/pure.js";
-import webHtmlFrame from "./web.html.js";
-
-import { getRunnables } from "./utils.js";
-import {
-  ITestconfig,
-  IBuiltConfig,
-  IProject,
-  IRunTime,
-  ITestTypes,
-} from "./Types.js";
-
-import {
-  // TestPageHtml,
-  // ProjectPageHtml,
-  AppHtml,
-} from "./utils/buildTemplates.js";
+import { ITestconfig, IRunTime, ITestTypes, IBuiltConfig } from "./lib";
+import { IProject } from "./Types";
+import { getRunnables } from "./utils";
+import { AppHtml } from "./utils/buildTemplates";
+
+import esbuildNodeConfiger from "./esbuildConfigs/node";
+import esbuildWebConfiger from "./esbuildConfigs/web";
+import esbuildImportConfiger from "./esbuildConfigs/pure";
+import webHtmlFrame from "./web.html";
 
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
@@ -69,23 +59,23 @@ 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 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,
@@ -149,10 +139,8 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     }
   };
 
-  // Write HTML files
   fs.writeFileSync(`${process.cwd()}/testeranto/projects.html`, AppHtml());
 
-  // Create project-specific HTML files
   Object.keys(bigConfig.projects).forEach((projectName) => {
     console.log(`testeranto/reports/${projectName}`);
     if (!fs.existsSync(`testeranto/reports/${projectName}`)) {
@@ -163,19 +151,6 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
       `testeranto/reports/${projectName}/config.json`,
       JSON.stringify(config, null, 2)
     );
-
-    // fs.writeFileSync(
-    //   `${process.cwd()}/testeranto/reports/${projectName}/index.html`,
-    //   ProjectPageHtml(projectName)
-    // );
-
-    // Create runtime-specific HTML files
-    // ["node", "web", "pure"].forEach((runtime) => {
-    //   // fs.writeFileSync(
-    //   //   `${process.cwd()}/testeranto/reports/${projectName}/${runtime}.html`,
-    //   //   TestPageHtml(`${projectName} - ${runtime}`)
-    //   // );
-    // });
   });
 
   Promise.resolve(
@@ -195,13 +170,14 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
           )}/${sourceFileNameMinusJs}.html`
         );
         const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
+        const cssFilePath = `./${sourceFileNameMinusJs}.css`;
 
         return fs.promises
           .mkdir(path.dirname(htmlFilePath), { recursive: true })
           .then((x) =>
             fs.writeFileSync(
               htmlFilePath,
-              webHtmlFrame(jsfilePath, htmlFilePath)
+              webHtmlFrame(jsfilePath, htmlFilePath, cssFilePath)
             )
           );
       })
@@ -230,8 +206,6 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
         .join(".")}/${runtime}`;
 
       await fs.mkdirSync(folder, { recursive: true });
-
-      // fs.writeFileSync(`${folder}/index.html`, TestPageHtml(testName));
     });
   });
 

package/src/components/{pure/ProjectPageView.test/index.ts → SunriseAnimation.test/index.tsx}

@@ -1,8 +1,11 @@
 import Testeranto from "testeranto-react/src/react-dom/component/web";
-
 import { implementation } from "./implementation";
 import { specification } from "./specification";
-import { I, O } from "./types";
-import { ProjectPageView } from "../ProjectPageView";
+import { SunriseAnimation } from "./SunriseAnimation";
+import React from "react";
 
-export default Testeranto<I, O>(implementation, specification, ProjectPageView);
+export default Testeranto(
+  implementation,
+  specification,
+  SunriseAnimation
+);

package/src/components/SunriseAnimation.test/interface.ts

@@ -0,0 +1,49 @@
+import { IInput, ISelection, ISubject } from './types';
+import { ITestInterface } from "../../CoreTypes";
+import * as React from 'react';
+import * as ReactDom from 'react-dom/client';
+import { SunriseAnimation } from './SunriseAnimation';
+
+export const interface: ITestInterface<{
+  iinput: IInput;
+  isubject: ISubject;
+  istore: ISelection;
+  iselection: ISelection;
+  given: (props: IInput) => ISelection;
+  when: (sel: ISelection) => ISelection;
+  then: (sel: ISelection) => Promise<ISelection>;
+}> = {
+  beforeEach: async (subject, initializer) => {
+    const container = document.createElement('div');
+    document.body.appendChild(container);
+    const root = ReactDom.createRoot(container);
+    const props = initializer();
+    const reactElement = React.createElement(subject, props);
+    root.render(reactElement);
+    
+    return {
+      container,
+      reactElement,
+      domRoot: root,
+      animationElement: container.querySelector('.sunrise-animation')
+    };
+  },
+
+  afterEach: async (store) => {
+    store.domRoot.unmount();
+    document.body.removeChild(store.container);
+    return store;
+  },
+
+  andWhen: async (store, whenCB) => {
+    return whenCB(store);
+  },
+
+  butThen: async (store, thenCB) => {
+    return thenCB(store);
+  },
+
+  afterAll: () => {},
+  beforeAll: () => ({}),
+  assertThis: (x) => x,
+};

package/src/components/SunriseAnimation.test/types.ts

@@ -0,0 +1,53 @@
+import { Ibdd_in, Ibdd_out } from "../../CoreTypes";
+import * as React from 'react';
+import * as ReactDom from 'react-dom/client';
+
+export type IInput = {
+  active: boolean;
+  duration?: number;
+  color?: string;
+};
+
+export type ISelection = {
+  container: HTMLDivElement;
+  reactElement: React.ReactElement;
+  domRoot: ReactDom.Root;
+  animationElement: HTMLElement | null;
+};
+
+export type IStore = ISelection;
+
+export type ISubject = {
+  container: HTMLDivElement;
+  domRoot: ReactDom.Root;
+};
+
+export type O = Ibdd_out<
+  // Suites
+  {
+    Default: [string];
+    AnimationBehavior: [string];
+    Customization: [string];
+  },
+  // Givens
+  {
+    Default: [];
+    Active: [];
+    Inactive: [];
+    WithCustomDuration: [number];
+    WithCustomColor: [string];
+  },
+  // Whens
+  {
+    ToggleActive: [];
+  },
+  // Thens
+  {
+    RendersContainer: [];
+    ShowsWhenActive: [];
+    HidesWhenInactive: [];
+    HasAnimation: [];
+    HasDuration: [number];
+    HasColor: [string];
+  }
+>;

package/src/components/TestStatusBadge.tsx

@@ -1,3 +1,4 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import React from 'react';
 import { Badge } from 'react-bootstrap';
 
@@ -16,50 +17,28 @@ type TestStatusBadgeProps = {
 };
 
 export const TestStatusBadge = (props: TestStatusBadgeProps) => {
-  // Enhanced logging
-  console.groupCollapsed(`[TestStatusBadge] Rendering for ${props.testName}`);
-  console.log('Raw props:', JSON.parse(JSON.stringify(props)));
-
   // Simplified status determination
   const hasTests = props.testsExist !== false;
   const testCompleted = props.runTimeErrors !== -1;
   const hasRuntimeErrors = props.runTimeErrors > 0;
 
-  console.log('Status flags:', {
-    hasTests,
-    testCompleted,
-    hasRuntimeErrors,
-    typeErrors: props.typeErrors,
-    staticErrors: props.staticErrors
-  });
-
   let bddStatus;
   if (!hasTests) {
-    console.warn('No tests.json found - marking as failed');
     bddStatus = { text: '❌ No Tests', variant: 'danger' };
   } else if (!testCompleted) {
-    console.warn('Test did not complete (runTimeErrors=-1) - marking as failed');
     bddStatus = { text: '❌ No Tests', variant: 'danger' };
   } else if (hasRuntimeErrors) {
-    console.warn(`Test failed with ${props.runTimeErrors} runtime errors`);
     bddStatus = { text: `❌ BDD (${props.runTimeErrors})`, variant: 'danger' };
   } else {
-    console.log('Test passed all runtime checks');
     bddStatus = { text: '✅ BDD', variant: 'success' };
   }
 
   if (props.variant === 'compact') {
-    console.log('Rendering compact badge:', bddStatus);
+
     console.groupEnd();
     return <Badge bg={bddStatus.variant}>{bddStatus.text}</Badge>;
   }
 
-  console.log('Rendering full badge set with:', {
-    bddStatus,
-    typeErrors: props.typeErrors,
-    staticErrors: props.staticErrors
-  });
-  console.groupEnd();
 
   return (
     <div className="d-flex gap-2">

package/src/components/pure/AppFrame.test/implementation.tsx

@@ -0,0 +1,72 @@
+import { assert } from "chai";
+import React from "react";
+
+import { ITestImplementation } from "../../../CoreTypes";
+
+import { I, ISelection, O } from "./types";
+
+export const implementation: ITestImplementation<I, O> = {
+  suites: {
+    Default: "AppFrame basic rendering",
+    Layout: "AppFrame layout structure",
+  },
+
+  givens: {
+    Default: () => (selection: ISelection) => ({
+      ...selection,
+      children: <div>Test Content</div>,
+    }),
+    WithChildren: (children: React.ReactNode) => () => (selection: ISelection) => ({
+      ...selection,
+      children,
+    }),
+  },
+
+  whens: {},
+
+  thens: {
+    takeScreenshot:
+      (name: string) =>
+        async ({ htmlElement, container }, pm) => {
+          if (!container) throw new Error('Container not found');
+          const p = await pm.page();
+          await pm.customScreenShot({ path: `${name}.png` }, p);
+          return {
+            htmlElement,
+            reactElement: React.createElement('div'),
+            domRoot: container,
+            container
+          };
+        },
+    RendersContainer: () => async ({ htmlElement, container }) => {
+      // const container = htmlElement.querySelector('.min-vh-100');
+      assert.exists(container, 'Should have min-vh-100 container');
+      return {
+        htmlElement,
+        reactElement: React.createElement('div'),
+        domRoot: container as HTMLElement,
+        container: container as HTMLElement
+      };
+    },
+    HasMainContent: () => async ({ htmlElement }) => {
+      const main = htmlElement.querySelector('main.flex-grow-1');
+      assert.exists(main, 'Should have main content area');
+      return { htmlElement };
+    },
+    HasFooter: () => async ({ htmlElement }) => {
+      const footer = htmlElement.querySelector('footer');
+      assert.exists(footer, 'Should have footer');
+      return { htmlElement };
+    },
+    HasSettingsButton: () => async ({ htmlElement }) => {
+      const button = htmlElement.querySelector('footer button');
+      assert.exists(button, 'Should have settings button in footer');
+      return { htmlElement };
+    },
+    HasTesterantoLink: () => async ({ htmlElement }) => {
+      const link = htmlElement.querySelector('footer a[href*="testeranto"]');
+      assert.exists(link, 'Should have testeranto link in footer');
+      return { htmlElement };
+    },
+  },
+};

package/src/components/pure/AppFrame.test/index.tsx

@@ -0,0 +1,22 @@
+import React from "react";
+
+import Testeranto from "testeranto-react/src/react-dom/component/web";
+
+import { implementation } from "./implementation";
+import { specification } from "./specification";
+import { AppFrame } from "../AppFrame";
+
+
+import "../../../App.scss";
+
+const WrappedAppFrame: React.FC<{ children?: React.ReactNode }> = ({ children }) => (
+  <div id="test-root">
+    <AppFrame data-testid="app-frame">{children}</AppFrame>
+  </div>
+);
+
+export default Testeranto(
+  implementation,
+  specification,
+  WrappedAppFrame
+);