testeranto 0.199.0 → 0.200.0

package/pitono/core_generator.py

@@ -0,0 +1,110 @@
+import json
+import os
+import sys
+from typing import Dict, List, Any
+from pathlib import Path
+
+class PitonoCoreGenerator:
+    def __init__(self, test_name: str, entry_points: List[str]):
+        self.test_name = test_name
+        self.entry_points = entry_points
+        self.output_dir = Path("testeranto") / "pitono" / test_name
+        self.output_dir.mkdir(parents=True, exist_ok=True)
+    
+    def generate_core_json(self) -> Dict[str, Any]:
+        """Generate a core.json file similar to esbuild's output"""
+        return {
+            "testName": self.test_name,
+            "entryPoints": self.entry_points,
+            "outputs": self._generate_outputs(),
+            "metafile": {
+                "inputs": self._generate_inputs(),
+                "outputs": self._generate_metafile_outputs()
+            },
+            "timestamp": self._get_timestamp(),
+            "runtime": "pitono"
+        }
+    
+    def _generate_outputs(self) -> Dict[str, Any]:
+        """Generate outputs section similar to esbuild"""
+        outputs = {}
+        for entry_point in self.entry_points:
+            # For pitono, the "output" is the test file itself
+            # Use the absolute path to the original file
+            absolute_path = os.path.abspath(entry_point)
+            outputs[absolute_path] = {
+                "imports": [],
+                "exports": [],
+                "entryPoint": entry_point,
+                "inputs": {
+                    ep: {
+                        "bytes": os.path.getsize(ep) if os.path.exists(ep) else 1024,
+                        "imports": []
+                    }
+                    for ep in self.entry_points
+                },
+                "bytes": os.path.getsize(entry_point) if os.path.exists(entry_point) else 2048
+            }
+        return outputs
+    
+    def _generate_inputs(self) -> Dict[str, Any]:
+        """Generate inputs section for metafile"""
+        inputs = {}
+        for entry_point in self.entry_points:
+            # Use absolute paths
+            absolute_path = os.path.abspath(entry_point)
+            inputs[absolute_path] = {
+                "bytes": os.path.getsize(entry_point) if os.path.exists(entry_point) else 1024,
+                "imports": []
+            }
+        return inputs
+    
+    def _generate_metafile_outputs(self) -> Dict[str, Any]:
+        """Generate outputs section for metafile"""
+        outputs = {}
+        for entry_point in self.entry_points:
+            # Use the absolute path to the original file
+            absolute_path = os.path.abspath(entry_point)
+            outputs[absolute_path] = {
+                "bytes": os.path.getsize(entry_point) if os.path.exists(entry_point) else 2048,
+                "inputs": {
+                    ep: {
+                        "bytesInOutput": os.path.getsize(ep) if os.path.exists(ep) else 1024
+                    }
+                    for ep in self.entry_points
+                },
+                "exports": [],
+                "entryPoint": entry_point
+            }
+        return outputs
+    
+    def _get_timestamp(self) -> int:
+        """Get current timestamp"""
+        import time
+        return int(time.time() * 1000)
+    
+    def write_core_json(self):
+        """Write the core.json file to disk"""
+        core_data = self.generate_core_json()
+        core_file_path = self.output_dir / "core.json"
+        
+        with open(core_file_path, 'w') as f:
+            json.dump(core_data, f, indent=2)
+        
+        print(f"Pitono core.json written to: {core_file_path}")
+        return core_file_path
+
+def main():
+    if len(sys.argv) < 3:
+        print("Usage: pitono-core-generator <test_name> <entry_point1> [entry_point2 ...]")
+        sys.exit(1)
+    
+    test_name = sys.argv[1]
+    # Convert entry points to absolute paths
+    entry_points = [os.path.abspath(ep) for ep in sys.argv[2:]]
+    
+    generator = PitonoCoreGenerator(test_name, entry_points)
+    generator.write_core_json()
+
+if __name__ == "__main__":
+    main()

package/pitono/pitono.egg-info/PKG-INFO

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: pitono
+Version: 0.1.0
+Summary: Python implementation of Testeranto
+Author: Testeranto Team
+Author-email: 
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Dynamic: requires-python

package/pitono/pitono.egg-info/SOURCES.txt

@@ -0,0 +1,7 @@
+pyproject.toml
+setup.py
+pitono.egg-info/PKG-INFO
+pitono.egg-info/SOURCES.txt
+pitono.egg-info/dependency_links.txt
+pitono.egg-info/entry_points.txt
+pitono.egg-info/top_level.txt

package/pitono/pitono.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

package/pitono/pitono.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pitono-core-generator = core_generator:main

package/pitono/pitono.egg-info/top_level.txt

@@ -0,0 +1 @@
+

