testeranto 0.200.0 → 0.202.0

package/src/PM/metafileOutputs.ts

@@ -0,0 +1,90 @@
+// import { IRunTime } from "../Types";
+// import { IOutputs, filesHash } from "./utils";
+
+// import ansiC from "ansi-colors";
+// import fs from "fs";
+
+// export const metafileOutputs = async (platform: IRunTime) => {
+//   let metafilePath: string;
+//   if (platform === "python") {
+//     metafilePath = `./testeranto/metafiles/python/core.json`;
+//   } else {
+//     metafilePath = `./testeranto/metafiles/${platform}/${this.name}.json`;
+//   }
+
+//   // Check if the file exists
+//   if (!fs.existsSync(metafilePath)) {
+//     if (platform === "python") {
+//       console.log(
+//         ansiC.yellow(
+//           ansiC.inverse(`Pitono metafile not found yet: ${metafilePath}`)
+//         )
+//       );
+//     }
+//     return;
+//   }
+
+//   let metafile;
+//   try {
+//     const fileContent = fs.readFileSync(metafilePath).toString();
+//     const parsedData = JSON.parse(fileContent);
+//     // Handle different metafile structures
+//     if (platform === "python") {
+//       // Pitono metafile might be the entire content or have a different structure
+//       metafile = parsedData.metafile || parsedData;
+//     } else {
+//       metafile = parsedData.metafile;
+//     }
+//     if (!metafile) {
+//       console.log(
+//         ansiC.yellow(ansiC.inverse(`No metafile found in ${metafilePath}`))
+//       );
+//       return;
+//     }
+//   } catch (error) {
+//     console.error(`Error reading metafile at ${metafilePath}:`, error);
+//     return;
+//   }
+
+//   const outputs: IOutputs = metafile.outputs;
+
+//   Object.keys(outputs).forEach(async (k) => {
+//     const pattern = `testeranto/bundles/${platform}/${this.name}/${this.configs.src}`;
+//     if (!k.startsWith(pattern)) {
+//       return false;
+//     }
+
+//     const addableFiles = Object.keys(outputs[k].inputs).filter((i) => {
+//       if (!fs.existsSync(i)) return false;
+//       if (i.startsWith("node_modules")) return false;
+//       if (i.startsWith("./node_modules")) return false;
+
+//       return true;
+//     });
+
+//     const f = `${k.split(".").slice(0, -1).join(".")}/`;
+
+//     if (!fs.existsSync(f)) {
+//       fs.mkdirSync(f);
+//     }
+
+//     const entrypoint = outputs[k].entryPoint;
+
+//     if (entrypoint) {
+//       const changeDigest = await filesHash(addableFiles);
+
+//       if (changeDigest === changes[entrypoint]) {
+//         // skip
+//       } else {
+//         changes[entrypoint] = changeDigest;
+//         this.tscCheck({
+//           platform,
+//           addableFiles,
+//           entrypoint: entrypoint,
+//         });
+//         this.eslintCheck(entrypoint, platform, addableFiles);
+//         this.makePrompt(entrypoint, addableFiles, platform);
+//       }
+//     }
+//   });
+// };

package/src/PM/node.ts

@@ -59,24 +59,6 @@ export class PM_Node extends PM {
     });
   }
 
-  async launchSideCar(
-    n: number
-  ): Promise<[number, ITTestResourceConfiguration]> {
-    return this.send<[number, ITTestResourceConfiguration]>(
-      "launchSideCar",
-      n,
-      this.testResourceConfiguration.name
-    );
-  }
-
-  stopSideCar(n: number): Promise<any> {
-    return this.send<ITTestResourceConfiguration>(
-      "stopSideCar",
-      n,
-      this.testResourceConfiguration.name
-    );
-  }
-
   async pages() {
     return this.send<string[]>("pages", ...arguments);
   }
@@ -275,4 +257,22 @@ export class PM_Node extends PM {
     //   this.browser = b;
     // });
   }
+
+  // async launchSideCar(
+  //   n: number
+  // ): Promise<[number, ITTestResourceConfiguration]> {
+  //   return this.send<[number, ITTestResourceConfiguration]>(
+  //     "launchSideCar",
+  //     n,
+  //     this.testResourceConfiguration.name
+  //   );
+  // }
+
+  // stopSideCar(n: number): Promise<any> {
+  //   return this.send<ITTestResourceConfiguration>(
+  //     "stopSideCar",
+  //     n,
+  //     this.testResourceConfiguration.name
+  //   );
+  // }
 }

package/src/PM/pure.ts

@@ -18,9 +18,6 @@ export class PM_Pure extends PM {
     throw new Error("pure.ts getInnerHtml not implemented");
   }
 
