testeranto 0.200.1 → 0.203.0

package/src/pitono/PM/python.py

@@ -0,0 +1,165 @@
+import socket
+import json
+import random
+import struct
+from typing import Any, List, Dict, Optional
+from ..types import ITTestResourceConfiguration
+
+class PM_Python:
+    def __init__(self, t: ITTestResourceConfiguration, ipc_file: str):
+        self.test_resource_configuration = t
+        self.client = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
+        try:
+            self.client.connect(ipc_file)
+            # Set a timeout to prevent blocking forever
+            self.client.settimeout(30.0)
+        except Exception as e:
+            raise e
+    
+    def start(self) -> None:
+        raise Exception("DEPRECATED")
+    
+    def stop(self) -> None:
+        try:
+            self.client.close()
+        except:
+            pass
+    
+    def send(self, command: str, *args) -> Any:
+        # Generate a unique key for this request
+        key = str(random.random())
+        # Create the message array with command, arguments, and key
+        message = [command]
+        message.extend(args)
+        message.append(key)
+        
+        # Convert to JSON and encode
+        data = json.dumps(message).encode('utf-8')
+        
+        # Send the length of the data first (as 4-byte big-endian)
+        length = struct.pack('>I', len(data))
+        self.client.sendall(length)
+        # Send the actual data
+        self.client.sendall(data)
+        
+        # Wait for response
+        # First read the length
+        length_data = self._recv_all(4)
+        if not length_data:
+            raise Exception("No response length received")
+        response_length = struct.unpack('>I', length_data)[0]
+        
+        # Read the response data
+        response_data = self._recv_all(response_length)
+        if not response_data:
+            raise Exception("No response data received")
+        
+        # Parse the response
+        try:
+            response = json.loads(response_data.decode('utf-8'))
+            # Check if the response key matches our request key
+            if response.get('key') == key:
+                return response.get('payload')
+            else:
+                raise Exception(f"Key mismatch in response. Expected: {key}, Got: {response.get('key')}")
+        except json.JSONDecodeError:
+            raise Exception("Invalid JSON response")
+    
+    def _recv_all(self, length: int) -> bytes:
+        data = b''
+        while len(data) < length:
+            chunk = self.client.recv(length - len(data))
+            if not chunk:
+                break
+            data += chunk
+        return data
+    
+    async def pages(self) -> List[str]:
+        return self.send("pages")
+    
+    def wait_for_selector(self, p: str, s: str) -> Any:
+        return self.send("waitForSelector", p, s)
+    
+    def close_page(self, p: Any) -> Any:
+        return self.send("closePage", p)
+    
+    def goto(self, page: str, url: str) -> Any:
+        return self.send("goto", page, url)
+    
+    async def new_page(self) -> str:
+        return self.send("newPage")
+    
+    def __call__(self, selector: str, page: str) -> Any:
+        return self.send("$", selector, page)
+    
+    def is_disabled(self, selector: str) -> bool:
+        return self.send("isDisabled", selector)
+    
+    def get_attribute(self, selector: str, attribute: str, p: str) -> Any:
+        return self.send("getAttribute", selector, attribute, p)
+    
+    def get_inner_html(self, selector: str, p: str) -> Any:
+        return self.send("getInnerHtml", selector, p)
+    
+    def focus_on(self, selector: str) -> Any:
+        return self.send("focusOn", selector)
+    
+    def type_into(self, selector: str) -> Any:
+        return self.send("typeInto", selector)
+    
+    def page(self) -> Optional[str]:
+        return self.send("page")
+    
+    def click(self, selector: str) -> Any:
+        return self.send("click", selector)
+    
+    def screencast(self, opts: Dict, page: str) -> Any:
+        adjusted_opts = dict(opts)
+        if 'path' in adjusted_opts:
+            adjusted_opts['path'] = f"{self.test_resource_configuration.fs}/{opts['path']}"
+        return self.send("screencast", adjusted_opts, page, self.test_resource_configuration.name)
+    
+    def screencast_stop(self, p: str) -> Any:
+        return self.send("screencastStop", p)
+    
+    def custom_screenshot(self, x: List) -> Any:
+        opts = x[0]
+        page = x[1] if len(x) > 1 else None
+        
+        adjusted_opts = dict(opts)
+        if 'path' in adjusted_opts:
+            adjusted_opts['path'] = f"{self.test_resource_configuration.fs}/{opts['path']}"
+        
+        if page:
+            return self.send("customScreenShot", adjusted_opts, self.test_resource_configuration.name, page)
+        else:
+            return self.send("customScreenShot", adjusted_opts, self.test_resource_configuration.name)
+    
+    async def exists_sync(self, dest_folder: str) -> bool:
+        path = f"{self.test_resource_configuration.fs}/{dest_folder}"
+        return self.send("existsSync", path)
+    
+    def mkdir_sync(self) -> Any:
+        path = f"{self.test_resource_configuration.fs}/"
+        return self.send("mkdirSync", path)
+    
+    async def write(self, uid: int, contents: str) -> bool:
+        return self.send("write", uid, contents)
+    
+    def write_file_sync(self, filepath: str, contents: str) -> bool:
+        full_path = f"{self.test_resource_configuration.fs}/{filepath}"
+        try:
+            result = self.send("writeFileSync", full_path, contents, self.test_resource_configuration.name)
+            return result
+        except Exception as e:
+            raise e
+    
+    async def create_write_stream(self, filepath: str) -> str:
+        full_path = f"{self.test_resource_configuration.fs}/{filepath}"
+        return self.send("createWriteStream", full_path, self.test_resource_configuration.name)
+    
+    async def end(self, uid: Any) -> bool:
+        return self.send("end", uid)
+    
+    async def custom_close(self) -> Any:
+        return self.send("customclose", self.test_resource_configuration.fs, self.test_resource_configuration.name)

