testeranto 0.202.0 → 0.205.0

package/src/style.scss

@@ -1,3 +1,262 @@
-// @import "bootstrap/scss/bootstrap.scss";
-@import "testeranto-stilo/src/style.scss";
+@import "bootstrap/scss/bootstrap.scss";
+// @import "testeranto-stilo/src/style.scss";
 // @import "./themes.scss";
+
+// Ultra-tight spacing overrides
+* {
+  margin: 0;
+  padding: 0;
+  box-sizing: border-box;
+}
+
+body {
+  line-height: 1.1;
+  font-size: 0.875rem;
+}
+
+.container-fluid {
+  padding-left: 0.125rem;
+  padding-right: 0.125rem;
+}
+
+// Padding utilities
+.p-4 {
+  padding: 0.25rem !important;
+}
+.p-3 {
+  padding: 0.25rem !important;
+}
+.p-2 {
+  padding: 0.125rem !important;
+}
+.p-1 {
+  padding: 0.0625rem !important;
+}
+
+// Margin utilities
+.m-2 {
+  margin: 0.125rem !important;
+}
+.m-3 {
+  margin: 0.25rem !important;
+}
+.mb-3 {
+  margin-bottom: 0.25rem !important;
+}
+.mt-2 {
+  margin-top: 0.125rem !important;
+}
+.mt-3 {
+  margin-top: 0.25rem !important;
+}
+
+// Navbar and sidebar adjustments
+.navbar {
+  min-height: 1.5rem;
+}
+
+.nav-link {
+  padding: 0.125rem 0.25rem !important;
+  margin: 0.0625rem !important;
+  font-size: 0.75rem;
+}
+
+// Card adjustments
+.card {
+  margin-bottom: 0.25rem;
+}
+
+.card-body {
+  padding: 0.25rem;
+}
+
+.card-header {
+  padding: 0.125rem 0.25rem;
+  font-size: 0.75rem;
+}
+
+// Form adjustments
+.form-control {
+  padding: 0.0625rem 0.125rem;
+  font-size: 0.75rem;
+  line-height: 1.1;
+}
+
+.form-label {
+  margin-bottom: 0.0625rem;
+  font-size: 0.75rem;
+}
+
+// Button adjustments
+.btn {
+  padding: 0.0625rem 0.25rem;
+  font-size: 0.75rem;
+  line-height: 1.1;
+}
+
+.btn-sm {
+  padding: 0.03125rem 0.125rem;
+  font-size: 0.6875rem;
+}
+
+// Alert adjustments
+.alert {
+  padding: 0.125rem 0.25rem;
+  margin-bottom: 0.25rem;
+  font-size: 0.75rem;
+}
+
+// Tooltip adjustments
+.tooltip {
+  .tooltip-inner {
+    padding: 0.125rem 0.25rem;
+    font-size: 0.6875rem;
+  }
+}
+
+// Additional ultra-compact styles
+h1,
+h2,
+h3,
+h4,
+h5,
+h6 {
+  margin-bottom: 0.25rem;
+  line-height: 1.1;
+}
+
+h1 {
+  font-size: 1.25rem;
+}
+h2 {
+  font-size: 1.125rem;
+}
+h3 {
+  font-size: 1rem;
+}
+h4 {
+  font-size: 0.875rem;
+}
+h5 {
+  font-size: 0.8125rem;
+}
+h6 {
+  font-size: 0.75rem;
+}
+
+// List items
+ul,
+ol {
+  padding-left: 1rem;
+  margin-bottom: 0.25rem;
+}
+
+li {
+  margin-bottom: 0.125rem;
+}
+
+// Table adjustments
+.table {
+  font-size: 0.75rem;
+  margin-bottom: 0.25rem;
+
+  th,
+  td {
+    padding: 0.125rem 0.25rem;
+  }
+}
+
+// Badge adjustments
+.badge {
+  font-size: 0.6875rem;
+  padding: 0.125rem 0.25rem;
+}
+
+// Dropdown adjustments
+.dropdown-menu {
+  font-size: 0.75rem;
+  padding: 0.125rem;
+
+  .dropdown-item {
+    padding: 0.125rem 0.5rem;
+  }
+}
+
+// Modal adjustments
+.modal-content {
+  .modal-header {
+    padding: 0.25rem 0.5rem;
+  }
+  .modal-body {
+    padding: 0.25rem;
+  }
+  .modal-footer {
+    padding: 0.25rem;
+  }
+}
+
+// Reduce border radii for a more compact look
+.rounded {
+  border-radius: 0.125rem !important;
+}
+.rounded-sm {
+  border-radius: 0.0625rem !important;
+}
+
+/////////////////////////////////
+///
+@font-face {
+  font-family: "M PLUS Rounded 1c";
+  src: url("../../../fonts/M_PLUS_Rounded_1c/MPLUSRounded1c-Thin.ttf")
+    format("truetype");
+  font-weight: 100;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: "M PLUS Rounded 1c";
+  src: url("../../../fonts/M_PLUS_Rounded_1c/MPLUSRounded1c-Light.ttf")
+    format("truetype");
+  font-weight: 300;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: "M PLUS Rounded 1c";
+  src: url("../../../fonts/M_PLUS_Rounded_1c/MPLUSRounded1c-Regular.ttf")
+    format("truetype");
+  font-weight: 400;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: "M PLUS Rounded 1c";
+  src: url("../../../fonts/M_PLUS_Rounded_1c/MPLUSRounded1c-Medium.ttf")
+    format("truetype");
+  font-weight: 500;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: "M PLUS Rounded 1c";
+  src: url("../../../fonts/M_PLUS_Rounded_1c/MPLUSRounded1c-Bold.ttf")
+    format("truetype");
+  font-weight: 700;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: "M PLUS Rounded 1c";
+  src: url("../../../fonts/M_PLUS_Rounded_1c/MPLUSRounded1c-ExtraBold.ttf")
+    format("truetype");
+  font-weight: 800;
+  font-style: normal;
+}
+
+@font-face {
+  font-family: "M PLUS Rounded 1c";
+  src: url("../../../fonts/M_PLUS_Rounded_1c/MPLUSRounded1c-Black.ttf")
+    format("truetype");
+  font-weight: 900;
+  font-style: normal;
+}