-  stopSideCar(uid: number): Promise<any> {
-    throw new Error("pure.ts stopSideCar not implemented");
-  }
   server: PuppetMasterServer;
   testResourceConfiguration: ITTestResourceConfiguration;
 
@@ -44,11 +41,6 @@ export class PM_Pure extends PM {
 
   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);
   }
 
   pages() {
@@ -145,7 +137,6 @@ export class PM_Pure extends PM {
   writeFileSync() {
     return Promise.resolve(true);
   }
-  /////////////////////////////////////////////////////
 
   end(uid: number) {
     return globalThis["end"](uid);
@@ -168,9 +159,10 @@ export class PM_Pure extends PM {
     };
   }
 
-  // startPuppeteer(options?: any): any {
-  //   // return puppeteer.connect(options).then((b) => {
-  //   //   this.browser = b;
-  //   // });
+  // launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]> {
+  //   return globalThis["launchSideCar"](n, this.testResourceConfiguration.name);
+  // }
+  // stopSideCar(uid: number): Promise<any> {
+  //   throw new Error("pure.ts stopSideCar not implemented");
   // }
 }

package/src/PM/types.ts

@@ -0,0 +1,145 @@
+export type ProcessStatus = "running" | "exited" | "error" | "completed";
+export type ProcessType = "process" | "promise";
+export type ProcessCategory = "aider" | "bdd-test" | "build-time" | "other";
+export type ProcessPlatform = "node" | "web" | "pure" | "pitono" | "golang";
+
+export interface ProcessInfo {
+  child?: any;
+  promise?: Promise<any>;
+  status: ProcessStatus;
+  exitCode?: number;
+  error?: string;
+  command: string;
+  pid?: number;
+  timestamp: string;
+  type: ProcessType;
+  category: ProcessCategory;
+  testName?: string;
+  platform?: ProcessPlatform;
+}
+
+export interface ProcessData {
+  processId: string;
+  command: string;
+  pid?: number;
+  status: ProcessStatus;
+  exitCode?: number;
+  error?: string;
+  timestamp: string;
+  category: ProcessCategory;
+  testName?: string;
+  platform?: ProcessPlatform;
+  logs: string[];
+}
+
+export interface ProcessManager {
+  allProcesses: Map<string, ProcessInfo>;
+  processLogs: Map<string, string[]>;
+  addPromiseProcess: (
+    processId: string,
+    promise: Promise<any>,
+    command: string,
+    category?: ProcessCategory,
+    testName?: string,
+    platform?: ProcessPlatform,
+    onResolve?: (result: any) => void,
+    onReject?: (error: any) => void
+  ) => string;
+  broadcast: (message: any) => void;
+  getProcessesByCategory: (category: ProcessCategory) => any[];
+  getBDDTestProcesses: () => any[];
+  getBuildTimeProcesses: () => any[];
+  getAiderProcesses: () => any[];
+  getProcessesByTestName: (testName: string) => any[];
+  getProcessesByPlatform: (platform: ProcessPlatform) => any[];
+}
+
+// WebSocket message types
+export interface WebSocketMessage {
+  type: string;
+  [key: string]: any;
+}
+
+export interface ExecuteCommandMessage extends WebSocketMessage {
+  type: "executeCommand";
+  command: string;
+}
+
+export interface GetRunningProcessesMessage extends WebSocketMessage {
+  type: "getRunningProcesses";
+}
+
+export interface GetProcessMessage extends WebSocketMessage {
+  type: "getProcess";
+  processId: string;
+}
+
+export interface StdinMessage extends WebSocketMessage {
+  type: "stdin";
+  processId: string;
+  data: string;
+}
+
+export interface KillProcessMessage extends WebSocketMessage {
+  type: "killProcess";
+  processId: string;
+}
+
+// Process event types
+export interface ProcessStartedEvent {
+  type: "processStarted";
+  processId: string;
+  command: string;
+  timestamp: string;
+  logs: string[];
+}
+
+export interface ProcessStdoutEvent {
+  type: "processStdout";
+  processId: string;
+  data: string;
+  timestamp: string;
+}
+
+export interface ProcessStderrEvent {
+  type: "processStderr";
+  processId: string;
+  data: string;
+  timestamp: string;
+}
+
+export interface ProcessExitedEvent {
+  type: "processExited";
+  processId: string;
+  exitCode: number;
+  timestamp: string;
+  logs?: string[];
+}
+
+export interface ProcessErrorEvent {
+  type: "processError";
+  processId: string;
+  error: string;
+  timestamp: string;
+  logs?: string[];
+}
+
+export interface RunningProcessesEvent {
+  type: "runningProcesses";
+  processes: ProcessData[];
+}
+
+export interface ProcessDataEvent {
+  type: "processData";
+  processId: string;
+  command: string;
+  pid?: number;
+  status: ProcessStatus;
+  exitCode?: number;
+  error?: string;
+  timestamp: string;
+  category: ProcessCategory;
+  testName?: string;
+  platform?: ProcessPlatform;
+  logs: string[];
+}

package/src/PM/utils.ts

@@ -0,0 +1,256 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import ansiC from "ansi-colors";
+import path from "path";
+import fs from "fs";
+import crypto from "node:crypto";
+
+import { IRunTime } from "../Types";
+
+export type IOutputs = Record<
+  string,
+  {
+    entryPoint: string;
+    inputs: Record<string, string>;
+  }
+>;
+
+export type LogStreams = {
+  closeAll: () => void;
+  writeExitCode: (code: number, error?: Error) => void;
+  stdout?: fs.WriteStream;
+  stderr?: fs.WriteStream;
+  info?: fs.WriteStream;
+  warn?: fs.WriteStream;
+  error?: fs.WriteStream;
+  debug?: fs.WriteStream;
+  exit: fs.WriteStream;
+};
+
+export function runtimeLogs(
+  runtime: IRunTime,
+  reportDest: string
+): Record<string, fs.WriteStream> {
+  const safeDest = reportDest || `testeranto/reports/default_${Date.now()}`;
+
+  try {
+    if (!fs.existsSync(safeDest)) {
+      fs.mkdirSync(safeDest, { recursive: true });
+    }
+
+    if (runtime === "node") {
+      return {
+        stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
+        stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
+        exit: fs.createWriteStream(`${safeDest}/exit.log`),
+      };
+    } else if (runtime === "web") {
+      return {
+        info: fs.createWriteStream(`${safeDest}/info.log`),
+        warn: fs.createWriteStream(`${safeDest}/warn.log`),
+        error: fs.createWriteStream(`${safeDest}/error.log`),
+        debug: fs.createWriteStream(`${safeDest}/debug.log`),
+        exit: fs.createWriteStream(`${safeDest}/exit.log`),
+      };
+    } else if (runtime === "pure") {
+      return {
+        exit: fs.createWriteStream(`${safeDest}/exit.log`),
+      };
+    } else if (runtime === "pitono") {
+      return {
+        stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
+        stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
+        exit: fs.createWriteStream(`${safeDest}/exit.log`),
+      };
+    } else {
+      throw `unknown runtime: ${runtime}`;
+    }
+  } catch (e) {
+    console.error(`Failed to create log streams in ${safeDest}:`, e);
+    throw e;
+  }
+}
+
+export function createLogStreams(
+  reportDest: string,
+  runtime: IRunTime
+): LogStreams {
+  // Create directory if it doesn't exist
+  if (!fs.existsSync(reportDest)) {
+    fs.mkdirSync(reportDest, { recursive: true });
+  }
+
+  // const streams = {
+  //   exit: fs.createWriteStream(`${reportDest}/exit.log`),
+  const safeDest = reportDest || `testeranto/reports/default_${Date.now()}`;
+
+  try {
+    if (!fs.existsSync(safeDest)) {
+      fs.mkdirSync(safeDest, { recursive: true });
+    }
+
+    const streams = runtimeLogs(runtime, safeDest);
+    // const streams = {
+    //   exit: fs.createWriteStream(`${safeDest}/exit.log`),
+    //   ...(runtime === "node" || runtime === "pure"
+    //     ? {
+    //         stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
+    //         stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
+    //       }
+    //     : {
+    //         info: fs.createWriteStream(`${safeDest}/info.log`),
+    //         warn: fs.createWriteStream(`${safeDest}/warn.log`),
+    //         error: fs.createWriteStream(`${safeDest}/error.log`),
+    //         debug: fs.createWriteStream(`${safeDest}/debug.log`),
+    //       }),
+    // };
+
+    return {
+      ...streams,
+      closeAll: () => {
+        Object.values(streams).forEach(
+          (stream) => !stream.closed && stream.close()
+        );
+      },
+      writeExitCode: (code: number, error?: Error) => {
+        if (error) {
+          streams.exit.write(`Error: ${error.message}\n`);
+          if (error.stack) {
+            streams.exit.write(`Stack Trace:\n${error.stack}\n`);
+          }
+        }
+        streams.exit.write(`${code}\n`);
+      },
+      exit: streams.exit,
+    };
+  } catch (e) {
+    console.error(`Failed to create log streams in ${safeDest}:`, e);
+    throw e;
+  }
+}
+
+export async function fileHash(filePath, algorithm = "md5") {
+  return new Promise<string>((resolve, reject) => {
+    const hash = crypto.createHash(algorithm);
+    const fileStream = fs.createReadStream(filePath);
+
+    fileStream.on("data", (data) => {
+      hash.update(data);
+    });
+
+    fileStream.on("end", () => {
+      const fileHash = hash.digest("hex");
+      resolve(fileHash);
+    });
+
+    fileStream.on("error", (error) => {
+      reject(`Error reading file: ${error.message}`);
+    });
+  });
+}
+
+export const statusMessagePretty = (
+  failures: number,
+  test: string,
+  runtime: IRunTime
+) => {
+  if (failures === 0) {
+    console.log(ansiC.green(ansiC.inverse(`${runtime} > ${test}`)));
+  } else if (failures > 0) {
+    console.log(
+      ansiC.red(
+        ansiC.inverse(
+          `${runtime} > ${test} failed ${failures} times (exit code: ${failures})`
+        )
+      )
+    );
+  } else {
+    console.log(
+      ansiC.red(ansiC.inverse(`${runtime} > ${test} crashed (exit code: -1)`))
+    );
+  }
+};
+
+export async function writeFileAndCreateDir(filePath, data) {
+  const dirPath = path.dirname(filePath);
+
+  try {
+    await fs.promises.mkdir(dirPath, { recursive: true });
+    await fs.writeFileSync(filePath, data);
+  } catch (error) {
+    console.error(`Error writing file: ${error}`);
+  }
+}
+
+export const filesHash = async (files: string[], algorithm = "md5") => {
+  return new Promise<string>((resolve, reject) => {
+    resolve(
+      files.reduce(async (mm: Promise<string>, f) => {
+        return (await mm) + (await fileHash(f));
+      }, Promise.resolve(""))
+    );
+  });
+};
+
+export function isValidUrl(string) {
+  try {
+    new URL(string);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
+// Wait for file to exist, checks every 2 seconds by default
+export async function pollForFile(path, timeout = 2000) {
+  const intervalObj = setInterval(function () {
+    const file = path;
+    const fileExists = fs.existsSync(file);
+    if (fileExists) {
+      clearInterval(intervalObj);
+    }
+  }, timeout);
+}
+
+const executablePath = "/opt/homebrew/bin/chromium";
+
+export const puppeteerConfigs = {
+  slowMo: 1,
+  waitForInitialPage: false,
+  executablePath,
+  headless: true,
+  defaultViewport: null, // Disable default 800x600 viewport
+  dumpio: false,
+  devtools: false,
+
+  args: [
+    "--allow-file-access-from-files",
+    "--allow-insecure-localhost",
+    "--allow-running-insecure-content",
+    "--auto-open-devtools-for-tabs",
+    "--disable-dev-shm-usage",
+    "--disable-extensions",
+    "--disable-features=site-per-process",
+    "--disable-gpu",
+    "--disable-setuid-sandbox",
+    "--disable-site-isolation-trials",
+    "--disable-web-security",
+    "--no-first-run",
+    "--no-sandbox",
+    "--no-startup-window",
+    "--reduce-security-for-testing",
+    "--remote-allow-origins=*",
+    "--start-maximized",
+    "--unsafely-treat-insecure-origin-as-secure=*",
+    `--remote-debugging-port=3234`,
+    // "--disable-features=IsolateOrigins,site-per-process",
+    // "--disable-features=IsolateOrigins",
+    // "--disk-cache-dir=/dev/null",
+    // "--disk-cache-size=1",
+    // "--no-zygote",
+    // "--remote-allow-origins=ws://localhost:3234",
+    // "--single-process",
+    // "--start-maximized",
+    // "--unsafely-treat-insecure-origin-as-secure",
+    // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
+  ],
+};

package/src/PM/web.ts

@@ -38,14 +38,6 @@ export class PM_Web extends PM {
     throw new Error("Method not implemented.");
   }
 
-  stopSideCar(n: number): Promise<any> {
-    return window["stopSideCar"](n, this.testResourceConfiguration.name);
-  }
-
-  launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]> {
-    return window["launchSideCar"](n, this.testResourceConfiguration.name);
-  }
-
   waitForSelector(p: string, s: string): any {
     return window["waitForSelector"](p, s);
   }
@@ -179,4 +171,12 @@ export class PM_Web extends PM {
       );
     };
   }
+
+  // stopSideCar(n: number): Promise<any> {
+  //   return window["stopSideCar"](n, this.testResourceConfiguration.name);
+  // }
+
+  // launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]> {
+  //   return window["launchSideCar"](n, this.testResourceConfiguration.name);
+  // }
 }