testeranto 0.199.0 → 0.200.1

package/docs/index.md

@@ -35,7 +35,7 @@ async <I extends Ibdd_in_any, O extends Ibdd_out, M>(
   input: I["iinput"],
   testSpecification: ITestSpecification<I, O>,
   testImplementation: ITestImplementation<I, O, M>,
-  testAdapter: Partial<ITestInterface<I>>,
+  testAdapter: Partial<ITestAdapter<I>>,
   testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement
 ): Promise<Testeranto<I, O, M>>
 ```
@@ -52,7 +52,7 @@ import Testeranto from "testeranto/src/Node"; // <- import the Node main functio
 
 import { implementation } from "./Rectangle.test.implementation";
 import { specification } from "./Rectangle.test.specification";
-import { interface } from "./Rectangle.test.interface";
+import { adapter } from "./Rectangle.test.adapter";
 
 // Note the type parameters I, O, and M: these will be important later
 export default Testeranto<
@@ -63,7 +63,7 @@ export default Testeranto<
     Rectangle.prototype, // <- the subject of the test.
     specification,
     implementation,
-    interface
+    adapter
 );
 ```
 
@@ -75,7 +75,7 @@ import Testeranto from "testeranto/src/Web"; // <- import the Web main function
 
 import { implementation } from "./Rectangle.test.implementation";
 import { specification } from "./Rectangle.test.specification";
-import { interface } from "./Rectangle.test.interface";
+import { adapter } from "./Rectangle.test.adapter";
 
 // Note the type parameters I, O, and M: these will be important later
 export default Testeranto<
@@ -86,7 +86,7 @@ export default Testeranto<
     Rectangle.prototype, // <- the subject of the test.
     specification,
     implementation,
-    interface
+    adapter
 );
 ```
 
@@ -98,7 +98,7 @@ import Testeranto from "testeranto/src/Pure"; // <- import the Pure main functio
 
 import { implementation } from "./Rectangle.test.implementation";
 import { specification } from "./Rectangle.test.specification";
-import { interface } from "./Rectangle.test.interface";
+import { adapter } from "./Rectangle.test.adapter";
 
 // Note the type parameters I, O, and M: these will be important later
 export default Testeranto<
@@ -109,7 +109,7 @@ export default Testeranto<
     Rectangle.prototype, // <- the subject of the test.
     specification,
     implementation,
-    interface
+    adapter
 );
 ```
 
@@ -230,18 +230,18 @@ export const implementation: ITestImplementation<
 };
 ```
 
-#### The Interface aka ITestInterface
+#### The Adapter aka ITestAdapter
 
-The test interface is code which is NOT business logic. The interface adapts your test subject so that the BDD hooks can be applied. The interface implements the traditional BDD steps "before all", "after all", "before each", "after each", etc
+The test adapter is code which is NOT business logic. The adapter adapts your test subject so that the BDD hooks can be applied. The adapter implements the traditional BDD steps "before all", "after all", "before each", "after each", etc
 
 ```ts
 import {
   Ibdd_in,
-  ITestInterface,
+  ITestAdapter,
 } from "testeranto/src/CoreTypes";
 
 //  Note the type parameter. This is important!