package/src/pitono/Pitono.py

@@ -0,0 +1,298 @@
+from typing import Any, Callable, Dict, List, Optional
+import json
+import asyncio
+from .types import ITestSpecification, ITestImplementation, ITestAdapter, ITTestResourceRequest
+from .simple_adapter import SimpleTestAdapter
+from .base_suite import BaseSuite
+from .base_given import BaseGiven
+from .base_when import BaseWhen
+from .base_then import BaseThen
+from .PM.python import PM_Python
+
+# Export these for easier imports
+__all__ = [
+    'Pitono', 'set_default_instance', 'main'
+]
+
+import sys
+
+def Pitono(
+    input_val: Any = None,
+    test_specification: ITestSpecification = None,
+    test_implementation: ITestImplementation = None,
+    test_adapter: ITestAdapter = None,
+    test_resource_requirement: ITTestResourceRequest = None,
+    uber_catcher: Callable[[Callable], None] = None,
+    **kwargs
+):
+    # Create a Pitono instance and return it
+    instance = PitonoClass(
+        input_val,
+        test_specification,
+        test_implementation,
+        test_resource_requirement or {},
+        test_adapter,
+        uber_catcher or (lambda x: None)
+    )
+    return instance
+
+# Store the default instance
+_default_instance = None
+
+def set_default_instance(instance):
+    global _default_instance
+    _default_instance = instance
+
+async def main():
+    if len(sys.argv) < 3:
+        print("Usage: python <test_file.py> <partialTestResource> <ipcfile>")
+        sys.exit(-1)
+        
+    partialTestResource = sys.argv[1]
+    ipcfile = sys.argv[2]
+    
+    if _default_instance is None:
+        print("ERROR: No default Pitono instance has been configured")
+        sys.exit(-1)
+        
+    result = await _default_instance.receiveTestResourceConfig(partialTestResource, ipcfile)
+    sys.exit(result.fails)
+
+class PitonoClass:
+    def __init__(
+        self,
+        input_val: Any,
+        test_specification: ITestSpecification,
+        test_implementation: ITestImplementation,
+        test_resource_requirement: ITTestResourceRequest,
+        test_adapter: ITestAdapter,
+        uber_catcher: Callable[[Callable], None]
+    ):
+        self.test_resource_requirement = test_resource_requirement
+        self.artifacts: List[Any] = []
+        self.test_jobs: List[Any] = []
+        self.test_specification = test_specification
+        self.suites_overrides: Dict[str, Any] = {}
+        self.given_overrides: Dict[str, Any] = {}
+        self.when_overrides: Dict[str, Any] = {}
+        self.then_overrides: Dict[str, Any] = {}
+        self.puppet_master: Any = None
+        self.specs: Any = None
+        self.test_implementation = test_implementation
+        self.test_subject = input_val
+        self.test_adapter = test_adapter
+        
+        # Generate specs
+        self.specs = test_specification(
+            self.Suites(),
+            self.Given(),
+            self.When(),
+            self.Then()
+        )
+        
+    def Suites(self):
+        return self.suites_overrides
+    
+    def Given(self):
+        # Return a function that creates the appropriate Given instance
+        def create_given(given_type, features, whens, thens, initial_values=None):
+            if given_type in self.given_overrides:
+                return self.given_overrides[given_type](features, whens, thens, initial_values)
+            else:
+                raise ValueError(f"Given type '{given_type}' not found")
+        
+        # Create a wrapper that provides access to all given types
+        class GivenWrapper:
+            def __getattr__(self, name):
+                def given_func(features, whens, thens, initial_values=None):
+                    return create_given(name, features, whens, thens, initial_values)
+                return given_func
+        
+        return GivenWrapper()
+    
+    def When(self):
+        # Similar approach for When
+        def create_when(when_type, *args):
+            if when_type in self.when_overrides:
+                return self.when_overrides[when_type](*args)
+            else:
+                raise ValueError(f"When type '{when_type}' not found")
+        
+        class WhenWrapper:
+            def __getattr__(self, name):
+                def when_func(*args):
+                    return create_when(name, *args)
+                return when_func
+        
+        return WhenWrapper()
+    
+    def Then(self):
+        # Similar approach for Then
+        def create_then(then_type, *args):
+            if then_type in self.then_overrides:
+                return self.then_overrides[then_type](*args)
+            else:
+                raise ValueError(f"Then type '{then_type}' not found")
+        
+        class ThenWrapper:
+            def __getattr__(self, name):
+                def then_func(*args):
+                    return create_then(name, *args)
+                return then_func
+        
+        return ThenWrapper()
+    
+    def _initialize_classy_implementations(self, test_implementation):
+        # Create classy implementations similar to TypeScript
+        classyGivens = {}
+        for key in test_implementation.givens.keys():
+            def create_given_closure(given_key):
+                def given_func(features, whens, thens, initial_values=None):
+                    return BaseGiven(
+                        given_key,
+                        features,
+                        whens,
+                        thens,
+                        test_implementation.givens[given_key],
+                        initial_values
+                    )
+                return given_func
+            classyGivens[key] = create_given_closure(key)
+        
+        classyWhens = {}
+        for key in test_implementation.whens.keys():
+            def create_when_closure(when_key):
+                def when_func(*args):
+                    # Create a BaseWhen instance
+                    name = f"{when_key}: {args}"
+                    when_cb = test_implementation.whens[when_key](*args)
+                    return BaseWhen(name, when_cb)
+                return when_func
+            classyWhens[key] = create_when_closure(key)
+        
+        classyThens = {}
+        for key in test_implementation.thens.keys():
+            def create_then_closure(then_key):
+                def then_func(*args):
+                    # Create a BaseThen instance
+                    name = f"{then_key}: {args}"
+                    then_cb = test_implementation.thens[then_key](*args)
+                    return BaseThen(name, then_cb)
+                return then_func
+            classyThens[key] = create_then_closure(key)
+        
+        self.given_overrides = classyGivens
+        self.when_overrides = classyWhens
+        self.then_overrides = classyThens
+        
+        # Initialize the classy implementations
+        self._initialize_classy_implementations(test_implementation)
+
+    async def _run_test_job(self, runner, suite, puppet_master):
+        try:
+            # Create a simple t_log function
+            def t_log(*args):
+                print(" ".join(map(str, args)))
+            
+            # Run the suite
+            suite_done = await runner(puppet_master, t_log)
+            fails = suite_done.fails
+            
+            # Get features and artifacts
+            features = []
+            if hasattr(suite_done, 'features') and callable(suite_done.features):
+                features = suite_done.features()
+            elif hasattr(suite_done, 'features'):
+                features = suite_done.features
+            
+            artifacts = []
+            if hasattr(suite_done, 'artifacts'):
+                artifacts = suite_done.artifacts
+            
+            # Create a simple result object
+            class Result:
+                def __init__(self, failed, fails, artifacts, features):
+                    self.failed = failed
+                    self.fails = fails
+                    self.artifacts = artifacts
+                    self.features = features
+            
+            return Result(
+                fails > 0,
+                fails,
+                artifacts,
+                features
+            )
+        except Exception as e:
+            print(f"Error in test job: {e}")
+            
+            class Result:
+                def __init__(self, failed, fails, artifacts, features):
+                    self.failed = failed
+                    self.fails = fails
+                    self.artifacts = artifacts
+                    self.features = features
+            
+            return Result(True, 1, [], [])
+    
+    async def receiveTestResourceConfig(self, partialTestResource: str, ipcfile: str) -> Any:
+        # Parse the test resource configuration
+        test_resource_config = json.loads(partialTestResource)
+        
+        # Create a PM_Python instance
+        pm = PM_Python(test_resource_config, ipcfile)
+        
+        # Run all test jobs
+        total_fails = 0
+        all_features = set()
+        all_artifacts = []
+        
+        # Collect all suite results
+        suite_results = []
+        for job in self.test_jobs:
+            try:
+                result = await job['receiveTestResourceConfig'](pm)
+                total_fails += result.fails
+                # Add features to the set
+                if hasattr(result, 'features'):
+                    for feature in result.features:
+                        all_features.add(feature)
+                if hasattr(result, 'artifacts'):
+                    all_artifacts.extend(result.artifacts)
+                # Get the suite object
+                suite_obj = job['to_obj']()
+                suite_results.append(suite_obj)
+            except Exception as e:
+                print(f"Error running test job: {e}")
+                total_fails += 1
+        
+        # Write the final tests.json
+        try:
+            # Flatten all givens from all suites
+            all_givens = []
+            for suite in suite_results:
+                if 'givens' in suite:
+                    all_givens.extend(suite['givens'])
+            
+            # Prepare tests data matching the TypeScript structure
+            tests_data = {
+                "name": self.specs[0].name if self.specs else "Unnamed Test",
+                "givens": all_givens,
+                "fails": total_fails,
+                "features": list(all_features),
+                "artifacts": all_artifacts
+            }
+            
+            # Write to file
+            tests_json_path = f"{test_resource_config['fs']}/tests.json"
+            with open(tests_json_path, 'w') as f:
+                json.dump(tests_data, f, indent=2)
+                
+        except Exception as e:
+            print(f"Error writing tests.json: {e}")
+        
+        # Return result
+        class Result:
+            def __init__(self, fails):
+                self.fails = fails
+        return Result(total_fails)

