testeranto 0.200.1 → 0.203.0

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/pitonoBuild.ts

@@ -0,0 +1,56 @@
+import { IBuiltConfig } from "../Types";
+import { generatePitonoMetafile, writePitonoMetafile } from "../utils/pitonoMetafile";
+import { PitonoWatcher } from "../utils/pitonoWatcher";
+
+export class PitonoBuild {
+  private config: IBuiltConfig;
+  private testName: string;
+  private watcher: PitonoWatcher | null = null;
+
+  constructor(config: IBuiltConfig, testName: string) {
+    this.config = config;
+    this.testName = testName;
+  }
+
+  async build() {
+    // Filter python tests
+    const pythonTests = this.config.tests.filter((test) => test[1] === "python");
+    const hasPythonTests = pythonTests.length > 0;
+    
+    if (hasPythonTests) {
+      // Get the entry points
+      const pythonEntryPoints = pythonTests.map((test) => test[0]);
+      
+      // Generate and write metafile
+      const metafile = await generatePitonoMetafile(this.testName, pythonEntryPoints);
+      writePitonoMetafile(this.testName, metafile);
+
+      // Start watching for changes
+      this.watcher = new PitonoWatcher(this.testName, pythonEntryPoints);
+      await this.watcher.start();
+      
+      return pythonEntryPoints;
+    }
+    
+    return [];
+  }
+
+  async rebuild() {
+    if (this.watcher) {
+      await this.watcher.regenerateMetafile();
+    }
+  }
+
+  stop() {
+    if (this.watcher) {
+      this.watcher.stop();
+      this.watcher = null;
+    }
+  }
+
+  onBundleChange(callback: () => void) {
+    if (this.watcher) {
+      this.watcher.onMetafileChange(callback);
+    }
+  }
+}

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,262 @@
+/* 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 === "python") {
+      return {
+        stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
+        stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
+        exit: fs.createWriteStream(`${safeDest}/exit.log`),
+      };
+    } else if (runtime === "golang") {
+      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);
+  // }
 }