testeranto 0.219.15 → 0.219.17

package/bundle.js

@@ -1,5 +1,6 @@
-import * as fs from 'fs';
-import * as path from 'path';
+
+import fs from "fs"
+import path from "path"
 import * as esbuild from 'esbuild'
 
 // Build main application

package/dist/common/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/dist/module/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "module"
+}

package/dist/prebuild/chunk-QLT7PNPK.mjs

@@ -0,0 +1,162 @@
+// src/server/runtimes/common.ts
+import path from "path";
+import fs from "fs";
+import crypto from "crypto";
+async function processMetafile(config, metafile, runtime) {
+  if (!metafile || !metafile.outputs) {
+    return;
+  }
+  for (const [outputFile, outputInfo] of Object.entries(metafile.outputs)) {
+    let collectFileDependencies2 = function(filePath) {
+      if (collectedFiles.has(filePath)) {
+        return;
+      }
+      collectedFiles.add(filePath);
+      const fileInfo = metafile.inputs?.[filePath];
+      if (fileInfo?.imports) {
+        for (const importInfo of fileInfo.imports) {
+          const importPath = importInfo.path;
+          if (metafile.inputs?.[importPath]) {
+            collectFileDependencies2(importPath);
+          }
+        }
+      }
+    };
+    var collectFileDependencies = collectFileDependencies2;
+    const outputInfoTyped = outputInfo;
+    if (!outputInfoTyped.entryPoint) {
+      console.log(`[${runtime} Builder] Skipping output without entryPoint: ${outputFile}`);
+      continue;
+    }
+    const entryPoint = outputInfoTyped.entryPoint;
+    const isTestFile = /\.(test|spec)\.(ts|js)$/.test(entryPoint);
+    if (!isTestFile) {
+      console.log(`[${runtime} Builder] Skipping non-test entryPoint: ${entryPoint}`);
+      continue;
+    }
+    const outputInputs = outputInfoTyped.inputs || {};
+    const collectedFiles = /* @__PURE__ */ new Set();
+    for (const inputFile of Object.keys(outputInputs)) {
+      collectFileDependencies2(inputFile);
+    }
+    const allInputFiles = Array.from(collectedFiles).map(
+      (filePath) => path.isAbsolute(filePath) ? filePath : path.resolve(process.cwd(), filePath)
+    );
+    const workspaceRoot = "/workspace";
+    const relativeFiles = allInputFiles.map((file) => {
+      const absolutePath = path.isAbsolute(file) ? file : path.resolve(process.cwd(), file);
+      if (absolutePath.startsWith(workspaceRoot)) {
+        return absolutePath.slice(workspaceRoot.length);
+      }
+      return path.relative(process.cwd(), absolutePath);
+    }).filter(Boolean);
+    const outputBaseName = entryPoint.split(".").slice(0, -1).join(".");
+    const inputFilesPath = `testeranto/bundles/allTests/${runtime}/${outputBaseName}.mjs-inputFiles.json`;
+    fs.writeFileSync(inputFilesPath, JSON.stringify(relativeFiles, null, 2));
+    console.log(`[${runtime} Builder] Wrote ${relativeFiles.length} input files to ${inputFilesPath}`);
+  }
+}
+
+// src/esbuildConfigs/featuresPlugin.ts
+import path2 from "path";
+var featuresPlugin_default = {
+  name: "feature-markdown",
+  setup(build) {
+    build.onResolve({ filter: /\.md$/ }, (args) => {
+      if (args.resolveDir === "") return;
+      return {
+        path: path2.isAbsolute(args.path) ? args.path : path2.join(args.resolveDir, args.path),
+        namespace: "feature-markdown"
+      };
+    });
+    build.onLoad(
+      { filter: /.*/, namespace: "feature-markdown" },
+      async (args) => {
+        return {
+          contents: `file://${args.path}`,
+          loader: "text"
+          // contents: JSON.stringify({ path: args.path }),
+          // loader: "json",
+          // contents: JSON.stringify({
+          //   // html: markdownHTML,
+          //   raw: markdownContent,
+          //   filename: args.path, //path.basename(args.path),
+          // }),
+          // loader: "json",
+        };
+      }
+    );
+  }
+};
+
+// src/esbuildConfigs/index.ts
+var esbuildConfigs_default = (config) => {
+  return {
+    // packages: "external",
+    target: "esnext",
+    format: "esm",
+    splitting: true,
+    outExtension: { ".js": ".mjs" },
+    outbase: ".",
+    jsx: "transform",
+    bundle: true,
+    // minify: config.minify === true,
+    write: true,
+    loader: {
+      ".js": "jsx",
+      ".png": "binary",
+      ".jpg": "binary"
+    }
+  };
+};
+
+// src/esbuildConfigs/inputFilesPlugin.ts
+import fs2 from "fs";
+var otherInputs = {};
+var register = (entrypoint, sources) => {
+  if (!otherInputs[entrypoint]) {
+    otherInputs[entrypoint] = /* @__PURE__ */ new Set();
+  }
+  sources.forEach((s) => otherInputs[entrypoint].add(s));
+};
+var inputFilesPlugin_default = (platform, testName) => {
+  const f = `${testName}`;
+  return {
+    register,
+    inputFilesPluginFactory: {
+      name: "metafileWriter",
+      setup(build) {
+        build.onEnd((result) => {
+          fs2.writeFileSync(f, JSON.stringify(result, null, 2));
+        });
+      }
+    }
+  };
+};
+
+// src/esbuildConfigs/rebuildPlugin.ts
+import fs3 from "fs";
+var rebuildPlugin_default = (r) => {
+  return {
+    name: "rebuild-notify",
+    setup: (build) => {
+      build.onEnd((result) => {
+        console.log(`${r} > build ended with ${result.errors.length} errors`);
+        if (result.errors.length > 0) {
+          fs3.writeFileSync(
+            `./testeranto/reports${r}_build_errors`,
+            JSON.stringify(result, null, 2)
+          );
+        }
+      });
+    }
+  };
+};
+
+export {
+  processMetafile,
+  featuresPlugin_default,
+  esbuildConfigs_default,
+  inputFilesPlugin_default,
+  rebuildPlugin_default
+};