package/src/pitono/PitonoTest.py

@@ -0,0 +1,25 @@
+from pitono import Pitono, set_default_instance, main
+import asyncio
+import sys
+
+# Import your test components
+from .Pitono.adapter import testAdapter
+from .MockPitono import MockPitono
+from .Pitono.specification import specification
+from .Pitono.implementation import implementation
+
+# Create the test instance
+test_instance = Pitono(
+    MockPitono,
+    specification,
+    implementation,
+    testAdapter,
+    {"ports": 1}
+)
+
+# Set it as the default instance
+set_default_instance(test_instance)
+
+# Run the main function if this file is executed directly
+if __name__ == "__main__":
+    asyncio.run(main())

package/src/pitono/README.md

@@ -1,3 +1,24 @@
 # Pitono
 
 The python implementation of testeranto.
+
+## Setup
+
+1. Create a virtual environment:
+```bash
+python3 -m venv venv
+```
+
+2. Activate the virtual environment:
+```bash
+source venv/bin/activate
+```
+
+3. Install the package in development mode:
+```bash
+pip install -e .
+```
+
+## Running Tests
+
+Make sure the virtual environment is activated, then run your Python tests normally.

package/src/pitono/__init__.py

@@ -0,0 +1,6 @@
+from .Pitono import Pitono, set_default_instance, main
+
+# Export these for easier imports
+__all__ = [
+    'Pitono', 'set_default_instance', 'main'
+]

