testeranto 0.200.1 → 0.202.0

package/dist/module/src/testeranto.js

@@ -4,13 +4,17 @@ import ansiC from "ansi-colors";
 import fs from "fs";
 import path from "path";
 import readline from "readline";
-import esbuild from "esbuild";
 import { getRunnables } from "./utils";
 import { AppHtml } from "./utils/buildTemplates";
-import esbuildNodeConfiger from "./esbuildConfigs/node";
-import esbuildWebConfiger from "./esbuildConfigs/web";
-import esbuildImportConfiger from "./esbuildConfigs/pure";
 import webHtmlFrame from "./web.html";
+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);
+}
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
@@ -30,7 +34,13 @@ import(f).then(async (module) => {
         console.error("no project found for", testName, "in testeranto.config.ts");
         process.exit(-1);
     }
-    fs.writeFileSync(`${process.cwd()}/testeranto/projects.json`, JSON.stringify(Object.keys(bigConfig.projects), null, 2));
+    try {
+        fs.writeFileSync(`${process.cwd()}/testeranto/projects.json`, JSON.stringify(Object.keys(bigConfig.projects), null, 2));
+    }
+    catch (e) {
+        console.error("there was a problem");
+        console.error(e);
+    }
     const rawConfig = bigConfig.projects[testName];
     if (!rawConfig) {
         console.error(`Project "${testName}" does not exist in the configuration.`);
@@ -52,56 +62,11 @@ import(f).then(async (module) => {
             process.exit(-1);
         }
     });
-    let nodeDone = false;
-    let webDone = false;
-    let importDone = false;
-    let golangDone = false;
-    let pitonoDone = false;
-    let status = "build";
-    const { nodeEntryPoints, nodeEntryPointSidecars, webEntryPoints, webEntryPointSidecars, pureEntryPoints, pureEntryPointSidecars, } = getRunnables(config.tests, testName);
-    const onNodeDone = () => {
-        nodeDone = true;
-        onDone();
-    };
-    const onWebDone = () => {
-        webDone = true;
-        onDone();
-    };
-    const onImportDone = () => {
-        importDone = true;
-        onDone();
-    };
-    const onGolangDone = () => {
-        golangDone = true;
-        onDone();
-    };
-    const onPitonoDone = () => {
-        pitonoDone = true;
-        onDone();
-    };
     let pm = null;
-    const onDone = async () => {
-        // Check which test types are present
-        const hasGolangTests = config.tests.some(test => test[1] === 'golang');
-        const hasPitonoTests = config.tests.some(test => test[1] === 'pitono');
-        // Wait for all relevant runtimes to be done
-        const allDone = nodeDone && webDone && importDone &&
-            (!hasGolangTests || golangDone) &&
-            (!hasPitonoTests || pitonoDone);
-        if (allDone) {
-            status = "built";
-            // Start the PM_Main to run the tests after build
-            if (!pm) {
-                const { PM_Main } = await import("./PM/main");
-                pm = new PM_Main(config, testName, mode);
-                await pm.start();
-            }
-        }
-        if (allDone && mode === "once") {
-            console.log(ansiC.inverse(`${testName} was built and the builder exited successfully.`));
-            // Let PM_Main handle the exit after tests are complete
-        }
-    };
+    // Start PM_Main immediately - it will handle the build processes internally
+    const { PM_Main } = await import("./PM/main");
+    pm = new PM_Main(config, testName, mode);
+    await pm.start();
     fs.writeFileSync(`${process.cwd()}/testeranto/projects.html`, AppHtml());
     Object.keys(bigConfig.projects).forEach((projectName) => {
         console.log(`testeranto/reports/${projectName}`);
@@ -125,39 +90,45 @@ import(f).then(async (module) => {
         return Array.from(meta(config.tests, new Set()));
     };
     // Also handle pitono endpoints for HTML generation if needed
-    [...getSecondaryEndpointsPoints("pitono")].forEach(async (sourceFilePath) => {
+    [...getSecondaryEndpointsPoints("python")].forEach(async (sourceFilePath) => {
         // You might want to generate specific files for pitono tests here
         console.log(`Pitono test found: ${sourceFilePath}`);
     });
     // Handle golang tests by generating their metafiles
-    const golangTests = config.tests.filter(test => test[1] === 'golang');
+    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');
+        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 golangEntryPoints = golangTests.map((test) => test[0]);
         const metafile = await generateGolangMetafile(testName, golangEntryPoints);
         writeGolangMetafile(testName, metafile);
         // Mark golang as done after writing the metafile
-        onGolangDone();
+        // onGolangDone();
     }
     // Handle pitono (Python) tests by generating their metafiles
-    const pitonoTests = config.tests.filter(test => test[1] === 'pitono');
+    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');
+        const { generatePitonoMetafile } = await import("./utils/pitonoMetafile");
         // Get the entry points (first element of each test tuple)
-        const pitonoEntryPoints = pitonoTests.map(test => test[0]);
+        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));
-        // Mark pitono as done after writing the metafile
-        onPitonoDone();
+        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");
+            }
+        });
     }
     Promise.resolve(Promise.all([...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
         const sourceFileSplit = sourceFilePath.split("/");
@@ -174,10 +145,12 @@ import(f).then(async (module) => {
             .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 = [
         ["pure", Object.keys(pureEntryPoints)],
         ["node", Object.keys(nodeEntryPoints)],
         ["web", Object.keys(webEntryPoints)],
+        ["python", Object.keys(pythonEntryPoints)],
     ];
     x.forEach(async ([runtime, keys]) => {
         keys.forEach(async (k) => {
@@ -192,45 +165,13 @@ import(f).then(async (module) => {
         [pureEntryPoints, pureEntryPointSidecars, "pure"],
         [webEntryPoints, webEntryPointSidecars, "web"],
         [nodeEntryPoints, nodeEntryPointSidecars, "node"],
+        [pythonEntryPoints, pythonEntryPointSidecars, "python"],
     ].forEach(([eps, eps2, runtime]) => {
         [...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 });
         });
     });
-    await Promise.all([
-        ...[
-            [
-                esbuildImportConfiger,
-                pureEntryPoints,
-                pureEntryPointSidecars,
-                onImportDone,
-            ],
-            [
-                esbuildNodeConfiger,
-                nodeEntryPoints,
-                nodeEntryPointSidecars,
-                onNodeDone,
-            ],
-            [esbuildWebConfiger, webEntryPoints, webEntryPointSidecars, onWebDone],
-        ].map(([configer, entryPoints, sidecars, done]) => {
-            esbuild
-                .context(configer(config, [...Object.keys(entryPoints), ...Object.keys(sidecars)], testName))
-                .then(async (ctx) => {
-                if (mode === "dev") {
-                    await ctx.watch().then((v) => {
-                        done();
-                    });
-                }
-                else {
-                    ctx.rebuild().then((v) => {
-                        done();
-                    });
-                }
-                return ctx;
-            });
-        }),
-    ]);
     process.stdin.on("keypress", (str, key) => {
         if (key.name === "q") {
             console.log("Testeranto is shutting down gracefully...");

package/dist/module/src/utils/api.js

@@ -1,8 +1,8 @@
 import { getLogFilesForRuntime, STANDARD_LOGS } from "./logFiles";
 export const fetchProjectData = async (projectName) => {
     const [summaryRes, configRes] = await Promise.all([
-        fetch(`reports/${projectName}/summary.json`),
-        fetch("reports/config.json"),
+        fetch(summaryDotJson(projectName)),
+        fetch("/reports/config.json"),
     ]);
     return {
         summary: (await summaryRes.json()),
@@ -23,7 +23,7 @@ export const fetchTestData = async (projectName, filepath, runTime) => {
                 const response = await fetch(`${basePath}/${file}`);
                 if (!response.ok)
                     return null;
-                const content = file.endsWith('.json')
+                const content = file.endsWith(".json")
                     ? await response.json()
                     : await response.text();
                 return { file, content };
@@ -35,7 +35,7 @@ export const fetchTestData = async (projectName, filepath, runTime) => {
         });
         // Wait for all requests and populate logs
         const logResults = await Promise.all(logRequests);
-        logResults.forEach(result => {
+        logResults.forEach((result) => {
             if (result) {
                 logs[result.file] = result.content;
             }
@@ -46,7 +46,7 @@ export const fetchTestData = async (projectName, filepath, runTime) => {
                 try {
                     const response = await fetch(`${basePath}/${file}`);
                     if (response.ok) {
-                        logs[file] = file.endsWith('.json')
+                        logs[file] = file.endsWith(".json")
                             ? await response.json()
                             : await response.text();
                     }
@@ -64,12 +64,12 @@ export const fetchTestData = async (projectName, filepath, runTime) => {
         if (Object.keys(logs).length === 0) {
             return {
                 logs: {},
-                error: "No test logs found. The test may not have run or the report files are missing."
+                error: "No test logs found. The test may not have run or the report files are missing.",
             };
         }
         return {
             logs,
-            error: null
+            error: null,
         };
     }
     catch (err) {
@@ -82,3 +82,6 @@ export const fetchTestData = async (projectName, filepath, runTime) => {
         };
     }
 };
+export const summaryDotJson = (name) => {
+    return `reports/${name}/summary.json`;
+};

package/dist/module/src/utils/gitTest.js

@@ -0,0 +1,23 @@
+import { getFileService } from '../services/FileService';
+export const testGitIntegration = async () => {
+    try {
+        const fileService = getFileService('dev');
+        // Test basic file operations
+        const testContent = '// Test file content\nconsole.log("Hello Git!");';
+        await fileService.writeFile('test-file.ts', testContent);
+        const content = await fileService.readFile('test-file.ts');
+        console.log('File content:', content);
+        const exists = await fileService.exists('test-file.ts');
+        console.log('File exists:', exists);
+        // Test Git operations
+        const changes = await fileService.getChanges();
+        console.log('Changes:', changes);
+        const branch = await fileService.getCurrentBranch();
+        console.log('Current branch:', branch);
+        return { success: true, changes, branch };
+    }
+    catch (error) {
+        console.error('Git integration test failed:', error);
+        return { success: false, error: error instanceof Error ? error.message : 'Unknown error' };
+    }
+};

package/dist/module/src/utils.js

@@ -1,5 +1,16 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 import path from "path";
+export const webEvaluator = (d, webArgz) => {
+    return `
+import('${d}').then(async (x) => {
+  try {
+    return await (await x.default).receiveTestResourceConfig(${webArgz})
+  } catch (e) {
+    console.log("web run failure", e.toString())
+  }
+})
+`;
+};
 export const destinationOfRuntime = (f, r, configs) => {
     return path
         .normalize(`${configs.buildDir}/${r}/${f}`)
@@ -20,7 +31,6 @@ export const promptPather = (entryPoint, platform, projectName) => {
     return path.join("testeranto", "reports", projectName, entryPoint.split(".").slice(0, -1).join("."), platform, `prompt.txt`);
 };
 export const getRunnables = (tests, projectName, payload = {
-    pythonEntryPoints: {},
     nodeEntryPoints: {},
     nodeEntryPointSidecars: {},
     webEntryPoints: {},
@@ -29,12 +39,11 @@ export const getRunnables = (tests, projectName, payload = {
     pureEntryPointSidecars: {},
     golangEntryPoints: {},
     golangEntryPointSidecars: {},
-    pitonoEntryPoints: {},
-    pitonoEntryPointSidecars: {},
+    pythonEntryPoints: {},
+    pythonEntryPointSidecars: {},
 }) => {
     // Ensure all properties are properly initialized
     const initializedPayload = {
-        pythonEntryPoints: payload.pythonEntryPoints || {},
         nodeEntryPoints: payload.nodeEntryPoints || {},
         nodeEntryPointSidecars: payload.nodeEntryPointSidecars || {},
         webEntryPoints: payload.webEntryPoints || {},
@@ -43,8 +52,8 @@ export const getRunnables = (tests, projectName, payload = {
         pureEntryPointSidecars: payload.pureEntryPointSidecars || {},
         golangEntryPoints: payload.golangEntryPoints || {},
         golangEntryPointSidecars: payload.golangEntryPointSidecars || {},
-        pitonoEntryPoints: payload.pitonoEntryPoints || {},
-        pitonoEntryPointSidecars: payload.pitonoEntryPointSidecars || {},
+        pythonEntryPoints: payload.pythonEntryPoints || {},
+        pythonEntryPointSidecars: payload.pythonEntryPointSidecars || {},
     };
     return tests.reduce((pt, cv, cndx, cry) => {
         if (cv[1] === "node") {
@@ -72,9 +81,9 @@ export const getRunnables = (tests, projectName, payload = {
             // For Go files, we'll use the original path since they're not compiled to JS
             pt.golangEntryPoints[cv[0]] = path.resolve(cv[0]);
         }
-        else if (cv[1] === "pitono") {
-            // For pitono files, use the original Python file path
-            pt.pitonoEntryPoints[cv[0]] = path.resolve(cv[0]);
+        else if (cv[1] === "python") {
+            // For python files, use the original Python file path
+            pt.pythonEntryPoints[cv[0]] = path.resolve(cv[0]);
         }
         //////////////////////////////////////////////////////////
         cv[3]
@@ -111,10 +120,10 @@ export const getRunnables = (tests, projectName, payload = {
             pt.golangEntryPointSidecars[`${t[0]}`] = path.resolve(t[0]);
         });
         cv[3]
-            .filter((t) => t[1] === "pitono")
+            .filter((t) => t[1] === "python")
             .forEach((t) => {
-            // For pitono sidecars, use the original Python file path
-            pt.pitonoEntryPointSidecars[`${t[0]}`] = path.resolve(t[0]);
+            // For python sidecars, use the original Python file path
+            pt.pythonEntryPointSidecars[`${t[0]}`] = path.resolve(t[0]);
         });
         return pt;
     }, initializedPayload);

package/dist/module/testeranto.config.js

@@ -1,6 +1,10 @@
 import { sassPlugin } from "esbuild-sass-plugin";
 // TODO- this config file is horrible. I need to redo how config files are handled.
 const config = {
+    // Add GitHub OAuth configuration
+    // githubOAuth: {
+    //   clientId: "Ov23li3JEcsRqW0zWCG7",
+    // },
     projects: {
         // staticSite: {
         //   tests: [["src/ReportServer.test.ts/index.ts", "node", { ports: 1 }, []]],
@@ -21,9 +25,26 @@ const config = {
             tests: [
                 ["example/test_example.py", "python", { ports: 0 }, []],
                 ["src/golingvu/base_suite_test.go", "golang", { ports: 0 }, []],
+                ["src/lib/TipoSkripto.test/TipoSkripto.ts", "node", { ports: 0 }, []],
                 ["src/lib/BaseSuite.test/node.test.ts", "node", { ports: 0 }, []],
                 ["src/lib/BaseSuite.test/pure.test.ts", "pure", { ports: 0 }, []],
                 ["src/lib/BaseSuite.test/web.test.ts", "web", { ports: 0 }, []],
+                ["src/Pure.test.ts", "pure", { ports: 0 }, []],
+                ["src/lib/pmProxy.test/index.ts", "node", { ports: 0 }, []],
+                [
+                    "src/components/pure/ProjectPageView.test/index.tsx",
+                    "web",
+                    { ports: 0 },
+                    [],
+                ],
+                [
+                    "src/components/pure/FeaturesReporterView.test/index.tsx",
+                    "web",
+                    { ports: 0 },
+                    [],
+                ],
+                //////////////////////////////////////////////////////////////////////////////////////////////////////////
+                // broken
                 // [
                 //   "src/components/pure/TestPageView.test/index.tsx",
                 //   "web",
@@ -31,23 +52,6 @@ const config = {
                 //   [],
                 // ],
                 // [
-                //   "src/components/pure/ProjectPageView.test/index.tsx",
-                //   "web",
-                //   { ports: 0 },
-                //   [],
-                // ],
-                // ["src/Pure.test.ts", "pure", { ports: 0 }, []],
-                // ["src/lib/pmProxy.test/index.ts", "node", { ports: 0 }, []],
-                // ["src/lib/TipoSkripto.test/TipoSkripto.ts", "node", { ports: 0 }, []],
-                // [
-                //   "src/components/pure/FeaturesReporterView.test/index.tsx",
-                //   "web",
-                //   { ports: 0 },
-                //   [],
-                // ],
-                //////////////////////////////////////////////////////////////////////////////////////////////////////////
-                // broken
-                // [
                 //   "src/components/pure/ModalContent.test/index.tsx",
                 //   "web",
                 //   { ports: 0 },