package/pitono/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pitono"
+version = "0.1.0"
+description = "Python implementation of Testeranto"
+readme = "README.md"
+requires-python = ">=3.7"
+authors = [
+    { name = "Testeranto Team" }
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+]
+
+[project.scripts]
+pitono-core-generator = "core_generator:main"

package/pitono/setup.py

@@ -0,0 +1,40 @@
+from setuptools import setup, find_packages
+import os
+
+# Get the long description from the README file
+readme_path = os.path.join(os.path.dirname(__file__), 'README.md')
+long_description = ''
+if os.path.exists(readme_path):
+    with open(readme_path, 'r', encoding='utf-8') as f:
+        long_description = f.read()
+
+setup(
+    name="pitono",
+    version="0.1.0",
+    packages=find_packages(where='.'),
+    package_dir={'': '.'},
+    entry_points={
+        'console_scripts': [
+            'pitono-core-generator=core_generator:main',
+        ],
+    },
+    python_requires='>=3.7',
+    install_requires=[
+        # Add any dependencies here
+    ],
+    author="Testeranto Team",
+    author_email="",
+    description="Python implementation of Testeranto",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.7",
+        "Programming Language :: Python :: 3.8",
+        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.10",
+    ],
+)

package/pitono/simple_adapter.py

@@ -0,0 +1,24 @@
+from .types import ITestAdapter, ITTestResourceConfiguration
+
+class SimpleTestAdapter(ITestAdapter):
+    def before_all(self, input_val, tr, pm):
+        return input_val
+    
+    def after_all(self, store, pm):
+        return store
+    
+    def before_each(self, subject, initializer, test_resource, initial_values, pm):
+        return subject
+    
+    def after_each(self, store, key, pm):
+        return store
+    
+    def and_when(self, store, when_cb, test_resource, pm):
+        return store
+    
+    def but_then(self, store, then_cb, test_resource, pm):
+        return store
+    
+    def assert_this(self, t):
+        # Simple implementation - always return True for now
+        return True

package/pitono/types.py

@@ -0,0 +1,78 @@
+from typing import TypeVar, Generic, Callable, Any, Dict, List, Optional
+
+# Type variables for BDD input/output types
+Iinput = TypeVar('Iinput')
+Isubject = TypeVar('Isubject')
+Istore = TypeVar('Istore')
+Iselection = TypeVar('Iselection')
+Then = TypeVar('Then')
+Given = TypeVar('Given')
+
+# Test resource configuration
+class ITTestResourceConfiguration:
+    def __init__(
+        self,
+        name: str,
+        fs: str,
+        ports: List[int],
+        browser_ws_endpoint: Optional[str] = None,
+        timeout: Optional[int] = None,
+        retries: Optional[int] = None,
+        environment: Optional[Dict[str, str]] = None
+    ):
+        self.name = name
+        self.fs = fs
+        self.ports = ports
+        self.browser_ws_endpoint = browser_ws_endpoint
+        self.timeout = timeout
+        self.retries = retries
+        self.environment = environment or {}
+
+# Test adapter interface
+class ITestAdapter:
+    def before_all(self, input_val: Any, tr: ITTestResourceConfiguration, pm: Any) -> Any:
+        raise NotImplementedError()
+    
+    def after_all(self, store: Any, pm: Any) -> Any:
+        raise NotImplementedError()
+    
+    def before_each(self, subject: Any, initializer: Any, test_resource: ITTestResourceConfiguration, 
+                   initial_values: Any, pm: Any) -> Any:
+        raise NotImplementedError()
+    
+    def after_each(self, store: Any, key: str, pm: Any) -> Any:
+        raise NotImplementedError()
+    
+    def and_when(self, store: Any, when_cb: Any, test_resource: Any, pm: Any) -> Any:
+        raise NotImplementedError()
+    
+    def but_then(self, store: Any, then_cb: Any, test_resource: Any, pm: Any) -> Any:
+        raise NotImplementedError()
+    
+    def assert_this(self, t: Any) -> bool:
+        raise NotImplementedError()
+
+# Test specification function type
+ITestSpecification = Callable[[Any, Any, Any, Any], Any]
+
+# Test implementation structure
+class ITestImplementation:
+    def __init__(self, suites: Dict[str, Any], givens: Dict[str, Any], 
+                 whens: Dict[str, Any], thens: Dict[str, Any]):
+        self.suites = suites
+        self.givens = givens
+        self.whens = whens
+        self.thens = thens
+
+# Test resource request
+class ITTestResourceRequest:
+    def __init__(self, ports: int):
+        self.ports = ports
+
+# Final results
+class IFinalResults:
+    def __init__(self, failed: bool, fails: int, artifacts: List[Any], features: List[str]):
+        self.failed = failed
+        self.fails = fails
+        self.artifacts = artifacts
+        self.features = features

