testeranto 0.199.0 → 0.200.0

package/bundle.js

@@ -4,8 +4,8 @@ import { sassPlugin } from 'esbuild-sass-plugin'
 await esbuild.build({
   outExtension: { '.js': '.mjs' },
   entryPoints: [
-    'src/build.ts',
-    'src/run.ts',
+    // 'src/build.ts',
+    // 'src/run.ts',
     'src/init-docs.ts',
     'src/ReportServer.ts',
     'src/esbuildConfigs/eslint-formatter-testeranto.ts',

package/cmd/test_runner/main.go

@@ -0,0 +1,65 @@
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"testeranto/src/golingvu"
+)
+
+func main() {
+	fmt.Println("Starting Golingvu test runner...")
+	
+	// Create a simple test implementation
+	testImplementation := golingvu.ITestImplementation{
+		Suites: make(map[string]interface{}),
+		Givens: make(map[string]interface{}),
+		Whens:  make(map[string]interface{}),
+		Thens:  make(map[string]interface{}),
+	}
+	
+	// Create a test specification
+	testSpecification := func(suites, givens, whens, thens interface{}) interface{} {
+		fmt.Println("Test specification called")
+		return nil
+	}
+	
+	// Create a test adapter
+	testAdapter := &golingvu.SimpleTestAdapter{}
+	
+	// Create a test resource requirement
+	testResourceRequirement := golingvu.ITTestResourceRequest{
+		Ports: 0,
+	}
+	
+	// Create uberCatcher
+	uberCatcher := func(f func()) {
+		// Handle panics
+		defer func() {
+			if r := recover(); r != nil {
+				log.Printf("Recovered from panic: %v", r)
+			}
+		}()
+		f()
+	}
+	
+	// Create Golingvu instance
+	gv := golingvu.NewGolingvu(
+		nil,
+		testSpecification,
+		testImplementation,
+		testResourceRequirement,
+		testAdapter,
+		uberCatcher,
+	)
+	
+	fmt.Printf("Golingvu instance created successfully: %v\n", gv != nil)
+	
+	// Try to get specs
+	specs := gv.GetSpecs()
+	fmt.Printf("Specs: %v\n", specs)
+	
+	// Try to get test jobs
+	testJobs := gv.GetTestJobs()
+	fmt.Printf("Number of test jobs: %d\n", len(testJobs))
+}

package/cmd/testeranto/main.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"fmt"
+
+	"testeranto/src/golingvu"
+)
+
+func main() {
+	fmt.Println("Golingvu Implementation (Testeranto in Go)")
+	
+	// Example usage
+	testSpec := func(suites, givens, whens, thens interface{}) interface{} {
+		// Implement your test specification logic here
+		fmt.Println("Generating test specs...")
+		return nil
+	}
+	
+	testImpl := golingvu.ITestImplementation{
+		Suites: make(map[string]interface{}),
+		Givens: make(map[string]interface{}),
+		Whens:  make(map[string]interface{}),
+		Thens:  make(map[string]interface{}),
+	}
+	
+	gv := golingvu.NewGolingvu(
+		nil,
+		testSpec,
+		testImpl,
+		golingvu.DefaultTestResourceRequest,
+		nil,
+		func(f func()) { f() },
+	)
+	
+	fmt.Printf("Golingvu initialized: %v\n", gv)
+	fmt.Printf("Specs: %v\n", gv.GetSpecs())
+}

package/dist/common/src/PM/main.js

@@ -87,6 +87,13 @@ function runtimeLogs(runtime, reportDest) {
                 exit: fs_1.default.createWriteStream(`${safeDest}/exit.log`),
             };
         }
+        else if (runtime === "pitono") {
+            return {
+                stdout: fs_1.default.createWriteStream(`${safeDest}/stdout.log`),
+                stderr: fs_1.default.createWriteStream(`${safeDest}/stderr.log`),
+                exit: fs_1.default.createWriteStream(`${safeDest}/exit.log`),
+            };
+        }
         else {
             throw `unknown runtime: ${runtime}`;
         }
@@ -819,6 +826,32 @@ class PM_Main extends PM_WithEslintAndTsc_js_1.PM_WithEslintAndTsc {
             //   }
             // }
         };