-export const testAdapter: ITestInterface<
+export const testAdapter: ITestAdapter<
   I extends Ibdd_in,
 > = {
   beforeEach: async (subject, i) => {
@@ -358,7 +358,7 @@ import {
   Ibdd_out,
   ITestImplementation,
   ITestSpecification,
-  ITestInterface,
+  ITestAdapter,
 } from "testeranto/src/CoreTypes";
 
 // The test subject
@@ -440,7 +440,7 @@ type M = {
   };
 };
 
-const testAdapter: ITestInterface<
+const testAdapter: ITestAdapter<
   I extends Ibdd_in,
 > = {
   beforeEach: async (subject, i) => {

package/example/test_example.py

@@ -0,0 +1,106 @@
+import asyncio
+from pitono import Pitono, SimpleTestAdapter
+from pitono.types import ITestSpecification, ITestImplementation, ITTestResourceRequest
+from pitono.core_generator import PitonoCoreGenerator
+
+# Define a simple test specification
+def test_specification(suites, givens, whens, thens):
+    return {
+        'suites': suites,
+        'givens': givens,
+        'whens': whens,
+        'thens': thens
+    }
+
+# Create a simple test implementation
+test_implementation = ITestImplementation(
+    suites={},
+    givens={},
+    whens={},
+    thens={}
+)
+
+# Create a test resource requirement
+test_resource_requirement = ITTestResourceRequest(ports=0)
+
+# Create a test adapter
+test_adapter = SimpleTestAdapter()
+
+# Create uber_catcher
+def uber_catcher(func):
+    try:
+        func()
+    except Exception as e:
+        print(f"Error: {e}")
+
+# Create Pitono instance
+pitono = Pitono(
+    input_val=None,
+    test_specification=test_specification,
+    test_implementation=test_implementation,
+    test_resource_requirement=test_resource_requirement,
+    test_adapter=test_adapter,
+    uber_catcher=uber_catcher
+)
+
+print("Pitono initialized successfully!")
+
+# Test the core generator
+def test_core_generator():
+    entry_points = ["example/test1.py", "example/test2.py"]
+    generator = PitonoCoreGenerator("test_suite", entry_points)
+    generator.write_core_json()
+    print("Core generator test completed!")
+
+# Let's test running a simple suite
+async def test_suite():
+    from pitono.base_suite import BaseSuite
+    from pitono.base_given import BaseGiven
+    from pitono.base_when import BaseWhen
+    from pitono.base_then import BaseThen
+    
+    # Create a simple then implementation
+    class SimpleThen(BaseThen):
+        async def but_then(self, store, then_cb, test_resource_configuration, pm):
+            return True
+    
+    # Create a simple when implementation
+    class SimpleWhen(BaseWhen):
+        async def and_when(self, store, when_cb, test_resource, pm):
+            return store
+    
+    # Create a simple given implementation
+    class SimpleGiven(BaseGiven):
+        async def given_that(self, subject, test_resource_configuration, artifactory, given_cb, initial_values, pm):
+            return {"initial": "store"}
+    
+    # Create test instances
+    then = SimpleThen("test then", lambda: True)
+    when = SimpleWhen("test when", lambda: None)
+    given = SimpleGiven("test given", ["test feature"], [when], [then], lambda: None, {})
+    
+    suite = BaseSuite("test suite", {"test_given": given})
+    
+    # Mock functions
+    def artifactory(path, value):
+        print(f"Artifactory: {path} -> {value}")
+    
+    def t_log(*args):
+        print("LOG:", *args)
+    
+    # Run the suite
+    result = await suite.run(
+        None,
+        None,
+        artifactory,
+        t_log,
+        None
+    )
+    print(f"Suite result: {result.to_obj()}")
+
+if __name__ == "__main__":
+    # Test core generator
+    test_core_generator()
+    
+    # Run the test suite
+    asyncio.run(test_suite())

package/go.mod

@@ -0,0 +1,3 @@
+module testeranto
+
+go 1.19

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testeranto",
   "description": "the AI powered BDD test framework for typescript projects",
-  "version": "0.199.0",
+  "version": "0.200.1",
   "engines": {
     "node": "18.18.0"
   },
@@ -129,6 +129,7 @@
     "type-fix": "aider --model deepseek/deepseek-chat --load type-fix.txt",
     "t-build": "tsx src/build.ts",
     "t-run": "tsx src/run.ts",
+    "testeranto": "tsx src/testeranto.ts",
     "t-init": "tsx dist/prebuild/init-docs.mjs",
     "t-report": "tsx dist/prebuild/ReportServer.mjs",
     "compile-docs": "node scripts/compile-docs.js",
@@ -178,7 +179,6 @@
     "@types/fabric": "^5.3.10",
     "@types/file-saver": "^2.0.7",
     "@types/node-static": "^0.7.11",
-    "@types/react-router-dom": "^5.3.3",
     "@types/xmldom": "^0.1.34",
     "@ungap/structured-clone": "^1.3.0",
     "@xterm/addon-fit": "^0.10.0",

package/pitono/__init__.py

@@ -0,0 +1,54 @@
+from typing import Any, List, Dict, Callable
+from .types import ITestSpecification, ITestImplementation, ITestAdapter, ITTestResourceRequest
+from .simple_adapter import SimpleTestAdapter
+
+class Pitono:
+    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.assert_this_func = test_adapter.assert_this
+        
+        # Generate specs
+        self.specs = test_specification(
+            self.suites(),
+            self.given(),
+            self.when(),
+            self.then()
+        )
+    
+    def suites(self) -> Dict[str, Any]:
+        return self.suites_overrides
+    
+    def given(self) -> Dict[str, Any]:
+        return self.given_overrides
+    
+    def when(self) -> Dict[str, Any]:
+        return self.when_overrides
+    
+    def then(self) -> Dict[str, Any]:
+        return self.then_overrides
+    
+    def get_test_jobs(self) -> List[Any]:
+        return self.test_jobs
+    
+    def get_specs(self) -> Any:
+        return self.specs
+    
+    def assert_this(self, t: Any) -> Any:
+        return self.assert_this_func(t)

package/pitono/base_given.py

@@ -0,0 +1,131 @@
+from typing import List, Dict, Any, Callable, Optional
+from .types import Isubject, Istore, Iselection, Then, Given
+
+class BaseGiven:
+    def __init__(
+        self,
+        name: str,
+        features: List[str],
+        whens: List[Any],
+        thens: List[Any],
+        given_cb: Given,
+        initial_values: Any
+    ):
+        self.name = name
+        self.features = features or []
+        self.whens = whens or []
+        self.thens = thens or []
+        self.given_cb = given_cb
+        self.initial_values = initial_values
+        self.artifacts: List[str] = []
+        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
+        normalized_path = path.replace('\\', '/')
+        self.artifacts.append(normalized_path)
+    
+    def to_obj(self) -> Dict[str, Any]:
+        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],
+            'error': str(self.error) if self.error else None,
+            'failed': self.failed,
+            'features': self.features,
+            'artifacts': self.artifacts
+        }
+    
+    async def given_that(
+        self,
+        subject: Isubject,
+        test_resource_configuration,
+        artifactory: Callable[[str, Any], None],
+        given_cb: Given,
+        initial_values: Any,
+        pm: Any
+    ) -> Istore:
+        raise NotImplementedError()
+    
+    async def after_each(
+        self,
+        store: Istore,
+        key: str,
+        artifactory: Callable[[str, Any], None],
+        pm: Any
+    ) -> Istore:
+        return store
+    
+    def uber_catcher(self, e: Exception) -> None:
+        self.error = e
+
+    async def give(
+        self,
+        subject: Isubject,
+        key: str,
+        test_resource_configuration,
+        tester: Callable[[Any], bool],
+        artifactory: Callable[[str, Any], None],
+        t_log: Callable[..., None],
+        pm: Any,
+        suite_ndx: int
+    ) -> Istore:
+        self.key = key
+        t_log(f"\n {self.key}")
+        t_log(f"\n Given: {self.name}")
+
+        def given_artifactory(f_path: str, value: Any):
+            artifactory(f"given-{key}/{f_path}", value)
+
+        try:
+            # Call given_that to set up the initial state
+            self.store = await self.given_that(
+                subject,
+                test_resource_configuration,
+                given_artifactory,
+                self.given_cb,
+                self.initial_values,
+                pm
+            )
+        except Exception as e:
+            self.failed = True
+            self.error = e
+            raise e
+
+        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}"
+                )
+            
+            # 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)
+        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
+
+        return self.store

