testeranto 0.172.0 → 0.177.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testeranto",
   "description": "the AI powered BDD test framework for typescript projects",
-  "version": "0.172.0",
+  "version": "0.177.0",
   "engines": {
     "node": "18.18.0"
   },
@@ -155,7 +155,7 @@
     "@swc/core": "^1.3.26",
     "@types/express": "^5.0.0",
     "@types/express-session": "^1.18.1",
-    "@types/node": "^22.7.5",
+    "@types/node": "^24.1.0",
     "@types/react": "18.2.0",
     "@types/react-dom": "18.2.0",
     "@types/react-test-renderer": "19.0.0",
@@ -165,7 +165,7 @@
     "@typescript-eslint/parser": "^5.46.0",
     "marked": "^12.0.2",
     "self-import": "*",
-    "testeranto-react": "0.0.5",
+    "testeranto-react": "0.0.8",
     "ts-node": "^10.9.1",
     "typescript": "^5.8.2"
   },

package/src/PM/base.ts

@@ -162,11 +162,13 @@ export abstract class PM_Base {
     return false;
   }
 
-  async writeFileSync(
-    filepath: string,
-    contents: string,
-    testName: string
-  ): Promise<boolean> {
+  async writeFileSync(...x): Promise<boolean> {
+    const filepath = x[0];
+    const contents = x[1];
+    const testName = x[2];
+
+    console.log("writing file", filepath);
+
     return new Promise<boolean>(async (res) => {
       fs.mkdirSync(path.dirname(filepath), {
         recursive: true,

package/src/PM/main.ts

@@ -3,7 +3,7 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import { ChildProcess, spawn } from "node:child_process";
-
+import ansiColors from "ansi-colors";
 import net from "net";
 import { Page } from "puppeteer-core/lib/esm/puppeteer";
 import fs, { watch } from "fs";
@@ -21,8 +21,8 @@ import { getRunnables } from "../utils";
 import { IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
 import { Sidecar } from "../lib/Sidecar.js";
 import { Queue } from "../utils/queue.js";
+
 import { PM_WithEslintAndTsc } from "./PM_WithEslintAndTsc.js";
-import ansiColors from "ansi-colors";
 
 type IOutputs = Record<
   string,
@@ -242,9 +242,9 @@ export class PM_Main extends PM_WithEslintAndTsc {
         slowMo: 1,
         waitForInitialPage: false,
         executablePath,
-        headless: false,
+        headless: true,
         dumpio: false,
-        devtools: true,
+        devtools: false,
 
         args: [
           "--disable-features=site-per-process",
@@ -717,7 +717,12 @@ export class PM_Main extends PM_WithEslintAndTsc {
     const child = spawn(
       "node",
       // "node",
-      ["--inspect-brk", builtfile, testResources, ipcfile],
+      [
+        // "--inspect-brk",
+        builtfile,
+        testResources,
+        ipcfile,
+      ],
       {
         stdio: ["pipe", "pipe", "pipe", "ipc"],
       }
@@ -1245,17 +1250,6 @@ export class PM_Main extends PM_WithEslintAndTsc {
 
     const d = `${dest}?cacheBust=${Date.now()}`;
 
-    const evaluation = `
-
-    import('${d}').then(async (x) => {
-
-      try {
-        return await (await x.default).receiveTestResourceConfig(${webArgz})
-      } catch (e) {
-        console.log("web run failure", e.toString())
-      }
-    })`;
-
     const ofile = `${reportDest}/logs.txt`;
     const oStream = fs.createWriteStream(ofile);
 
@@ -1296,7 +1290,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
             page.close();
             oStream.close();
           });
-          console.log("ostream is closed");
+
           return;
         };
 
@@ -1330,7 +1324,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
         });
 
         page.on("console", (log: ConsoleMessage) => {
-          console.log("console message: ", log.text());
+          // console.log("console message: ", log.text());
           if (oStream.closed) {
             console.log("missed console message: ", log.text());
             return;
@@ -1347,14 +1341,24 @@ export class PM_Main extends PM_WithEslintAndTsc {
         await page.goto(`file://${`${destFolder}.html`}`, {});
 
         await page
-          .evaluate(evaluation)
+          .evaluate(
+            `
+import('${d}').then(async (x) => {
+  try {
+    return await (await x.default).receiveTestResourceConfig(${webArgz})
+  } catch (e) {
+    console.log("web run failure", e.toString())
+  }
+})
+`
+          )
           .then(async ({ fails, failed, features }: IFinalResults) => {
             statusMessagePretty(fails, src, "web");
             this.bddTestIsNowDone(src, fails);
-            close();
+            // close();
           })
           .catch((e) => {
-            console.log(ansiC.red(ansiC.inverse(e)));
+            console.log(ansiC.red(ansiC.inverse(e.stack)));
 
             console.log(
               ansiC.red(
@@ -1367,6 +1371,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
           })
           .finally(() => {
             // process.exit(-1);
+            close();
           });
 
         return page;

package/src/PM/node.ts

@@ -182,7 +182,12 @@ export class PM_Node extends PM {
     return await this.send("write", ...arguments);
   }
 
-  async writeFileSync(filepath: string, contents: string) {
+  async writeFileSync(x) {
+    const z = arguments["0"];
+
+    const filepath = z[0];
+    const contents = z[1];
+
     return await this.send<boolean>(
       "writeFileSync",
       this.testResourceConfiguration.fs + "/" + filepath,

package/src/PM/pure.ts

@@ -136,7 +136,12 @@ export class PM_Pure extends PM {
     return globalThis["write"](uid, contents);
   }
 
-  writeFileSync(filepath: string, contents: string) {
+  writeFileSync(x) {
+    const z = arguments["0"];
+
+    const filepath = z[0];
+    const contents = z[1];
+
     return globalThis["writeFileSync"](
       this.testResourceConfiguration.fs + "/" + filepath,
       contents,

package/src/PM/web.ts

@@ -111,8 +111,8 @@ export class PM_Web extends PM {
   customScreenShot(x: ScreenshotOptions, y: any) {
     const opts = x[0];
     const page = x[1];
-    console.log("customScreenShot 2 opts", opts);
-    console.log("customScreenShot 2 page", page);
+    // console.log("customScreenShot 2 opts", opts);
+    // console.log("customScreenShot 2 page", page);
     return window["customScreenShot"](
       {
         ...opts,
@@ -135,7 +135,11 @@ export class PM_Web extends PM {
     return window["write"](uid, contents);
   }
 
-  writeFileSync(filepath: string, contents: string) {
+  writeFileSync(x) {
+    const z = arguments["0"];
+
+    const filepath = z[0];
+    const contents = z[1];
     return window["writeFileSync"](
       this.testResourceConfiguration.fs + "/" + filepath,
       contents,

package/src/Pure.test.ts

@@ -105,8 +105,8 @@ const implementation: ITestImplementation<I, O> = {
             ...store,
             pm: {
               ...store.pm,
-              testResourceConfiguration: { name: "test-resource" }
-            }
+              testResourceConfiguration: { name: "test-resource" },
+            },
           };
         default:
           return store;
@@ -116,23 +116,23 @@ const implementation: ITestImplementation<I, O> = {
       console.debug("[DEBUG] Adding artifact");
       return {
         ...store,
-        artifacts: [...(store.artifacts || []), artifact]
+        artifacts: [...(store.artifacts || []), artifact],
       };
     },
     setTestJobs: (jobs: any[]) => (store) => {
       console.debug("[DEBUG] Setting test jobs");
       return {
         ...store,
-        testJobs: jobs
+        testJobs: jobs,
       };
     },
     modifySpecs: (modifier: (specs: any) => any[]) => (store) => {
       console.debug("[DEBUG] Modifying specs");
       return {
         ...store,
-        specs: modifier(store.specs || [])
+        specs: modifier(store.specs || []),
       };
-    }
+    },
   },
 
   thens: {

package/src/Pure.ts

@@ -39,15 +39,9 @@ export class PureTesteranto<
   }
 
   async receiveTestResourceConfig(partialTestResource: string) {
-    console.log(
-      "[DEBUG] receiveTestResourceConfig called with:",
-      partialTestResource
-    );
     const t: ITTestResourceConfiguration = JSON.parse(partialTestResource);
     const pm = new PM_Pure(t);
 
-    // console.log("[DEBUG] Current test jobs:", this.testJobs?.length);
-
     // if (!this.testJobs || this.testJobs.length === 0) {
     //   console.error(
     //     "[ERROR] No test jobs available - checking specs:",
@@ -64,9 +58,7 @@ export class PureTesteranto<
     // }
 
     try {
-      console.log("[DEBUG] Executing test job with PM:", pm);
       const result = await this.testJobs[0].receiveTestResourceConfig(pm);
-      console.log("[DEBUG] Test job completed with result:", result);
       return result;
     } catch (e) {
       console.error("[ERROR] Test job failed:", e);

package/src/ReportServer.test.ts/index.ts

@@ -0,0 +1,194 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+
+import { IncomingMessage, Server, ServerResponse } from "http";
+
+import {
+  Ibdd_in,
+  Ibdd_out,
+  ITestAdapter,
+  ITestImplementation,
+  ITestSpecification,
+} from "../CoreTypes";
+import testeranto from "../Node";
+import { ReportServerOfPort } from "../ReportServerLib";
+import { PM } from "../PM";
+import { ITTestResourceConfiguration } from "../lib";
+import { IPM } from "../lib/types";
+import { PM_Node } from "../PM/node";
+import { util } from "chai";
+
+type O = Ibdd_out<
+  { Default: [] },
+  {
+    "the http server which is used in development": [];
+  },
+  // There are no "whens", it is a stateless server.
+  {},
+  {
+    "the frontpage looks good": [];
+    "the projects page looks good": [];
+    "a project page looks good": [];
+    "a test page looks good": [];
+  }
+>;
+
+const specification: ITestSpecification<I, O> = (Suite, Given, When, Then) => [
+  Suite.Default("the http server which is used in development", {
+    initialization: Given["the http server which is used in development"](
+      ["It should serve the front page", "It should serve the ReportApp"],
+      [],
+      [
+        Then["the frontpage looks good"](),
+        // Then["the projects page looks good"](),
+        // Then["a project page looks good"](),
+        // Then["a test page looks good"](),
+      ]
+    ),
+  }),
+];
+
+const implementation: ITestImplementation<I, O, M> = {
+  suites: {
+    Default: "the http server which is used in  development",
+  },
+
+  givens: {
+    "the http server which is used in development": function (
+      subject
+    ): Server<typeof IncomingMessage, typeof ServerResponse> {
+      // throw new Error("Function not implemented.");
+      return subject;
+    },
+  },
+
+  // There are no "whens", it is a stateless server.
+  whens: {},
+
+  thens: {
+    "the frontpage looks good": async (port, utils) => {
+      // throw new Error("Function not implemented.");
+
+      // utils.newPage(`localhost:${port}`);
+      debugger;
+      const page = await utils.newPage();
+      utils.goto(page, `localhost:${port}`);
+      utils.customScreenShot({ path: `frontpage.png` }, page);
+
+      return;
+    },
+
+    "the projects page looks good": function (): (
+      port,
+      utils: PM
+    ) => Server<typeof IncomingMessage, typeof ServerResponse> {
+      throw new Error("Function not implemented.");
+    },
+    "a project page looks good": function (): (
+      port,
+      utils: PM
+    ) => Server<typeof IncomingMessage, typeof ServerResponse> {
+      throw new Error("Function not implemented.");
+    },
+    "a test page looks good": function (): (
+      port,
+      utils: PM
+    ) => Server<typeof IncomingMessage, typeof ServerResponse> {
+      throw new Error("Function not implemented.");
+    },
+  },
+};
+
+const adapter: ITestAdapter<I> = {
+  assertThis: function (
+    x: Server<typeof IncomingMessage, typeof ServerResponse>
+  ) {
+    throw new Error("Function not implemented.");
+  },
+  andWhen: function (
+    store: Server<typeof IncomingMessage, typeof ServerResponse>,
+    whenCB: Server<typeof IncomingMessage, typeof ServerResponse>,
+    testResource: ITTestResourceConfiguration,
+    pm: IPM
+  ): Promise<Server<typeof IncomingMessage, typeof ServerResponse>> {
+    throw new Error("Function not implemented.");
+  },
+  butThen: function (
+    store: Server<typeof IncomingMessage, typeof ServerResponse>,
+    thenCB: Server<typeof IncomingMessage, typeof ServerResponse>,
+    testResource: ITTestResourceConfiguration,
+    pm: IPM
+  ): Promise<Server<typeof IncomingMessage, typeof ServerResponse>> {
+    throw new Error("Function not implemented.");
+  },
+  afterAll: function (
+    store: Server<typeof IncomingMessage, typeof ServerResponse>,
+    pm: IPM
+  ) {
+    throw new Error("Function not implemented.");
+  },
+  afterEach: function (
+    store: Server<typeof IncomingMessage, typeof ServerResponse>,
+    key: string,
+    pm: IPM
+  ): Promise<unknown> {
+    throw new Error("Function not implemented.");
+  },
+  beforeAll: async function (
+    input: (
+      port: number
+    ) => Server<typeof IncomingMessage, typeof ServerResponse>,
+    testResource: ITTestResourceConfiguration,
+    pm: IPM
+  ): Promise<number> {
+    await new Promise((res, rej) => input(testResource.ports[0]));
+    return testResource.ports[0];
+  },
+  beforeEach: function (
+    subject: number,
+    initializer: (
+      c?: any
+    ) => Server<typeof IncomingMessage, typeof ServerResponse>,
+    testResource: ITTestResourceConfiguration,
+    initialValues: any,
+    pm: IPM
+  ): Promise<Server<typeof IncomingMessage, typeof ServerResponse>> {
+    throw new Error("Function not implemented.");
+  },
+};
+
+type I = Ibdd_in<
+  (port: number) => Server<typeof IncomingMessage, typeof ServerResponse>,
+  number,
+  Server<typeof IncomingMessage, typeof ServerResponse>,
+  // Server<typeof IncomingMessage, typeof ServerResponse>,
+  number,
+  Server<typeof IncomingMessage, typeof ServerResponse>,
+  Server<typeof IncomingMessage, typeof ServerResponse>,
+  Server<typeof IncomingMessage, typeof ServerResponse>
+>;
+
+type M = {
+  givens: {
+    [K in keyof O["givens"]]: (...args: any[]) => IProjectPageViewProps;
+  };
+  whens: {
+    [K in keyof O["whens"]]: (
+      ...args: any[]
+    ) => (
+      props: IProjectPageViewProps,
+      utils: any
+    ) => IProjectPageViewProps & { container?: HTMLElement };
+  };
+  thens: {
+    [K in keyof O["thens"]]: (port: number, pm: PM_Node) => void;
+  };
+};
+
+export default testeranto<I, O, M>(
+  ReportServerOfPort,
+  specification,
+  implementation,
+  adapter
+);

package/src/ReportServer.ts

@@ -1,135 +1,5 @@
 // simple http server to preview reports
 
-import staticServer from "node-static";
-import http from "http";
-import path from "path";
-import fs from "fs";
+import { ReportServerOfPort } from "./ReportServerLib";
 
-const fileServer = new staticServer.Server("./", { 
-  cache: false,
-  headers: {
-    "Cache-Control": "no-cache, no-store, must-revalidate",
-    "Pragma": "no-cache",
-    "Expires": "0"
-  }
-});
-
-const server = http.createServer((req, res) => {
-  // Handle potential double responses
-  let responded = false;
-  
-  const safeResponse = (handler: () => void) => {
-    if (responded) return;
-    responded = true;
-    try {
-      handler();
-    } catch (err) {
-      console.error('Error handling request:', err);
-      if (!res.headersSent) {
-        res.writeHead(500);
-      }
-      res.end('Internal Server Error');
-    }
-  };
-
-  req.on('error', (err) => {
-    console.error('Request error:', err);
-    safeResponse(() => {
-      if (!res.headersSent) {
-        res.writeHead(400);
-      }
-      res.end('Bad Request');
-    });
-  });
-
-  req.on('end', () => {
-    safeResponse(() => {
-      const filePath = path.join(process.cwd(), req.url || '');
-          
-      // First check if file exists
-      fs.stat(filePath, (err, stats) => {
-        if (err || !stats.isFile()) {
-          // Check if directory exists
-          fs.stat(filePath, (dirErr, dirStats) => {
-            if (!dirErr && dirStats.isDirectory()) {
-              // Serve directory listing
-              fs.readdir(filePath, (readErr, files) => {
-                if (readErr) {
-                  res.writeHead(500);
-                  return res.end('Error reading directory');
-                }
-                    
-                res.writeHead(200, { 'Content-Type': 'text/html' });
-                res.write(`
-                  <html>
-                    <head>
-                      <title>Directory Listing: ${req.url}</title>
-                      <style>
-                        body { font-family: sans-serif; margin: 2rem; }
-                        h1 { color: #333; }
-                        ul { list-style: none; padding: 0; }
-                        li { padding: 0.5rem; }
-                        li a { color: #0366d6; text-decoration: none; }
-                        li a:hover { text-decoration: underline; }
-                      </style>
-                    </head>
-                    <body>
-                      <h1>Directory: ${req.url}</h1>
-                      <ul>
-                        ${files.map(file => `
-                          <li>
-                            <a href="${path.join(req.url || '', file)}">
-                              ${file}${file.endsWith('/') ? '/' : ''}
-                            </a>
-                          </li>
-                        `).join('')}
-                      </ul>
-                    </body>
-                  </html>
-                `);
-                res.end();
-              });
-            } else {
-              // Neither file nor directory exists - send 404
-              if (!res.headersSent) {
-                res.writeHead(404, { 'Content-Type': 'text/plain' });
-                res.end('File not found');
-              }
-            }
-          });
-          return;
-        }
-
-        // File exists - serve it through node-static
-        const serve = () => {
-          fileServer.serve(req, res, (err) => {
-            if (err && !res.headersSent) {
-              res.writeHead(err.status || 500);
-              res.end(err.message);
-            }
-          });
-        };
-
-        // Ensure we don't double-serve
-        if (!res.headersSent) {
-          serve();
-        }
-      });
-    });
-  });
-
-  req.resume();
-});
-
-server.listen(8080, () => {
-  console.log('Server running on http://localhost:8080');
-  console.log('Serving files from:', process.cwd());
-});
-
-server.on('error', (err) => {
-  console.error('Server error:', err);
-});
-
-process.on('uncaughtException', (err) => {
-  console.error('Uncaught exception:', err);
-});
+ReportServerOfPort(process.argv[2]);