+        this.launchPitono = async (src, dest) => {
+            console.log(ansi_colors_2.default.green(ansi_colors_2.default.inverse(`pitono < ${src}`)));
+            this.bddTestIsRunning(src);
+            const reportDest = `testeranto/reports/${this.name}/${src
+                .split(".")
+                .slice(0, -1)
+                .join(".")}/pitono`;
+            if (!fs_1.default.existsSync(reportDest)) {
+                fs_1.default.mkdirSync(reportDest, { recursive: true });
+            }
+            const logs = createLogStreams(reportDest, "node"); // Use node-style logs for pitono
+            try {
+                // Execute the Python test using the pitono runner
+                const { PitonoRunner } = await Promise.resolve().then(() => __importStar(require('./pitonoRunner')));
+                const runner = new PitonoRunner(this.configs, this.name);
+                await runner.run();
+                this.bddTestIsNowDone(src, 0);
+                statusMessagePretty(0, src, "pitono");
+            }
+            catch (error) {
+                logs.writeExitCode(-1, error);
+                console.log(ansi_colors_2.default.red(ansi_colors_2.default.inverse(`${src} errored with: ${error}. Check logs for more info`)));
+                this.bddTestIsNowDone(src, -1);
+                statusMessagePretty(-1, src, "pitono");
+            }
+        };
         this.launchWeb = async (src, dest) => {
             console.log(ansi_colors_2.default.green(ansi_colors_2.default.inverse(`web < ${src}`)));
             this.bddTestIsRunning(src);
@@ -1391,7 +1424,7 @@ import('${d}').then(async (x) => {
             console.error(e);
             console.error("could not start chrome via puppeter. Check this path: ", executablePath);
         }
-        const { nodeEntryPoints, webEntryPoints, pureEntryPoints } = this.getRunnables(this.configs.tests, this.name);
+        const { nodeEntryPoints, webEntryPoints, pureEntryPoints, pitonoEntryPoints } = this.getRunnables(this.configs.tests, this.name);
         [
             [
                 nodeEntryPoints,
@@ -1417,9 +1450,31 @@ import('${d}').then(async (x) => {
                     this.importMetafileWatcher = w;
                 },
             ],
+            [
+                pitonoEntryPoints,
+                this.launchPitono,
+                "pitono",
+                (w) => {
+                    this.pitonoMetafileWatcher = w;
+                },
+            ],
         ].forEach(async ([eps, launcher, runtime, watcher]) => {
-            const metafile = `./testeranto/metafiles/${runtime}/${this.name}.json`;
-            await pollForFile(metafile);
+            let metafile;
+            if (runtime === "pitono") {
+                metafile = `./testeranto/metafiles/python/core.json`;
+                // Ensure the directory exists before trying to watch
+                const metafileDir = path_1.default.dirname(metafile);
+                if (!fs_1.default.existsSync(metafileDir)) {
+                    fs_1.default.mkdirSync(metafileDir, { recursive: true });
+                }
+            }
+            else {
+                metafile = `./testeranto/metafiles/${runtime}/${this.name}.json`;
+            }
+            // Only poll for file if it's not a pitono runtime
+            if (runtime !== "pitono") {
+                await pollForFile(metafile);
+            }
             Object.entries(eps).forEach(async ([inputFile, outputFile]) => {
                 // await pollForFile(outputFile);\
                 this.launchers[inputFile] = () => launcher(inputFile, outputFile);
@@ -1440,10 +1495,37 @@ import('${d}').then(async (x) => {
                 }
             });
             this.metafileOutputs(runtime);
-            watcher((0, fs_1.watch)(metafile, async (e, filename) => {
-                console.log(ansi_colors_2.default.yellow(ansi_colors_2.default.inverse(`< ${e} ${filename} (${runtime})`)));
-                this.metafileOutputs(runtime);
-            }));
+            // For pitono, we need to wait for the file to be created
+            if (runtime === "pitono") {
+                // Use polling to wait for the file to exist
+                const checkFileExists = () => {
+                    if (fs_1.default.existsSync(metafile)) {
+                        console.log(ansi_colors_2.default.green(ansi_colors_2.default.inverse(`Pitono metafile found: ${metafile}`)));
+                        // Set up the watcher once the file exists
+                        watcher((0, fs_1.watch)(metafile, async (e, filename) => {
+                            console.log(ansi_colors_2.default.yellow(ansi_colors_2.default.inverse(`< ${e} ${filename} (${runtime})`)));
+                            this.metafileOutputs(runtime);
+                        }));
+                        // Read the metafile immediately
+                        this.metafileOutputs(runtime);
+                    }
+                    else {
+                        // Check again after a delay
+                        setTimeout(checkFileExists, 1000);
+                    }
+                };
+                // Start checking for the file
+                checkFileExists();
+            }
+            else {
+                // For other runtimes, only set up watcher if the file exists
+                if (fs_1.default.existsSync(metafile)) {
+                    watcher((0, fs_1.watch)(metafile, async (e, filename) => {
+                        console.log(ansi_colors_2.default.yellow(ansi_colors_2.default.inverse(`< ${e} ${filename} (${runtime})`)));
+                        this.metafileOutputs(runtime);
+                    }));
+                }
+            }
         });
         // Object.keys(this.configs.externalTests).forEach((et) => {
         //   this.launchExternalTest(et, this.configs.externalTests[et]);
@@ -1485,6 +1567,9 @@ import('${d}').then(async (x) => {
         this.nodeMetafileWatcher.close();
         this.webMetafileWatcher.close();
         this.importMetafileWatcher.close();
+        if (this.pitonoMetafileWatcher) {
+            this.pitonoMetafileWatcher.close();
+        }
         // Close any remaining log streams
         Object.values(this.logStreams || {}).forEach((logs) => logs.closeAll());
         // Close WebSocket server
@@ -1503,11 +1588,41 @@ import('${d}').then(async (x) => {
         this.checkForShutdown();
     }
     async metafileOutputs(platform) {
-        const metafile = JSON.parse(fs_1.default
-            .readFileSync(`./testeranto/metafiles/${platform}/${this.name}.json`)
-            .toString()).metafile;
-        if (!metafile)
+        let metafilePath;
+        if (platform === "pitono") {
+            metafilePath = `./testeranto/metafiles/python/core.json`;
+        }
+        else {
+            metafilePath = `./testeranto/metafiles/${platform}/${this.name}.json`;
+        }
+        // Check if the file exists
+        if (!fs_1.default.existsSync(metafilePath)) {
+            if (platform === "pitono") {
+                console.log(ansi_colors_2.default.yellow(ansi_colors_2.default.inverse(`Pitono metafile not found yet: ${metafilePath}`)));
+            }
+            return;
+        }
+        let metafile;
+        try {
+            const fileContent = fs_1.default.readFileSync(metafilePath).toString();
+            const parsedData = JSON.parse(fileContent);
+            // Handle different metafile structures
+            if (platform === "pitono") {
+                // Pitono metafile might be the entire content or have a different structure
+                metafile = parsedData.metafile || parsedData;
+            }
+            else {
+                metafile = parsedData.metafile;
+            }
+            if (!metafile) {
+                console.log(ansi_colors_2.default.yellow(ansi_colors_2.default.inverse(`No metafile found in ${metafilePath}`)));
+                return;
+            }
+        }
+        catch (error) {
+            console.error(`Error reading metafile at ${metafilePath}:`, error);
             return;
+        }
         const outputs = metafile.outputs;
         Object.keys(outputs).forEach(async (k) => {
             const pattern = `testeranto/bundles/${platform}/${this.name}/${this.configs.src}`;

package/dist/common/src/PM/pitonoRunner.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PitonoRunner = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+class PitonoRunner {
+    constructor(config, testName) {
+        this.config = config;
+        this.testName = testName;
+    }
+    async run() {
+        const coreJsonPath = path_1.default.join(process.cwd(), 'testeranto', 'pitono', this.testName, 'core.json');
+        // Wait for the core.json file to be created with a timeout
+        const maxWaitTime = 10000; // 10 seconds
+        const startTime = Date.now();
+        while (!fs_1.default.existsSync(coreJsonPath) && (Date.now() - startTime) < maxWaitTime) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        if (!fs_1.default.existsSync(coreJsonPath)) {
+            console.error(`Pitono core.json not found at: ${coreJsonPath} after waiting ${maxWaitTime}ms`);
+            return;
+        }
+        try {
+            const coreData = JSON.parse(fs_1.default.readFileSync(coreJsonPath, 'utf-8'));
+            const entryPoints = coreData.entryPoints;
+            for (const entryPoint of entryPoints) {
+                try {
+                    console.log(`Running pitono test: ${entryPoint}`);
+                    // Use python to execute the test file
+                    const absolutePath = path_1.default.resolve(entryPoint);
+                    // Check if the file exists
+                    if (!fs_1.default.existsSync(absolutePath)) {
+                        console.error(`Pitono test file not found: ${absolutePath}`);
+                        continue;
+                    }
+                    (0, child_process_1.execSync)(`python "${absolutePath}"`, { stdio: 'inherit' });
+                    console.log(`Pitono test completed: ${entryPoint}`);
+                }
+                catch (error) {
+                    console.error(`Pitono test failed: ${entryPoint}`, error);
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error reading or parsing core.json: ${error}`);
+        }
+    }
+}
+exports.PitonoRunner = PitonoRunner;