package/dist/prebuild/esbuildConfigs/eslint-formatter-testeranto.mjs

@@ -0,0 +1,20 @@
+// src/esbuildConfigs/eslint-formatter-testeranto.ts
+function eslint_formatter_testeranto_default(results) {
+  return results.filter((r) => r.messages.length).map((r) => {
+    const path = r.filePath.replace(process.cwd() + "/", "");
+    return [
+      path,
+      ...r.messages.map(
+        (m) => [
+          `${m.line}:${m.column} ${m.message} (${m.ruleId || ""})`,
+          ...m.suggestions?.map(
+            (s) => `- ${s.message}${s.fix ? " (fix)" : ""}`
+          ) || []
+        ].join("\n")
+      )
+    ].join("\n");
+  }).join("\n\n");
+}
+export {
+  eslint_formatter_testeranto_default as default
+};

package/dist/prebuild/init-docs.mjs

@@ -0,0 +1,56 @@
+// src/Init.ts
+import fs from "fs";
+var Init_default = async () => {
+  [
+    `testeranto/`,
+    `testeranto/bundles/`,
+    `testeranto/bundles/node`,
+    `testeranto/bundles/web`,
+    `testeranto/bundles/pure`,
+    `testeranto/bundles/golang`,
+    `testeranto/bundles/python`,
+    `testeranto/reports/`,
+    `testeranto/features/`,
+    `testeranto/metafiles/`,
+    `testeranto/metafiles/node`,
+    `testeranto/metafiles/web`,
+    `testeranto/metafiles/pure`,
+    `testeranto/metafiles/golang`,
+    `testeranto/metafiles/python`
+  ].forEach((f) => {
+    try {
+      fs.mkdirSync(`${process.cwd()}/${f}`);
+    } catch (e) {
+      console.error(e);
+    }
+  });
+  fs.copyFileSync(
+    `node_modules/testeranto/dist/prebuild/Report.js`,
+    `testeranto/Report.js`
+  );
+  fs.copyFileSync(
+    `node_modules/testeranto/dist/prebuild/Report.css`,
+    `testeranto/Report.css`
+  );
+  fs.copyFileSync(
+    `node_modules/testeranto/dist/prebuild/ProcessManager.js`,
+    `testeranto/ProcessManager.js`
+  );
+  fs.copyFileSync(
+    `node_modules/testeranto/dist/prebuild/ProcessManager.css`,
+    `testeranto/ProcessManager.css`
+  );
+  fs.copyFileSync(
+    `node_modules/testeranto/dist/prebuild/Features.js`,
+    `testeranto/ProcessManager.js`
+  );
+  fs.copyFileSync(
+    `node_modules/testeranto/dist/prebuild/Features.css`,
+    `testeranto/ProcessManager.css`
+  );
+};
+
+// src/init-docs.ts
+console.log("Initializing a testeranto project");
+Init_default();
+console.log("testeranto project initialized");

package/dist/prebuild/server/runtimes/node/node.mjs