package/sampleMetafile.json

@@ -0,0 +1,56 @@
+{
+  "errors": [],
+  "warnings": [],
+  "metafile": {
+    "outputs": {
+      "testeranto/bundles/node/core/src/lib/BaseSuite.test/node.test.mjs": {
+        "entryPoint": "src/lib/BaseSuite.test/node.test.ts",
+        "inputs": {
+          "dist/cjs-shim.js": {
+            "bytesInOutput": 167
+          },
+          "src/lib/index.ts": {
+            "bytesInOutput": 672
+          },
+          "src/PM/node.ts": {
+            "bytesInOutput": 5315
+          },
+          "src/PM/index.ts": {
+            "bytesInOutput": 20
+          },
+          "src/lib/pmProxy.ts": {
+            "bytesInOutput": 6590
+          },
+          "src/lib/BaseGiven.ts": {
+            "bytesInOutput": 2911
+          },
+          "src/lib/BaseWhen.ts": {
+            "bytesInOutput": 1127
+          },
+          "src/lib/BaseThen.ts": {
+            "bytesInOutput": 1581
+          },
+          "src/lib/BaseSuite.ts": {
+            "bytesInOutput": 2451
+          },
+          "src/lib/Tiposkripto.ts": {
+            "bytesInOutput": 5299
+          },
+          "src/Node.ts": {
+            "bytesInOutput": 1203
+          },
+          "src/lib/BaseSuite.test/mock.ts": {
+            "bytesInOutput": 1481
+          },
+          "src/lib/BaseSuite.test/test.ts": {
+            "bytesInOutput": 7643
+          },
+          "src/lib/BaseSuite.test/node.test.ts": {
+            "bytesInOutput": 103
+          }
+        },
+        "bytes": 37067
+      }
+    }
+  }
+}

package/src/PM/main.ts

@@ -83,6 +83,12 @@ function runtimeLogs(
       return {
         exit: fs.createWriteStream(`${safeDest}/exit.log`),
       };
+    } else if (runtime === "pitono") {
+      return {
+        stdout: fs.createWriteStream(`${safeDest}/stdout.log`),
+        stderr: fs.createWriteStream(`${safeDest}/stderr.log`),
+        exit: fs.createWriteStream(`${safeDest}/exit.log`),
+      };
     } else {
       throw `unknown runtime: ${runtime}`;
     }
@@ -239,6 +245,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
   webMetafileWatcher: fs.FSWatcher;
   nodeMetafileWatcher: fs.FSWatcher;
   importMetafileWatcher: fs.FSWatcher;
+  pitonoMetafileWatcher: fs.FSWatcher;
   pureSidecars: Record<number, Sidecar>;
   nodeSidecars: Record<number, ChildProcess>;
   webSidecars: Record<number, Page>;
@@ -641,7 +648,7 @@ export class PM_Main extends PM_WithEslintAndTsc {
       );
     }
 
-    const { nodeEntryPoints, webEntryPoints, pureEntryPoints } =
+    const { nodeEntryPoints, webEntryPoints, pureEntryPoints, pitonoEntryPoints } =
       this.getRunnables(this.configs.tests, this.name);
 
     [
@@ -669,6 +676,14 @@ export class PM_Main extends PM_WithEslintAndTsc {
           this.importMetafileWatcher = w;
         },
       ],