package/src/testeranto.ts

@@ -1,27 +1,29 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unused-vars */
+
 import ansiC from "ansi-colors";
 import fs from "fs";
-import path from "path";
 import readline from "readline";
 
-import { ITestconfig, IRunTime, ITestTypes, IBuiltConfig } from "./lib";
+import { ITestconfig, IRunTime, IBuiltConfig } from "./lib";
 import { IProject } from "./Types";
-import { getRunnables } from "./utils";
+
 import { AppHtml } from "./utils/buildTemplates";
 
-import webHtmlFrame from "./web.html";
-import { PM_Main } from "./PM/main";
+import { PM_Main } from "./app/backend/main";
+import { PitonoBuild } from "./PM/pitonoBuild";
+import { getRunnables } from "./app/backend/utils";
+const { GolingvuBuild } = await import("./PM/golingvuBuild");
 
-if (!process.env.GITHUB_CLIENT_ID) {
-  console.error(`env var "GITHUB_CLIENT_ID" needs to be set!`);
-  process.exit(-1);
-}
+// if (!process.env.GITHUB_CLIENT_ID) {
+//   console.error(`env var "GITHUB_CLIENT_ID" needs to be set!`);
+//   process.exit(-1);
+// }
 
-if (!process.env.GITHUB_CLIENT_SECRET) {
-  console.error(`env var "GITHUB_CLIENT_SECRET" needs to be set!`);
-  process.exit(-1);
-}
+// if (!process.env.GITHUB_CLIENT_SECRET) {
+//   console.error(`env var "GITHUB_CLIENT_SECRET" needs to be set!`);
+//   process.exit(-1);
+// }
 
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
@@ -34,11 +36,9 @@ if (mode !== "once" && mode !== "dev") {
   process.exit(-1);
 }
 
-const f = process.cwd() + "/" + "testeranto.config.ts";
+const configFilePath = process.cwd() + "/" + "testeranto.config.ts";
 
