testeranto 0.203.0 → 0.205.0

package/src/pitono/PM/python.py

@@ -7,6 +7,9 @@ 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:

package/src/pitono/Pitono.py

@@ -82,13 +82,65 @@ class PitonoClass:
         self.test_subject = input_val
         self.test_adapter = test_adapter
         
-        # Generate specs
-        self.specs = test_specification(
-            self.Suites(),
-            self.Given(),
-            self.When(),
-            self.Then()
-        )
+        # 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
@@ -102,11 +154,17 @@ class PitonoClass:
                 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()
     
@@ -123,6 +181,11 @@ class PitonoClass:
                 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()
     
@@ -139,6 +202,11 @@ class PitonoClass:
                 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()
     
@@ -164,9 +232,9 @@ class PitonoClass:
             def create_when_closure(when_key):
                 def when_func(*args):
                     # Create a BaseWhen instance
-                    name = f"{when_key}: {args}"
+                    # name = f"{when_key}: {args}"
                     when_cb = test_implementation.whens[when_key](*args)
-                    return BaseWhen(name, when_cb)
+                    return BaseWhen(when_key, when_cb)
                 return when_func
             classyWhens[key] = create_when_closure(key)
         
@@ -175,18 +243,56 @@ class PitonoClass:
             def create_then_closure(then_key):
                 def then_func(*args):
                     # Create a BaseThen instance
-                    name = f"{then_key}: {args}"
+                    # name = f"{then_key}: {args}"
                     then_cb = test_implementation.thens[then_key](*args)
-                    return BaseThen(name, then_cb)
+                    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)
         
-        # Initialize the classy implementations
-        self._initialize_classy_implementations(test_implementation)
+        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:
@@ -211,29 +317,28 @@ class PitonoClass:
             
             # Create a simple result object
             class Result:
-                def __init__(self, failed, fails, artifacts, features):
-                    self.failed = failed
+                def __init__(self, fails, artifacts, features):
                     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}")
+            import traceback
+            traceback.print_exc()
             
             class Result:
-                def __init__(self, failed, fails, artifacts, features):
-                    self.failed = failed
+                def __init__(self, fails, artifacts, features):
                     self.fails = fails
                     self.artifacts = artifacts
                     self.features = features
             
-            return Result(True, 1, [], [])
+            return Result(1, [], [])
     
     async def receiveTestResourceConfig(self, partialTestResource: str, ipcfile: str) -> Any:
         # Parse the test resource configuration
@@ -249,6 +354,35 @@ class PitonoClass:
         
         # 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)
@@ -264,6 +398,8 @@ class PitonoClass:
                 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
@@ -275,24 +411,34 @@ class PitonoClass:
                     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 else "Unnamed Test",
+                "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/base_given.py

@@ -4,14 +4,14 @@ from .types import Isubject, Istore, Iselection, Then, Given
 class BaseGiven:
     def __init__(
         self,
-        name: str,
+        key: str,
         features: List[str],
         whens: List[Any],
         thens: List[Any],
         given_cb: Given,
         initial_values: Any
     ):
-        self.name = name
+        self.key = key
         # Ensure features are always strings
         self.features = []
         if features:
@@ -29,7 +29,6 @@ class BaseGiven:
         self.error: Optional[Exception] = None
         self.failed = False
         self.store: Optional[Istore] = None
-        self.key: Optional[str] = None
     
     def add_artifact(self, path: str) -> None:
         # Normalize path separators
@@ -37,15 +36,42 @@ class BaseGiven:
         self.artifacts.append(normalized_path)
     
     def to_obj(self) -> Dict[str, Any]:
+        # Convert whens and thens to their object representations
+        when_objs = []
+        for w in self.whens:
+            if hasattr(w, 'to_obj'):
+                when_objs.append(w.to_obj())
+            else:
+                # Create a minimal when object
+                when_objs.append({
+                    'name': getattr(w, 'key', 'unknown'),
+                    'status': None,
+                    'error': None,
+                    'artifacts': []
+                })
+        
+        then_objs = []
+        for t in self.thens:
+            if hasattr(t, 'to_obj'):
+                then_objs.append(t.to_obj())
+            else:
+                # Create a minimal then object
+                then_objs.append({
+                    'name': getattr(t, 'key', 'unknown'),
+                    'error': False,
+                    'artifacts': [],
+                    'status': None
+                })
+        
         return {
             'key': self.key,
-            'name': self.name,
-            'whens': [w.to_obj() if hasattr(w, 'to_obj') else {} for w in self.whens],
-            'thens': [t.to_obj() if hasattr(t, 'to_obj') else {} for t in self.thens],
+            'whens': when_objs,
+            'thens': then_objs,
             'error': str(self.error) if self.error else None,
             'failed': self.failed,
             'features': self.features,
-            'artifacts': self.artifacts
+            'artifacts': self.artifacts,
+            'status': not self.failed
         }
     
     async def given_that(
@@ -83,10 +109,9 @@ class BaseGiven:
         pm: Any,
         suite_ndx: int
     ) -> Istore:
-        self.key = key
         self.failed = False
-        t_log(f"\n {self.key}")
-        t_log(f"\n Given: {self.name}")
+        t_log(f"\n {key}")
+        t_log(f"\n Given: {self.key}")
 
         def given_artifactory(f_path: str, value: Any):
             artifactory(f"given-{key}/{f_path}", value)

package/src/pitono/base_suite.py

@@ -32,7 +32,8 @@ class BaseSuite:
             'givens': givens,
             'fails': self.fails,
             'failed': self.failed,
-            'features': self.features()
+            'features': self.features(),
+            'artifacts': self.artifacts
         }
     
     async def setup(

package/src/pitono/base_then.py

@@ -1,8 +1,8 @@
 from typing import Any, Dict, List
 
 class BaseThen:
-    def __init__(self, name: str, then_cb: Any):
-        self.name = name
+    def __init__(self, key: str, then_cb: Any):
+        self.key = key
         self.then_cb = then_cb
         self.error = False
         self.artifacts: List[str] = []
@@ -26,9 +26,10 @@ class BaseThen:
     
     def to_obj(self) -> Dict[str, Any]:
         return {
-            'name': self.name,
+            'name': self.key,
             'error': self.error,
-            'artifacts': self.artifacts
+            'artifacts': self.artifacts,
+            'status': not self.error
         }
     
     async def but_then(

package/src/pitono/base_when.py

@@ -1,8 +1,8 @@
 from typing import Any, Dict, List
 
 class BaseWhen:
-    def __init__(self, name: str, when_cb: Any):
-        self.name = name
+    def __init__(self, key: str, when_cb: Any):
+        self.key = key
         self.when_cb = when_cb
         self.artifacts: List[str] = []
         self.error: Any = None
@@ -26,7 +26,8 @@ class BaseWhen:
     
     def to_obj(self) -> Dict[str, Any]:
         return {
-            'name': self.name,
+            'name': self.key,
+            'status': self.error is None,
             'error': str(self.error) if self.error else None,
             'artifacts': self.artifacts
         }