+      [
+        pitonoEntryPoints,
+        this.launchPitono,
+        "pitono",
+        (w) => {
+          this.pitonoMetafileWatcher = w;
+        },
+      ],
     ].forEach(
       async ([eps, launcher, runtime, watcher]: [
         Record<string, string>,
@@ -676,9 +691,22 @@ export class PM_Main extends PM_WithEslintAndTsc {
         IRunTime,
         (f: fs.FSWatcher) => void
       ]) => {
-        const metafile = `./testeranto/metafiles/${runtime}/${this.name}.json`;
+        let metafile: string;
+        if (runtime === "pitono") {
+          metafile = `./testeranto/metafiles/python/core.json`;
+          // Ensure the directory exists before trying to watch
+          const metafileDir = path.dirname(metafile);
+          if (!fs.existsSync(metafileDir)) {
+            fs.mkdirSync(metafileDir, { recursive: true });
+          }
+        } else {
+          metafile = `./testeranto/metafiles/${runtime}/${this.name}.json`;
+        }
 
-        await pollForFile(metafile);
+        // Only poll for file if it's not a pitono runtime
+        if (runtime !== "pitono") {
+          await pollForFile(metafile);
+        }
 
         Object.entries(eps).forEach(
           async ([inputFile, outputFile]: [string, string]) => {
@@ -707,14 +735,45 @@ export class PM_Main extends PM_WithEslintAndTsc {
 
         this.metafileOutputs(runtime);
 
-        watcher(
-          watch(metafile, async (e, filename) => {
-            console.log(
-              ansiC.yellow(ansiC.inverse(`< ${e} ${filename} (${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.existsSync(metafile)) {
+              console.log(
+                ansiC.green(ansiC.inverse(`Pitono metafile found: ${metafile}`))
+              );
+              // Set up the watcher once the file exists
+              watcher(
+                watch(metafile, async (e, filename) => {
+                  console.log(
+                    ansiC.yellow(ansiC.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.existsSync(metafile)) {
+            watcher(
+              watch(metafile, async (e, filename) => {
+                console.log(
+                  ansiC.yellow(ansiC.inverse(`< ${e} ${filename} (${runtime})`))
+                );
+                this.metafileOutputs(runtime);
+              })
             );
-            this.metafileOutputs(runtime);
-          })
-        );
+          }
+        }
       }
     );
 
@@ -760,6 +819,9 @@ export class PM_Main extends PM_WithEslintAndTsc {
     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());
@@ -799,13 +861,44 @@ export class PM_Main extends PM_WithEslintAndTsc {
   };
 
   async metafileOutputs(platform: IRunTime) {
-    const metafile = JSON.parse(
-      fs
-        .readFileSync(`./testeranto/metafiles/${platform}/${this.name}.json`)
-        .toString()
-    ).metafile;
-
-    if (!metafile) return;
+    let metafilePath: string;
+    if (platform === "pitono") {
+      metafilePath = `./testeranto/metafiles/python/core.json`;
+    } else {
+      metafilePath = `./testeranto/metafiles/${platform}/${this.name}.json`;
+    }
+    
+    // Check if the file exists
+    if (!fs.existsSync(metafilePath)) {
+      if (platform === "pitono") {
+        console.log(
+          ansiC.yellow(ansiC.inverse(`Pitono metafile not found yet: ${metafilePath}`))
+        );
+      }
+      return;
+    }
+    
+    let metafile;
+    try {
+      const fileContent = fs.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(
+          ansiC.yellow(ansiC.inverse(`No metafile found in ${metafilePath}`))
+        );
+        return;
+      }
+    } catch (error) {
+      console.error(`Error reading metafile at ${metafilePath}:`, error);
+      return;
+    }
 
     const outputs: IOutputs = metafile.outputs;
 
@@ -1609,6 +1702,42 @@ export class PM_Main extends PM_WithEslintAndTsc {
     // }
   };
 
+  launchPitono = async (src: string, dest: string) => {
+    console.log(ansiC.green(ansiC.inverse(`pitono < ${src}`)));
+    this.bddTestIsRunning(src);
+
+    const reportDest = `testeranto/reports/${this.name}/${src
+      .split(".")
+      .slice(0, -1)
+      .join(".")}/pitono`;
+    if (!fs.existsSync(reportDest)) {
+      fs.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 import('./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(
+        ansiC.red(
+          ansiC.inverse(
+            `${src} errored with: ${error}. Check logs for more info`
+          )
+        )
+      );
+      this.bddTestIsNowDone(src, -1);
+      statusMessagePretty(-1, src, "pitono");
+    }
+  };
+
   launchWeb = async (src: string, dest: string) => {
     console.log(ansiC.green(ansiC.inverse(`web < ${src}`)));
     this.bddTestIsRunning(src);

package/src/PM/pitonoRunner.ts

@@ -0,0 +1,49 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import { ITestconfig } from '../lib';
+
+export class PitonoRunner {
+    constructor(private config: ITestconfig, private testName: string) {}
+    
+    async run(): Promise<void> {
+        const coreJsonPath = path.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.existsSync(coreJsonPath) && (Date.now() - startTime) < maxWaitTime) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        
+        if (!fs.existsSync(coreJsonPath)) {
+            console.error(`Pitono core.json not found at: ${coreJsonPath} after waiting ${maxWaitTime}ms`);
+            return;
+        }
+        
+        try {
+            const coreData = JSON.parse(fs.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.resolve(entryPoint);
+                    // Check if the file exists
+                    if (!fs.existsSync(absolutePath)) {
+                        console.error(`Pitono test file not found: ${absolutePath}`);
+                        continue;
+                    }
+                    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}`);
+        }
+    }
+}

package/src/Types.ts

@@ -177,7 +177,7 @@ export type IPluginFactory = (
   entrypoints?: string[]
 ) => Plugin;
 
-export type IRunTime = `node` | `web` | "pure" | `spawn`;
+export type IRunTime = `node` | `web` | "pure" | `golang` | `python`;
 
 export type ITestTypes = [string, IRunTime, { ports: number }, ITestTypes[]];