testeranto 0.202.0 → 0.205.0

package/src/pitono/PM/python.py

@@ -0,0 +1,168 @@
+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):
+
+        print("PM_Python.__init__", ipc_file)
+
+        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,444 @@
+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
+        
+        # Initialize classy implementations
+        self._initialize_classy_implementations(test_implementation)
+        
+        # Generate specs - the specification function may expect 5 arguments
+        # Let's try to call it with the expected number of parameters
+        try:
+            import inspect
+            sig = inspect.signature(test_specification)
+            if len(sig.parameters) == 5:
+                # Add a Check parameter
+                self.specs = test_specification(
+                    self.Suites(),
+                    self.Given(),
+                    self.When(),
+                    self.Then(),
+                    lambda x: x  # Simple Check function
+                )
+            else:
+                # Assume 4 parameters
+                self.specs = test_specification(
+                    self.Suites(),
+                    self.Given(),
+                    self.When(),
+                    self.Then()
+                )
+        except:
+            # Fallback to 4 parameters
+            self.specs = test_specification(
+                self.Suites(),
+                self.Given(),
+                self.When(),
+                self.Then()
+            )
+        
+        # Initialize test jobs
+        self.test_jobs = []
+        # Create test jobs from the specs
+        for i, suite_spec in enumerate(self.specs):
+            # Create a BaseSuite instance
+            suite = BaseSuite(
+                suite_spec['name'],
+                suite_spec['givens']
+            )
+            suite.index = i
+            
+            # Create a runner function
+            async def runner(pm, t_log):
+                return await suite.run(
+                    self.test_subject,
+                    {},  # test_resource_config will be provided later
+                    lambda f_path, value: None,  # Simple artifactory
+                    t_log,
+                    pm
+                )
+            
+            self.test_jobs.append({
+                'receiveTestResourceConfig': lambda pm: self._run_test_job(runner, suite, pm),
+                'to_obj': suite.to_obj
+            })
+        
+    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
+        # Support both attribute access and indexing
+        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
+            
+            def __getitem__(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
+            
+            def __getitem__(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
+            
+            def __getitem__(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(when_key, 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(then_key, then_cb)
+                return then_func
+            classyThens[key] = create_then_closure(key)
+        
+        self.given_overrides = classyGivens
+        self.when_overrides = classyWhens
+        self.then_overrides = classyThens
+    
+    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
+                    when_cb = test_implementation.whens[when_key](*args)
+                    return BaseWhen(when_key, 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
+                    then_cb = test_implementation.thens[then_key](*args)
+                    return BaseThen(then_key, then_cb)
+                return then_func
+            classyThens[key] = create_then_closure(key)
+        
+        self.given_overrides = classyGivens
+        self.when_overrides = classyWhens
+        self.then_overrides = classyThens
+
+    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, fails, artifacts, features):
+                    self.fails = fails
+                    self.artifacts = artifacts
+                    self.features = features
+            
+            return Result(
+                fails,
+                artifacts,
+                features
+            )
+        except Exception as e:
+            print(f"Error in test job: {e}")
+            import traceback
+            traceback.print_exc()
+            
+            class Result:
+                def __init__(self, fails, artifacts, features):
+                    self.fails = fails
+                    self.artifacts = artifacts
+                    self.features = features
+            
+            return Result(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 = []
+        
+        # First, we need to create test jobs from the specs
+        # The specs should contain the test suites to run
+        if not hasattr(self, 'test_jobs') or not self.test_jobs:
+            # Create test jobs from the specs
+            self.test_jobs = []
+            for i, suite_spec in enumerate(self.specs):
+                # Create a BaseSuite instance
+                suite = BaseSuite(
+                    suite_spec['name'],
+                    suite_spec['givens']
+                )
+                suite.index = i
+                
+                # Create a runner function
+                async def runner(pm, t_log):
+                    return await suite.run(
+                        self.test_subject,
+                        test_resource_config,
+                        lambda f_path, value: None,  # Simple artifactory
+                        t_log,
+                        pm
+                    )
+                
+                self.test_jobs.append({
+                    'receiveTestResourceConfig': lambda pm: self._run_test_job(runner, suite, pm),
+                    'to_obj': suite.to_obj
+                })
+        
+        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}")
+                import traceback
+                traceback.print_exc()
+                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
+            # Based on the example tests.json file
+            tests_data = {
+                "name": self.specs[0]['name'] if self.specs and len(self.specs) > 0 and 'name' in self.specs[0] else "Unnamed Test",
+                "givens": all_givens,
+                "fails": total_fails,
+                "failed": total_fails > 0,
+                "features": list(all_features),
+                "artifacts": all_artifacts
+            }
+            
+            # Write to file
+            tests_json_path = f"{test_resource_config['fs']}/tests.json"
+            # Ensure the directory exists
+            import os
+            os.makedirs(os.path.dirname(tests_json_path), exist_ok=True)
+            with open(tests_json_path, 'w') as f:
+                json.dump(tests_data, f, indent=2)
+            print(f"tests.json written to: {tests_json_path}")
+                
+        except Exception as e:
+            print(f"Error writing tests.json: {e}")
+            import traceback
+            traceback.print_exc()
+        
+        # Return result
+        class Result:
+            def __init__(self, fails):
+                self.fails = fails
+                self.features = list(all_features)
+                self.artifacts = all_artifacts
+        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'
+]