package/{pitono → src/pitono}/base_given.py

@@ -12,7 +12,15 @@ class BaseGiven:
         initial_values: Any
     ):
         self.name = name
-        self.features = features or []
+        # Ensure features are always strings
+        self.features = []
+        if features:
+            for feature in features:
+                if isinstance(feature, str):
+                    self.features.append(feature)
+                else:
+                    # Try to convert to string
+                    self.features.append(str(feature))
         self.whens = whens or []
         self.thens = thens or []
         self.given_cb = given_cb
@@ -49,7 +57,8 @@ class BaseGiven:
         initial_values: Any,
         pm: Any
     ) -> Istore:
-        raise NotImplementedError()
+        # Default implementation - can be overridden by subclasses
+        return {"initial": "store"}
     
     async def after_each(
         self,
@@ -75,6 +84,7 @@ class BaseGiven:
         suite_ndx: int
     ) -> Istore:
         self.key = key
+        self.failed = False
         t_log(f"\n {self.key}")
         t_log(f"\n Given: {self.name}")
 
@@ -94,38 +104,50 @@ class BaseGiven:
         except Exception as e:
             self.failed = True
             self.error = e
-            raise e
+            # Don't re-raise to allow processing of other givens
+            return self.store
 
         try:
             # Process whens
             for when_ndx, when_step in enumerate(self.whens):
