testeranto 0.171.0 → 0.173.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testeranto",
   "description": "the AI powered BDD test framework for typescript projects",
-  "version": "0.171.0",
+  "version": "0.173.0",
   "engines": {
     "node": "18.18.0"
   },
@@ -133,7 +133,8 @@
     "t-init": "tsx dist/prebuild/init-docs.mjs",
     "t-report": "tsx dist/prebuild/ReportServer.mjs",
     "build-docs": "node scripts/compile-docs.js",
-    "do_it": "clear && rm -rf testeranto/** && yarn build && yarn t-init && yarn t-build allTests once && yarn t-run allTests once && yarn build-docs && yarn type-check"
+    "do_it": "clear && rm -rf testeranto/** && yarn build && yarn t-init && yarn t-build allTests once && yarn t-run allTests once && yarn build-docs && yarn type-check",
+    "prepublish": "self-import"
   },
   "peerDependencies": {
     "@types/react": "18.2.0",
@@ -154,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",
@@ -163,6 +164,8 @@
     "@typescript-eslint/eslint-plugin": "^5.46.0",
     "@typescript-eslint/parser": "^5.46.0",
     "marked": "^12.0.2",
+    "self-import": "*",
+    "testeranto-react": "0.0.5",
     "ts-node": "^10.9.1",
     "typescript": "^5.8.2"
   },
@@ -204,8 +207,6 @@
     "react-dom": "18.2.0",
     "react-router-dom": "^7.7.0",
     "sass": "^1.89.2",
-    "testeranto": "latest",
-    "testeranto-react": "^0.0.2",
     "tsc-prog": "^2.3.0",
     "tsx": "^4.19.3",
     "type-fest": "^4.41.0",

package/src/PM/base.ts

@@ -167,6 +167,11 @@ export abstract class PM_Base {
     contents: string,
     testName: string
   ): Promise<boolean> {
+    console.log("writeFileSync");
+    console.log("filepath", filepath);
+    console.log("contents", contents);
+    console.log("testName", testName);
+
     return new Promise<boolean>(async (res) => {
       fs.mkdirSync(path.dirname(filepath), {
         recursive: true,

package/src/PM/main.ts

@@ -105,10 +105,13 @@ function isValidUrl(string) {
 
 // Wait for file to exist, checks every 2 seconds by default
 async function pollForFile(path, timeout = 2000) {
+  console.log(`pollForFile: ${path}...`);
+
   const intervalObj = setInterval(function () {
     const file = path;
     const fileExists = fs.existsSync(file);
     if (fileExists) {
+      console.log(`metafile found: ${path}!`);
       clearInterval(intervalObj);
     }
   }, timeout);
@@ -242,9 +245,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 +720,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"],
       }
@@ -1330,7 +1338,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;

package/src/PM/node.ts

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

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,7 @@ export class PM_Web extends PM {
     return window["write"](uid, contents);
   }
 
-  writeFileSync(filepath: string, contents: string) {
+  writeFileSync([filepath, contents]: [string, string]) {
     return window["writeFileSync"](
       this.testResourceConfiguration.fs + "/" + filepath,
       contents,

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]);

package/src/ReportServerLib.ts

@@ -0,0 +1,144 @@
+// simple http server to preview reports
+
+import staticServer from "node-static";
+import http from "http";
+import path from "path";
+import fs from "fs";
+
+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.on("error", (err) => {
+  console.error("Server error:", err);
+});
+
+process.on("uncaughtException", (err) => {
+  console.error("Uncaught exception:", err);
+});
+
+const start = (port: number) =>
+  server.listen(port, () => {
+    console.log(`Server running on http://localhost:${port}`);
+    console.log("Serving files from:", process.cwd());
+  });
+
+export const ReportServerOfPort = (port: number) => start(port);
+
+// export default () => start(process.argv[2]);