package/pitono/base_suite.py

@@ -0,0 +1,95 @@
+from typing import Dict, List, Any, Callable
+
+class BaseSuite:
+    def __init__(self, name: str, givens: Dict[str, Any]):
+        self.name = name
+        self.givens = givens
+        self.store: Any = None
+        self.test_resource_configuration: Any = None
+        self.index: int = 0
+        self.failed = False
+        self.fails = 0
+        self.artifacts: List[str] = []
+    
+    def add_artifact(self, path: str) -> None:
+        normalized_path = path.replace('\\', '/')
+        self.artifacts.append(normalized_path)
+    
+    def features(self) -> List[str]:
+        features = []
+        seen = set()
+        for given in self.givens.values():
+            for feature in given.features:
+                if feature not in seen:
+                    features.append(feature)
+                    seen.add(feature)
+        return features
+    
+    def to_obj(self) -> Dict[str, Any]:
+        givens = [given.to_obj() for given in self.givens.values()]
+        return {
+            'name': self.name,
+            'givens': givens,
+            'fails': self.fails,
+            'failed': self.failed,
+            'features': self.features()
+        }
+    
+    async def setup(
+        self,
+        s: Any,
+        artifactory: Callable[[str, Any], None],
+        tr: Any,
+        pm: Any
+    ) -> Any:
+        return s
+    
+    def assert_that(self, t: Any) -> bool:
+        return bool(t)
+    
+    def after_all(self, store: Any, artifactory: Callable[[str, Any], None], pm: Any) -> Any:
+        return store
+    
+    async def run(
+        self,
+        input_val: Any,
+        test_resource_configuration,
+        artifactory: Callable[[str, Any], None],
+        t_log: Callable[..., None],
+        pm: Any
+    ) -> 'BaseSuite':
+        self.test_resource_configuration = test_resource_configuration
+        
+        def suite_artifactory(f_path: str, value: Any):
+            artifactory(f'suite-{self.index}-{self.name}/{f_path}', value)
+        
+        subject = await self.setup(
+            input_val,
+            suite_artifactory,
+            test_resource_configuration,
+            pm
+        )
+        
+        for g_key, g in self.givens.items():
+            try:
+                self.store = await g.give(
+                    subject,
+                    g_key,
+                    test_resource_configuration,
+                    self.assert_that,
+                    suite_artifactory,
+                    t_log,
+                    pm,
+                    self.index
+                )
+            except Exception as e:
+                self.failed = True
+                self.fails += 1
+                raise e
+        
+        try:
+            self.after_all(self.store, artifactory, pm)
+        except Exception as e:
+            print(f"Error in after_all: {e}")
+        
+        return self