@@ -0,0 +1,80 @@
+import {
+  esbuildConfigs_default,
+  featuresPlugin_default,
+  inputFilesPlugin_default,
+  processMetafile,
+  rebuildPlugin_default
+} from "../../../chunk-QLT7PNPK.mjs";
+
+// src/server/runtimes/node/node.ts
+import esbuild from "esbuild";
+
+// src/server/runtimes/node/esbuild.ts
+var absoluteBundlesDir = () => {
+  return "./testeranto/bundles/allTests/node/";
+};
+var esbuild_default = (nodeConfig, testName2, projectConfig) => {
+  console.log("esbuild", testName2, projectConfig);
+  const entryPoints = projectConfig.runtimes[testName2].tests;
+  const { inputFilesPluginFactory, register } = inputFilesPlugin_default(
+    "node",
+    testName2
+  );
+  return {
+    ...esbuildConfigs_default(nodeConfig),
+    outdir: absoluteBundlesDir(),
+    outbase: ".",
+    // Preserve directory structure relative to outdir
+    metafile: true,
+    supported: {
+      "dynamic-import": true
+    },
+    define: {
+      "process.env.FLUENTFFMPEG_COV": "0",
+      ENV: `"node"`
+    },
+    bundle: true,
+    format: "esm",
+    absWorkingDir: process.cwd(),
+    platform: "node",
+    packages: "external",
+    entryPoints,
+    plugins: [
+      featuresPlugin_default,
+      inputFilesPluginFactory,
+      rebuildPlugin_default("node"),
+      ...nodeConfig.plugins?.map((p) => p(register, entryPoints)) || []
+    ]
+  };
+};
+
+// src/server/runtimes/node/node.ts
+console.log(`[NODE BUILDER] hello:  ${process.argv}`);
+var projectConfigPath = process.argv[2];
+var nodeConfigPath = process.argv[3];
+var testName = process.argv[4];
+console.log(`[NODE BUILDER] projectConfigPath:  ${projectConfigPath}`);
+console.log(`[NODE BUILDER] nodeConfig:  ${nodeConfigPath}`);
+console.log(`[NODE BUILDER] testName:  ${testName}`);
+async function startBundling(nodeConfigs, projectConfig) {
+  console.log(`[NODE BUILDER] is now bundling:  ${testName}`);
+  const n = esbuild_default(nodeConfigs, testName, projectConfig);
+  const buildResult = await esbuild.build(n);
+  if (buildResult.metafile) {
+    await processMetafile(projectConfig, buildResult.metafile, "node");
+  } else {
+    console.warn("No metafile generated by esbuild");
+  }
+}
+async function main() {
+  try {
+    const nodeConfigs = (await import(nodeConfigPath)).default;
+    const projectConfigs = (await import(projectConfigPath)).default;
+    await startBundling(nodeConfigs, projectConfigs);
+  } catch (error) {
+    console.error("NODE BUILDER: Error importing config:", nodeConfigPath, error);
+    console.error(error);
+    process.exit(1);
+  }
+}
+main();

package/dist/prebuild/server/runtimes/web/hoist.mjs

@@ -0,0 +1,12 @@
+// src/server/runtimes/web/hoist.ts
+import puppeteer from "puppeteer";
+async function main() {
+  const browser = await puppeteer.connect({
+    browserURL: "http://web-builder:9222"
+  });
+  const page = await browser.newPage();
+  await page.goto("about:blank");
+  await browser.disconnect();
+  return;
+}
+main();

package/dist/prebuild/server/runtimes/web/web.mjs