-console.log("config file:", f);
-
-import(f).then(async (module) => {
+import(configFilePath).then(async (module) => {
   const pckge = (await import(`${process.cwd()}/package.json`)).default;
   const bigConfig: IProject = module.default;
 
@@ -67,7 +67,7 @@ import(f).then(async (module) => {
   }
 
   if (!rawConfig.tests) {
-    console.error(testName, "appears to have no tests: ", f);
+    console.error(testName, "appears to have no tests: ", configFilePath);
     console.error(`here is the config:`);
     console.log(JSON.stringify(rawConfig));
     process.exit(-1);
@@ -88,16 +88,18 @@ import(f).then(async (module) => {
     }
   });
 
+  //////////////////////////////////////////////////////////////////////////////////////////////////
+
   let pm: PM_Main | null = null;
   // Start PM_Main immediately - it will handle the build processes internally
-  const { PM_Main } = await import("./PM/main");
+  const { PM_Main } = await import("./app/backend/main");
   pm = new PM_Main(config, testName, mode);
   await pm.start();
 
-  fs.writeFileSync(`${process.cwd()}/testeranto/projects.html`, AppHtml());
+  fs.writeFileSync(`${process.cwd()}/testeranto/index.html`, AppHtml());
 
   Object.keys(bigConfig.projects).forEach((projectName) => {
-    console.log(`testeranto/reports/${projectName}`);
+    // console.log(`testeranto/reports/${projectName}`);
     if (!fs.existsSync(`testeranto/reports/${projectName}`)) {
       fs.mkdirSync(`testeranto/reports/${projectName}`);
     }
@@ -108,161 +110,126 @@ import(f).then(async (module) => {
     );
   });
 
-  const getSecondaryEndpointsPoints = (runtime?: IRunTime): string[] => {
-    const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
-      ts.forEach((t) => {
-        if (t[1] === runtime) {
-          st.add(t[0]);
-        }
-        if (Array.isArray(t[3])) {
-          meta(t[3], st);
-        }
-      });
-      return st;
-    };
-    return Array.from(meta(config.tests, new Set()));
-  };
+  // const getSecondaryEndpointsPoints = (runtime?: IRunTime): string[] => {
+  //   const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
+  //     ts.forEach((t) => {
+  //       if (t[1] === runtime) {
+  //         st.add(t[0]);
+  //       }
+  //       if (Array.isArray(t[3])) {
+  //         meta(t[3], st);
+  //       }
+  //     });
+  //     return st;
+  //   };
+  //   return Array.from(meta(config.tests, new Set()));
+  // };
 
   // Also handle pitono endpoints for HTML generation if needed
-  [...getSecondaryEndpointsPoints("python")].forEach(async (sourceFilePath) => {
-    // You might want to generate specific files for pitono tests here
-    console.log(`Pitono test found: ${sourceFilePath}`);
-  });
+  // [...getSecondaryEndpointsPoints("python")].forEach(async (sourceFilePath) => {
+  //   // You might want to generate specific files for pitono tests here
+  //   console.log(`Pitono test found: ${sourceFilePath}`);
+  // });
+
+  // Promise.resolve(
+  //   Promise.all(
+  //     [...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
+  //       const sourceFileSplit = sourceFilePath.split("/");
+  //       const sourceDir = sourceFileSplit.slice(0, -1);
+  //       const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
+  //       const sourceFileNameMinusJs = sourceFileName
+  //         .split(".")
+  //         .slice(0, -1)
+  //         .join(".");
+
+  //       const htmlFilePath = path.normalize(
+  //         `${process.cwd()}/testeranto/bundles/web/${testName}/${sourceDir.join(
+  //           "/"
+  //         )}/${sourceFileNameMinusJs}.html`
+  //       );
+  //       const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
+  //       const cssFilePath = `./${sourceFileNameMinusJs}.css`;
+
+  //       return fs.promises
+  //         .mkdir(path.dirname(htmlFilePath), { recursive: true })
+  //         .then((x) =>
+  //           fs.writeFileSync(
+  //             htmlFilePath,
+  //             webHtmlFrame(jsfilePath, htmlFilePath, cssFilePath)
+  //           )
+  //         );
+  //     })
+  //   )
+  // );
 
-  // Handle golang tests by generating their metafiles
+  const {
+    nodeEntryPoints,
+    nodeEntryPointSidecars,
+    webEntryPoints,
+    webEntryPointSidecars,
+    pureEntryPoints,
+    pureEntryPointSidecars,
+    pythonEntryPoints,
+    pythonEntryPointSidecars,
+    golangEntryPoints,
+    golangEntryPointSidecars,
+  } = getRunnables(config.tests, testName);
+
+  // Debug logging to check if entry points are being found
+  console.log("Node entry points:", Object.keys(nodeEntryPoints));
+  console.log("Web entry points:", Object.keys(webEntryPoints));
+  console.log("Pure entry points:", Object.keys(pureEntryPoints));
+
+  // Handle golang tests using GolingvuBuild
   const golangTests = config.tests.filter((test) => test[1] === "golang");
   const hasGolangTests = golangTests.length > 0;
   if (hasGolangTests) {
-    // Import and use the golang metafile utilities
-    const { generateGolangMetafile, writeGolangMetafile } = await import(
-      "./utils/golingvuMetafile"
-    );
-    // Get the entry points (first element of each test tuple)
-    const golangEntryPoints = golangTests.map((test) => test[0]);
-    const metafile = await generateGolangMetafile(testName, golangEntryPoints);
-    writeGolangMetafile(testName, metafile);
-    // Mark golang as done after writing the metafile
-    // onGolangDone();
+    const golingvuBuild = new GolingvuBuild(config, testName);
+    const golangEntryPoints = await golingvuBuild.build();
+    golingvuBuild.onBundleChange(() => {
+      Object.keys(golangEntryPoints).forEach((entryPoint) => {
+        if (pm) {
+          pm.addToQueue(entryPoint, "golang");
+        }
+      });
+    });
   }
 
   // Handle pitono (Python) tests by generating their metafiles
   const pitonoTests = config.tests.filter((test) => test[1] === "python");
   const hasPitonoTests = pitonoTests.length > 0;
   if (hasPitonoTests) {
-    // Import and use the pitono metafile utilities
-    const { generatePitonoMetafile } = await import("./utils/pitonoMetafile");
-    // Get the entry points (first element of each test tuple)
-    const pitonoEntryPoints = pitonoTests.map((test) => test[0]);
-    const metafile = await generatePitonoMetafile(testName, pitonoEntryPoints);
-
-    // Ensure the directory exists
-    const pitonoMetafilePath = `${process.cwd()}/testeranto/metafiles/python`;
-    await fs.promises.mkdir(pitonoMetafilePath, { recursive: true });
-
-    // Write the metafile to the specified path
-    fs.writeFileSync(
-      `${pitonoMetafilePath}/core.json`,
-      JSON.stringify(metafile, null, 2)
-    );
-
-    console.log(
-      ansiC.green(
-        ansiC.inverse(`Python metafile written to: ${pitonoMetafilePath}/core.json`)
-      )
-    );
-
-    // Add Python tests to the processing queue
-    pitonoEntryPoints.forEach((entryPoint) => {
-      if (pm) {
-        // For Python tests, the source file is the entry point itself
-        pm.addToQueue(entryPoint, "python");
-      }
+    const pitonoBuild = new PitonoBuild(config, testName);
+    const pitonoEntryPoints = await pitonoBuild.build();
+    pitonoBuild.onBundleChange(() => {
+      Object.keys(pitonoEntryPoints).forEach((entryPoint) => {
+        if (pm) {
+          pm.addToQueue(entryPoint, "python");
+        }
+      });
     });
   }
 
-  Promise.resolve(
-    Promise.all(
-      [...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
-        const sourceFileSplit = sourceFilePath.split("/");
-        const sourceDir = sourceFileSplit.slice(0, -1);
-        const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
-        const sourceFileNameMinusJs = sourceFileName
-          .split(".")
-          .slice(0, -1)
-          .join(".");
-
-        const htmlFilePath = path.normalize(
-          `${process.cwd()}/testeranto/bundles/web/${testName}/${sourceDir.join(
-            "/"
-          )}/${sourceFileNameMinusJs}.html`
-        );
-        const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
-        const cssFilePath = `./${sourceFileNameMinusJs}.css`;
-
-        return fs.promises
-          .mkdir(path.dirname(htmlFilePath), { recursive: true })
-          .then((x) =>
-            fs.writeFileSync(
-              htmlFilePath,
-              webHtmlFrame(jsfilePath, htmlFilePath, cssFilePath)
-            )
-          );
-      })
-    )
-  );
-
-  const {
-    nodeEntryPoints,
-    nodeEntryPointSidecars,
-    webEntryPoints,
-    webEntryPointSidecars,
-    pureEntryPoints,
-    pureEntryPointSidecars,
-    pythonEntryPoints,
-    pythonEntryPointSidecars,
-  } = getRunnables(config.tests, testName);
-
-  const x: [IRunTime, string[]][] = [
+  // create the necessary folders for all tests
+  [
     ["pure", Object.keys(pureEntryPoints)],
     ["node", Object.keys(nodeEntryPoints)],
     ["web", Object.keys(webEntryPoints)],
     ["python", Object.keys(pythonEntryPoints)],
-  ];
-
-  x.forEach(async ([runtime, keys]) => {
+    ["golang", Object.keys(golangEntryPoints)],
+  ].forEach(async ([runtime, keys]: [IRunTime, string[]]) => {
     keys.forEach(async (k) => {
-      const folder = `testeranto/reports/${testName}/${k
-        .split(".")
-        .slice(0, -1)
-        .join(".")}/${runtime}`;
-
-      await fs.mkdirSync(folder, { recursive: true });
+      fs.mkdirSync(
+        `testeranto/reports/${testName}/${k
+          .split(".")
+          .slice(0, -1)
+          .join(".")}/${runtime}`,
+        { recursive: true }
+      );
     });
   });
 
-  [
-    [pureEntryPoints, pureEntryPointSidecars, "pure"],
-    [webEntryPoints, webEntryPointSidecars, "web"],
-    [nodeEntryPoints, nodeEntryPointSidecars, "node"],
-    [pythonEntryPoints, pythonEntryPointSidecars, "python"],
-  ].forEach(
-    ([eps, eps2, runtime]: [
-      Record<string, string>,
-      Record<string, string>,
-      IRunTime
-    ]) => {
-      [...Object.keys(eps), ...Object.keys(eps2)].forEach((ep) => {
-        const fp = path.resolve(
-          `testeranto`,
-          `reports`,
-          testName,
-          ep.split(".").slice(0, -1).join("."),
-          runtime
-        );
-        fs.mkdirSync(fp, { recursive: true });
-      });
-    }
-  );
+  ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
   process.stdin.on("keypress", (str, key) => {
     if (key.name === "q") {