package/pitono/base_then.py

@@ -0,0 +1,50 @@
+from typing import Any, Dict, List
+
+class BaseThen:
+    def __init__(self, name: str, then_cb: Any):
+        self.name = name
+        self.then_cb = then_cb
+        self.error = False
+        self.artifacts: List[str] = []
+    
+    def add_artifact(self, path: str) -> None:
+        normalized_path = path.replace('\\', '/')
+        self.artifacts.append(normalized_path)
+    
+    def to_obj(self) -> Dict[str, Any]:
+        return {
+            'name': self.name,
+            'error': self.error,
+            'artifacts': self.artifacts
+        }
+    
+    async def but_then(
+        self,
+        store: Any,
+        then_cb: Any,
+        test_resource_configuration,
+        pm: Any
+    ) -> Any:
+        raise NotImplementedError()
+    
+    async def test(
+        self,
+        store: Any,
+        test_resource_configuration,
+        t_log: Any,
+        pm: Any,
+        filepath: str
+    ) -> Any:
+        try:
+            add_artifact = self.add_artifact
+            # Simple implementation for now
+            result = await self.but_then(
+                store,
+                self.then_cb,
+                test_resource_configuration,
+                pm
+            )
+            return result
+        except Exception as e:
+            self.error = True
+            raise e

package/pitono/base_when.py

@@ -0,0 +1,52 @@
+from typing import Any, Dict, List
+
+class BaseWhen:
+    def __init__(self, name: str, when_cb: Any):
+        self.name = name
+        self.when_cb = when_cb
+        self.artifacts: List[str] = []
+        self.error: Any = None
+    
+    def add_artifact(self, path: str) -> None:
+        normalized_path = path.replace('\\', '/')
+        self.artifacts.append(normalized_path)
+    
+    def to_obj(self) -> Dict[str, Any]:
+        return {
+            'name': self.name,
+            'error': str(self.error) if self.error else None,
+            'artifacts': self.artifacts
+        }
+    
+    async def and_when(
+        self,
+        store: Any,
+        when_cb: Any,
+        test_resource: Any,
+        pm: Any
+    ) -> Any:
+        raise NotImplementedError()
+    
+    async def test(
+        self,
+        store: Any,
+        test_resource_configuration,
+        t_log: Any,
+        pm: Any,
+        filepath: str
+    ) -> Any:
+        try:
+            # Ensure add_artifact is properly bound to 'this'
+            add_artifact = self.add_artifact
+            # In Python, we can just pass self.add_artifact directly
+            # For now, we'll implement a simple version
+            result = await self.and_when(
+                store,
+                self.when_cb,
+                test_resource_configuration,
+                pm
+            )
+            return result
+        except Exception as e:
+            self.error = e
+            raise e