-                await when_step.test(
-                    self.store,
-                    test_resource_configuration,
-                    t_log,
-                    pm,
-                    f"suite-{suite_ndx}/given-{key}/when/{when_ndx}"
-                )
+                try:
+                    self.store = await when_step.test(
+                        self.store,
+                        test_resource_configuration,
+                        t_log,
+                        pm,
+                        f"suite-{suite_ndx}/given-{key}/when/{when_ndx}"
+                    )
+                except Exception as e:
+                    self.failed = True
+                    self.error = e
+                    # Continue to process thens even if whens fail
             
             # Process thens
             for then_ndx, then_step in enumerate(self.thens):
-                result = await then_step.test(
-                    self.store,
-                    test_resource_configuration,
-                    t_log,
-                    pm,
-                    f"suite-{suite_ndx}/given-{key}/then-{then_ndx}"
-                )
-                tester(result)
+                try:
+                    result = await then_step.test(
+                        self.store,
+                        test_resource_configuration,
+                        t_log,
+                        pm,
+                        f"suite-{suite_ndx}/given-{key}/then-{then_ndx}"
+                    )
+                    # Test the result
+                    if not tester(result):
+                        self.failed = True
+                except Exception as e:
+                    self.failed = True
+                    self.error = e
+                    # Continue processing other thens
         except Exception as e:
             self.error = e
             self.failed = True
-            raise e
         finally:
             try:
                 await self.after_each(self.store, self.key, given_artifactory, pm)
             except Exception as e:
                 self.failed = True
-                raise e
+                # Don't re-raise
 
         return self.store