@@ -0,0 +1,162 @@
+import {
+  esbuildConfigs_default,
+  featuresPlugin_default,
+  inputFilesPlugin_default,
+  processMetafile,
+  rebuildPlugin_default
+} from "../../../chunk-QLT7PNPK.mjs";
+
+// src/server/runtimes/web/web.ts
+import esbuild from "esbuild";
+import puppeteer from "puppeteer";
+
+// src/server/runtimes/web/esbuild.ts
+var absoluteBundlesDir = (c) => {
+  return "./testeranto/bundles/allTests/web/";
+};
+var esbuild_default = (config, testName2) => {
+  const entrypoints = ["./example/Calculator.test.ts"];
+  const { inputFilesPluginFactory, register } = inputFilesPlugin_default(
+    "web",
+    testName2
+  );
+  return {
+    ...esbuildConfigs_default(config),
+    outdir: absoluteBundlesDir(config),
+    outbase: ".",
+    metafile: true,
+    supported: {
+      "dynamic-import": true
+    },
+    define: {
+      "process.env.FLUENTFFMPEG_COV": "0",
+      ENV: `"web"`
+    },
+    absWorkingDir: process.cwd(),
+    platform: "browser",
+    packages: "external",
+    entryPoints: entrypoints,
+    bundle: true,
+    format: "esm",
+    plugins: [
+      featuresPlugin_default,
+      inputFilesPluginFactory,
+      rebuildPlugin_default("web"),
+      ...config.web?.plugins?.map((p) => p(register, entrypoints)) || []
+    ]
+  };
+};
+
+// src/server/runtimes/web/web.ts
+import * as fs from "fs";
+import * as path from "path";
+var configFilePath = process.argv[2];
+var testName = process.argv[3] || "allTests";
+async function startBundling(config) {
+  console.log(`[WEB BUILDER] is now bundling:  ${testName}`);
+  if (!config) {
+    throw new Error("Config is undefined");
+  }
+  if (!config.buildDir) {
+    console.warn("config.buildDir is undefined, using default");
+    config.buildDir = "/workspace";
+  }
+  console.log(`Using build directory: ${config.buildDir}`);
+  const webConfig = esbuild_default(config, "allTests");
+  const buildResult = await esbuild.build(webConfig);
+  if (buildResult.metafile) {
+    await processMetafile(config, buildResult.metafile, "web");
+    const outputFiles = Object.keys(buildResult.metafile.outputs);
+    for (const outputFile of outputFiles) {
+      if (true) {
+        const htmlPath = `testeranto/bundles/allTests/web/example/Calculator.test.ts.html`;
+        await fs.promises.mkdir(path.dirname(htmlPath), { recursive: true });
+        const htmlContent = `<!DOCTYPE html>
+    <html>
+    <head>
+        <meta charset="UTF-8">
+        <title>Test Runner</title>
+    </head>
+    <body>
+        <div id="root"></div>
+        <script src="testeranto/bundles/allTests/web/example/Calculator.test.mjs"></script>
+    </body>
+    </html>`;
+        await fs.promises.writeFile(htmlPath, htmlContent);
+        console.log(`Created HTML file: ${htmlPath}`);
+      }
+    }
+  } else {
+    console.warn("No metafile generated by esbuild");
+  }
+  console.log("WEB BUILDER: Metafiles have been generated");
+  if (true) {
+    console.log(
+      "WEB BUILDER: Running in dev mode, keeping builder alive..."
+    );
+    const ctx = await esbuild.context(webConfig);
+    let { hosts, port } = await ctx.serve();
+    console.log(
+      `[WEB BUILDER]: esbuild server ${hosts}, ${port}`
+    );
+    process.on("SIGINT", async () => {
+      console.log("WEB BUILDER: Shutting down...");
+      process.exit(0);
+    });
+    try {
+      const browser = await puppeteer.launch({
+        // Flags required for Docker/Alpine compatibility
+        args: [
+          "--no-sandbox",
+          "--disable-setuid-sandbox",
+          "--disable-dev-shm-usage",
+          // Prevents crashes in low-memory Docker envs
+          "--disable-gpu",
+          "--single-process",
+          // Run in a single process
+          "--no-zygote",
+          // Disable zygote process
+          "--disable-background-timer-throttling",
+          // Disable throttling of timers in background pages
+          "--disable-backgrounding-occluded-windows",
+          // Disable backgrounding of occluded windows
+          "--disable-renderer-backgrounding",
+          // Disable backgrounding renders
+          "--remote-debugging-address=0.0.0.0",
+          // Allow remote debugging
+          "--remote-debugging-port=9222"
+          // Set remote debugging port
+        ],
+        // Automatically uses ENV PUPPETEER_EXECUTABLE_PATH
+        executablePath: process.env.PUPPETEER_EXECUTABLE_PATH || "/usr/bin/chromium-browser",
+        headless: true,
+        // Run in headless mode
+        timeout: 6e4
+        // Increase timeout to 60 seconds
+      });
+      console.log("Puppeteer launched successfully");
+    } catch (error) {
+      console.error("Failed to launch Puppeteer:", error);
+      process.exit(1);
+    }
+    await new Promise(() => {
+    });
+  }
+}
+async function main() {
+  try {
+    console.log(`[WEB BUILDER] Importing config from: ${configFilePath}`);
+    const imported = await import(configFilePath);
+    const config = imported.default;
+    if (!config) {
+      throw new Error(`Config not found in ${configFilePath}. Ensure the file exports a default object.`);
+    }
+    console.log("[WEB BUILDER] Config imported successfully:", Object.keys(config));
+    await startBundling(config);
+    console.log(`[WEB BUILDER] Puppeteer is running: ${puppeteer}`);
+  } catch (error) {
+    console.error(error);
+    process.exit(1);
+  }
+}
+main();