testeranto 0.199.0 → 0.200.1

package/dist/common/src/{build.js → testeranto.js}

@@ -53,12 +53,14 @@ readline_1.default.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
 const testName = process.argv[2];
-let mode = process.argv[3];
+const mode = process.argv[3];
 if (mode !== "once" && mode !== "dev") {
-    console.error(`The 4th argument should be 'dev' or 'once', not '${mode}'.`);
+    console.error(`The 3rd argument should be 'dev' or 'once', not '${mode}'.`);
     process.exit(-1);
 }
-Promise.resolve(`${process.cwd() + "/" + "testeranto.config.ts"}`).then(s => __importStar(require(s))).then(async (module) => {
+const f = process.cwd() + "/" + "testeranto.config.ts";
+console.log("config file:", f);
+Promise.resolve(`${f}`).then(s => __importStar(require(s))).then(async (module) => {
     const pckge = (await Promise.resolve(`${`${process.cwd()}/package.json`}`).then(s => __importStar(require(s)))).default;
     const bigConfig = module.default;
     const project = bigConfig.projects[testName];
@@ -68,56 +70,31 @@ Promise.resolve(`${process.cwd() + "/" + "testeranto.config.ts"}`).then(s => __i
     }
     fs_1.default.writeFileSync(`${process.cwd()}/testeranto/projects.json`, JSON.stringify(Object.keys(bigConfig.projects), null, 2));
     const rawConfig = bigConfig.projects[testName];
-    const getSecondaryEndpointsPoints = (runtime) => {
-        const meta = (ts, st) => {
-            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 getSideCars = (runtime?: IRunTime): string[] => {
-    //   return Array.from(
-    //     new Set(
-    //       config.tests
-    //         .reduce((mm, t) => {
-    //           mm = mm.concat(t[3]);
-    //           return mm;
-    //         }, [] as ITestTypes[])
-    //         .filter((t) => {
-    //           return t[1] === runtime;
-    //         })
-    //         .map((t) => {
-    //           return t[0];
-    //         })
-    //     )
-    //   );
-    // };
+    if (!rawConfig) {
+        console.error(`Project "${testName}" does not exist in the configuration.`);
+        console.error("Available projects:", Object.keys(bigConfig.projects));
+        process.exit(-1);
+    }
+    if (!rawConfig.tests) {
+        console.error(testName, "appears to have no tests: ", f);
+        console.error(`here is the config:`);
+        console.log(JSON.stringify(rawConfig));
+        process.exit(-1);
+    }
     const config = Object.assign(Object.assign({}, rawConfig), { buildDir: process.cwd() + "/testeranto/bundles/" + testName });
-    console.log(`Press 'q' to shutdown gracefully. Press 'x' to shutdown forcefully.`);
+    console.log(ansi_colors_1.default.inverse("Press 'q' to initiate a graceful shutdown."));
+    console.log(ansi_colors_1.default.inverse("Press 'x' to quit forcefully."));
     process.stdin.on("keypress", (str, key) => {
-        if (key.name === "q") {
-            console.log("Testeranto-Build is shutting down...");
-            mode = "once";
-            onDone();
-        }
-        else if (key.name === "x") {
-            console.log("Testeranto-Build is shutting down forcefully...");
+        if (key.name === "x") {
+            console.log(ansi_colors_1.default.inverse("Shutting down forcefully..."));
             process.exit(-1);
         }
-        else {
-            console.log(`Press 'q' to shutdown gracefully. Press 'x' to shutdown forcefully.`);
-        }
     });
     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, } = (0, utils_1.getRunnables)(config.tests, testName);
     const onNodeDone = () => {
@@ -132,13 +109,35 @@ Promise.resolve(`${process.cwd() + "/" + "testeranto.config.ts"}`).then(s => __i
         importDone = true;
         onDone();
     };
+    const onGolangDone = () => {
+        golangDone = true;
+        onDone();
+    };
+    const onPitonoDone = () => {
+        pitonoDone = true;
+        onDone();
+    };
+    let pm = null;
     const onDone = async () => {
-        if (nodeDone && webDone && importDone) {
+        // 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 Promise.resolve().then(() => __importStar(require("./PM/main")));
+                pm = new PM_Main(config, testName, mode);
+                await pm.start();
+            }
         }
-        if (nodeDone && webDone && importDone && mode === "once") {
+        if (allDone && mode === "once") {
             console.log(ansi_colors_1.default.inverse(`${testName} was built and the builder exited successfully.`));
-            process.exit();
+            // Let PM_Main handle the exit after tests are complete
         }
     };
     fs_1.default.writeFileSync(`${process.cwd()}/testeranto/projects.html`, (0, buildTemplates_1.AppHtml)());
@@ -149,6 +148,55 @@ Promise.resolve(`${process.cwd() + "/" + "testeranto.config.ts"}`).then(s => __i
         }
         fs_1.default.writeFileSync(`testeranto/reports/${projectName}/config.json`, JSON.stringify(config, null, 2));
     });
+    const getSecondaryEndpointsPoints = (runtime) => {
+        const meta = (ts, st) => {
+            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("pitono")].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 hasGolangTests = golangTests.length > 0;
+    if (hasGolangTests) {
+        // Import and use the golang metafile utilities
+        const { generateGolangMetafile, writeGolangMetafile } = await Promise.resolve().then(() => __importStar(require('./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();
+    }
+    // Handle pitono (Python) tests by generating their metafiles
+    const pitonoTests = config.tests.filter(test => test[1] === 'pitono');
+    const hasPitonoTests = pitonoTests.length > 0;
+    if (hasPitonoTests) {
+        // Import and use the pitono metafile utilities
+        const { generatePitonoMetafile } = await Promise.resolve().then(() => __importStar(require('./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_1.default.promises.mkdir(pitonoMetafilePath, { recursive: true });
+        // Write the metafile to the specified path
+        fs_1.default.writeFileSync(`${pitonoMetafilePath}/core.json`, JSON.stringify(metafile, null, 2));
+        // Mark pitono as done after writing the metafile
+        onPitonoDone();
+    }
     Promise.resolve(Promise.all([...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
         const sourceFileSplit = sourceFilePath.split("/");
         const sourceDir = sourceFileSplit.slice(0, -1);
@@ -164,13 +212,6 @@ Promise.resolve(`${process.cwd() + "/" + "testeranto.config.ts"}`).then(s => __i
             .mkdir(path_1.default.dirname(htmlFilePath), { recursive: true })
             .then((x) => fs_1.default.writeFileSync(htmlFilePath, (0, web_html_1.default)(jsfilePath, htmlFilePath, cssFilePath)));
     })));
-    // glob(`${process.cwd()}/testeranto/bundles/${testName}/chunk-*.mjs`, {
-    //   ignore: "node_modules/**",
-    // }).then((chunks) => {
-    //   chunks.forEach((chunk) => {
-    //     fs.unlinkSync(chunk);
-    //   });
-    // });
     const x = [
         ["pure", Object.keys(pureEntryPoints)],
         ["node", Object.keys(nodeEntryPoints)],
@@ -228,4 +269,15 @@ Promise.resolve(`${process.cwd() + "/" + "testeranto.config.ts"}`).then(s => __i
             });
         }),
     ]);
+    process.stdin.on("keypress", (str, key) => {
+        if (key.name === "q") {
+            console.log("Testeranto is shutting down gracefully...");
+            if (pm) {
+                pm.stop();
+            }
+            else {
+                process.exit();
+            }
+        }
+    });
 });

package/dist/common/src/utils/golingvuMetafile.js

@@ -0,0 +1,116 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateGolangMetafile = generateGolangMetafile;
+exports.writeGolangMetafile = writeGolangMetafile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+async function generateGolangMetafile(testName, entryPoints) {
+    const outputs = {};
+    // Process each Go entry point
+    for (const entryPoint of entryPoints) {
+        try {
+            // Get the package directory to find all Go files in the same package
+            const entryDir = path_1.default.dirname(entryPoint);
+            // Find all .go files in the same directory
+            const goFiles = fs_1.default.readdirSync(entryDir)
+                .filter(file => file.endsWith('.go'))
+                .map(file => path_1.default.join(entryDir, file));
+            // Create inputs record
+            const inputs = {};
+            let totalBytes = 0;
+            for (const file of goFiles) {
+                try {
+                    const stats = fs_1.default.statSync(file);
+                    inputs[file] = { bytesInOutput: stats.size };
+                    totalBytes += stats.size;
+                }
+                catch (_a) {
+                    inputs[file] = { bytesInOutput: 0 };
+                }
+            }
+            // Add the entry point itself if not already included
+            if (!inputs[entryPoint]) {
+                try {
+                    const entryStats = fs_1.default.statSync(entryPoint);
+                    inputs[entryPoint] = { bytesInOutput: entryStats.size };
+                    totalBytes += entryStats.size;
+                }
+                catch (_b) {
+                    inputs[entryPoint] = { bytesInOutput: 0 };
+                }
+            }
+            // The output path should match the Node.js structure - use a path in testeranto/bundles
+            // For Go, we don't have actual bundled outputs, so we'll use a placeholder
+            const outputPath = `testeranto/bundles/golang/${testName}/${entryPoint}`;
+            outputs[outputPath] = {
+                entryPoint: entryPoint, // Use the source file path, not the bundle path
+                inputs,
+                bytes: totalBytes
+            };
+        }
+        catch (error) {
+            console.error(`Error processing Go entry point ${entryPoint}:`, error);
+        }
+    }
+    // Create inputs record for the metafile - include all Go files
+    const allInputs = {};
+    // Collect all unique Go files from all entry points
+    const allGoFiles = new Set();
+    for (const entryPoint of entryPoints) {
+        try {
+            const entryDir = path_1.default.dirname(entryPoint);
+            // Find all .go files in the same directory
+            const goFiles = fs_1.default.readdirSync(entryDir)
+                .filter(file => file.endsWith('.go'))
+                .map(file => path_1.default.join(entryDir, file));
+            goFiles.forEach(file => allGoFiles.add(file));
+            // Add the entry point itself
+            allGoFiles.add(entryPoint);
+        }
+        catch (error) {
+            console.error(`Error processing Go entry point ${entryPoint} for source files:`, error);
+        }
+    }
+    // Add all Go files to inputs
+    for (const filePath of Array.from(allGoFiles)) {
+        try {
+            const stats = fs_1.default.statSync(filePath);
+            allInputs[filePath] = {
+                bytes: stats.size,
+                imports: [] // Go files don't have imports like JS
+            };
+        }
+        catch (_c) {
+            allInputs[filePath] = {
+                bytes: 0,
+                imports: []
+            };
+        }
+    }
+    // Reformat outputs to match esbuild structure
+    const esbuildOutputs = {};
+    for (const [outputPath, output] of Object.entries(outputs)) {
+        esbuildOutputs[outputPath] = {
+            bytes: output.bytes,
+            inputs: output.inputs,
+            entryPoint: output.entryPoint
+        };
+    }
+    return {
+        errors: [],
+        warnings: [],
+        metafile: {
+            inputs: allInputs,
+            outputs: esbuildOutputs
+        }
+    };
+}
+function writeGolangMetafile(testName, metafile) {
+    const metafileDir = path_1.default.join(process.cwd(), "testeranto", "metafiles", "golang");
+    fs_1.default.mkdirSync(metafileDir, { recursive: true });
+    const metafilePath = path_1.default.join(metafileDir, `${testName}.json`);
+    fs_1.default.writeFileSync(metafilePath, JSON.stringify(metafile, null, 2));
+}

package/dist/common/src/utils/logFiles.js

@@ -22,7 +22,8 @@ exports.STANDARD_LOGS = {
     LINT_ERRORS: 'lint_errors.txt',
     EXIT: 'exit.log',
     MESSAGE: 'message.txt',
-    PROMPT: 'prompt.txt'
+    PROMPT: 'prompt.txt',
+    BUILD: 'build.json'
 };
 exports.RUNTIME_SPECIFIC_LOGS = {
     node: {

package/dist/common/src/utils/pitonoMetafile.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePitonoMetafile = generatePitonoMetafile;
+exports.writePitonoMetafile = writePitonoMetafile;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+async function generatePitonoMetafile(testName, entryPoints) {
+    return {
+        testName,
+        entryPoints,
+        timestamp: Date.now()
+    };
+}
+function writePitonoMetafile(testName, metafile) {
+    const metafilePath = path_1.default.join(process.cwd(), 'testeranto', 'pitono', testName, 'metafile.json');
+    const metafileDir = path_1.default.dirname(metafilePath);
+    // Ensure directory exists
+    if (!fs_1.default.existsSync(metafileDir)) {
+        fs_1.default.mkdirSync(metafileDir, { recursive: true });
+    }
+    // Write the metafile
+    fs_1.default.writeFileSync(metafilePath, JSON.stringify(metafile, null, 2));
+    console.log(`Pitono metafile written to: ${metafilePath}`);
+    // Generate core.json using the Python script
+    try {
+        // First try using the installed command
+        const command = `pitono-core-generator ${testName} ${metafile.entryPoints.join(' ')}`;
+        (0, child_process_1.execSync)(command, { stdio: 'inherit' });
+        console.log(`Pitono core.json generated successfully for ${testName}`);
+    }
+    catch (error) {
+        console.error(`Failed to generate Pitono core.json with installed command: ${error}`);
+        // Fallback to direct Python execution
+        try {
+            const pythonCommand = `python ${process.cwd()}/pitono/core_generator.py ${testName} ${metafile.entryPoints.join(' ')}`;
+            (0, child_process_1.execSync)(pythonCommand, { stdio: 'inherit' });
+            console.log(`Pitono core.json generated successfully using direct Python execution`);
+        }
+        catch (fallbackError) {
+            console.error(`Direct Python execution also failed: ${fallbackError}`);
+            // Last resort: create the core.json manually
+            try {
+                const coreData = {
+                    testName: testName,
+                    entryPoints: metafile.entryPoints,
+                    outputs: {},
+                    metafile: {
+                        inputs: {},
+                        outputs: {}
+                    },
+                    timestamp: Date.now(),
+                    runtime: "pitono"
+                };
+                const coreFilePath = path_1.default.join(process.cwd(), 'testeranto', 'pitono', testName, 'core.json');
+                fs_1.default.writeFileSync(coreFilePath, JSON.stringify(coreData, null, 2));
+                console.log(`Pitono core.json created manually as fallback`);
+            }
+            catch (manualError) {
+                console.error(`Even manual creation failed: ${manualError}`);
+            }
+        }
+    }
+}

package/dist/common/src/utils.js

@@ -31,13 +31,32 @@ const promptPather = (entryPoint, platform, projectName) => {
 };
 exports.promptPather = promptPather;
 const getRunnables = (tests, projectName, payload = {
+    pythonEntryPoints: {},
     nodeEntryPoints: {},
     nodeEntryPointSidecars: {},
     webEntryPoints: {},
     webEntryPointSidecars: {},
     pureEntryPoints: {},
     pureEntryPointSidecars: {},
+    golangEntryPoints: {},
+    golangEntryPointSidecars: {},
+    pitonoEntryPoints: {},
+    pitonoEntryPointSidecars: {},
 }) => {
+    // Ensure all properties are properly initialized
+    const initializedPayload = {
+        pythonEntryPoints: payload.pythonEntryPoints || {},
+        nodeEntryPoints: payload.nodeEntryPoints || {},
+        nodeEntryPointSidecars: payload.nodeEntryPointSidecars || {},
+        webEntryPoints: payload.webEntryPoints || {},
+        webEntryPointSidecars: payload.webEntryPointSidecars || {},
+        pureEntryPoints: payload.pureEntryPoints || {},
+        pureEntryPointSidecars: payload.pureEntryPointSidecars || {},
+        golangEntryPoints: payload.golangEntryPoints || {},
+        golangEntryPointSidecars: payload.golangEntryPointSidecars || {},
+        pitonoEntryPoints: payload.pitonoEntryPoints || {},
+        pitonoEntryPointSidecars: payload.pitonoEntryPointSidecars || {},
+    };
     return tests.reduce((pt, cv, cndx, cry) => {
         if (cv[1] === "node") {
             pt.nodeEntryPoints[cv[0]] = path_1.default.resolve(`./testeranto/bundles/node/${projectName}/${cv[0]
@@ -60,6 +79,14 @@ const getRunnables = (tests, projectName, payload = {
                 .concat("mjs")
                 .join(".")}`);
         }
+        else if (cv[1] === "golang") {
+            // For Go files, we'll use the original path since they're not compiled to JS
+            pt.golangEntryPoints[cv[0]] = path_1.default.resolve(cv[0]);
+        }
+        else if (cv[1] === "pitono") {
+            // For pitono files, use the original Python file path
+            pt.pitonoEntryPoints[cv[0]] = path_1.default.resolve(cv[0]);
+        }
         //////////////////////////////////////////////////////////
         cv[3]
             .filter((t) => t[1] === "node")
@@ -88,7 +115,19 @@ const getRunnables = (tests, projectName, payload = {
                 .concat("mjs")
                 .join(".")}`);
         });
+        cv[3]
+            .filter((t) => t[1] === "golang")
+            .forEach((t) => {
+            // For Go sidecars, use the original path
+            pt.golangEntryPointSidecars[`${t[0]}`] = path_1.default.resolve(t[0]);
+        });
+        cv[3]
+            .filter((t) => t[1] === "pitono")
+            .forEach((t) => {
+            // For pitono sidecars, use the original Python file path
+            pt.pitonoEntryPointSidecars[`${t[0]}`] = path_1.default.resolve(t[0]);
+        });
         return pt;
-    }, payload);
+    }, initializedPayload);
 };
 exports.getRunnables = getRunnables;

package/dist/common/testeranto.config.js

@@ -21,30 +21,32 @@ const config = {
         // },
         core: {
             tests: [
+                ["example/test_example.py", "python", { ports: 0 }, []],
+                ["src/golingvu/base_suite_test.go", "golang", { 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/components/pure/TestPageView.test/index.tsx",
-                    "web",
-                    { ports: 0 },
-                    [],
-                ],
-                [
-                    "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 },
-                    [],
-                ],
+                // [
+                //   "src/components/pure/TestPageView.test/index.tsx",
+                //   "web",
+                //   { ports: 0 },
+                //   [],
+                // ],
+                // [
+                //   "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
                 // [