testeranto 0.202.0 → 0.203.0

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

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

@@ -1,4 +1,4 @@
-from typing import Dict, List, Any, Callable
+from typing import Dict, List, Any, Callable, Optional
 
 class BaseSuite:
     def __init__(self, name: str, givens: Dict[str, Any]):
@@ -70,6 +70,10 @@ class BaseSuite:
             pm
         )
         
+        # Reset fails counter
+        self.fails = 0
+        self.failed = False
+        
         for g_key, g in self.givens.items():
             try:
                 self.store = await g.give(
@@ -82,10 +86,18 @@ class BaseSuite:
                     pm,
                     self.index
                 )
+                # Add any failures from the given to the suite total
+                if hasattr(g, 'failed') and g.failed:
+                    self.fails += 1
             except Exception as e:
                 self.failed = True
                 self.fails += 1
-                raise e
+                # Log the error but continue with other givens
+                print(f"Error in given {g_key}:", str(e))
+        
+        # Mark the suite as failed if there are any failures
+        if self.fails > 0:
+            self.failed = True
         
         try:
             self.after_all(self.store, artifactory, pm)
@@ -93,3 +105,44 @@ class BaseSuite:
             print(f"Error in after_all: {e}")
         
         return self
+    
+    # Add missing properties to match TypeScript
+    @property
+    def test_resource_configuration(self) -> Any:
+        return self._test_resource_configuration
+    
+    @test_resource_configuration.setter
+    def test_resource_configuration(self, value: Any):
+        self._test_resource_configuration = value
+    
+    @property
+    def index(self) -> int:
+        return self._index
+    
+    @index.setter
+    def index(self, value: int):
+        self._index = value
+    
+    @property
+    def failed(self) -> bool:
+        return self._failed
+    
+    @failed.setter
+    def failed(self, value: bool):
+        self._failed = value
+    
+    @property
+    def fails(self) -> int:
+        return self._fails
+    
+    @fails.setter
+    def fails(self, value: int):
+        self._fails = value
+    
+    @property
+    def artifacts(self) -> List[str]:
+        return self._artifacts
+    
+    @artifacts.setter
+    def artifacts(self, value: List[str]):
+        self._artifacts = value

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

@@ -7,6 +7,19 @@ class BaseThen:
         self.error = False
         self.artifacts: List[str] = []
     
+    async def but_then(
+        self,
+        store: Any,
+        then_cb: Any,
+        test_resource_configuration,
+        pm: Any
+    ) -> Any:
+        # Execute the then callback which should perform assertions
+        # The then_cb is typically a function that takes the store and performs checks
+        if callable(then_cb):
+            return then_cb(store)
+        return True
+    
     def add_artifact(self, path: str) -> None:
         normalized_path = path.replace('\\', '/')
         self.artifacts.append(normalized_path)
@@ -25,7 +38,8 @@ class BaseThen:
         test_resource_configuration,
         pm: Any
     ) -> Any:
-        raise NotImplementedError()
+        # Default implementation - can be overridden by subclasses
+        return True
     
     async def test(
         self,

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

@@ -7,6 +7,19 @@ class BaseWhen:
         self.artifacts: List[str] = []
         self.error: Any = None
     
+    async def and_when(
+        self,
+        store: Any,
+        when_cb: Any,
+        test_resource: Any,
+        pm: Any
+    ) -> Any:
+        # Execute the when callback which should modify the store
+        # The when_cb is typically a function that takes the store and returns the modified store
+        if callable(when_cb):
+            return when_cb(store)
+        return store
+    
     def add_artifact(self, path: str) -> None:
         normalized_path = path.replace('\\', '/')
         self.artifacts.append(normalized_path)
@@ -25,7 +38,8 @@ class BaseWhen:
         test_resource: Any,
         pm: Any
     ) -> Any:
-        raise NotImplementedError()
+        # Default implementation - can be overridden by subclasses
+        return store
     
     async def test(
         self,

package/{pitono → src/pitono}/pitono.egg-info/PKG-INFO

@@ -15,3 +15,28 @@ Classifier: Programming Language :: Python :: 3.10
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 Dynamic: requires-python
+
+# 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/{pitono → src/pitono}/pitono.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+README.md
 pyproject.toml
 setup.py
 pitono.egg-info/PKG-INFO

package/src/pitono/types.py

@@ -0,0 +1,87 @@
+from typing import TypeVar, Generic, Callable, Any, Dict, List, Optional, Protocol, Union
+from dataclasses import dataclass
+
+# 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
+@dataclass
+class ITTestResourceConfiguration:
+    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
+
+# Test adapter interface - matches the TypeScript ITestAdapter
+class ITestAdapter(Protocol):
+    def before_all(self, input_val: Any, tr: ITTestResourceConfiguration, pm: Any) -> Any:
+        ...
+    
+    def after_all(self, store: Any, pm: Any) -> Any:
+        ...
+    
+    def before_each(self, subject: Any, initializer: Any, test_resource: ITTestResourceConfiguration, 
+                   initial_values: Any, pm: Any) -> Any:
+        ...
+    
+    def after_each(self, store: Any, key: str, pm: Any) -> Any:
+        ...
+    
+    def and_when(self, store: Any, when_cb: Any, test_resource: Any, pm: Any) -> Any:
+        ...
+    
+    def but_then(self, store: Any, then_cb: Any, test_resource: Any, pm: Any) -> Any:
+        ...
+    
+    def assert_this(self, t: Any) -> bool:
+        ...
+
+# Test specification function type - matches TypeScript ITestSpecification
+# It can take either 4 or 5 arguments to be flexible
+ITestSpecification = Callable[..., Any]
+
+# Test implementation structure - matches TypeScript ITestImplementation structure
+class ITestImplementation:
+    suites: Dict[str, Any]
+    givens: Dict[str, Callable[..., Any]]
+    whens: Dict[str, Callable[..., Callable[[Any], Any]]]
+    thens: Dict[str, Callable[..., Callable[[Any], Any]]]
+    
+    def __init__(self, 
+                 suites: Dict[str, Any], 
+                 givens: Dict[str, Callable[..., Any]], 
+                 whens: Dict[str, Callable[..., Callable[[Any], Any]]], 
+                 thens: Dict[str, Callable[..., Callable[[Any], Any]]]):
+        self.suites = suites
+        self.givens = givens
+        self.whens = whens
+        self.thens = thens
+
+# Test resource request
+@dataclass
+class ITTestResourceRequest:
+    ports: int
+
+# Final results
+@dataclass
+class IFinalResults:
+    failed: bool
+    fails: int
+    artifacts: List[Any]
+    features: List[str]
+
+# BDD input type interface - simplified version of Ibdd_in
+class Ibdd_in(Protocol):
+    pass
+
+# BDD output type interface - simplified version of Ibdd_out
+class Ibdd_out(Protocol):
+    pass

package/src/services/FileService.ts

@@ -187,19 +187,152 @@ class DevelopmentFileService implements FileService {
   }
 
   async readFile(path: string): Promise<string> {
-    const response = await fetch(
-      `/api/files/read?path=${encodeURIComponent(path)}`
-    );
-    if (!response.ok) throw new Error(`Failed to read file: ${path}`);
-    return await response.text();
+    console.log("Reading file with path:", path);
+    const encodedPath = encodeURIComponent(path);
+    console.log("Encoded path:", encodedPath);
+    const url = `/api/files/read?path=${encodedPath}`;
+    console.log("Request URL:", url);
+    
+    try {
+      const response = await fetch(url);
+      
+      // Clone the response to read it multiple times if needed
+      const responseClone = response.clone();
+      
+      if (!response.ok) {
+        console.error(`Failed to read file: ${path}`, response.status, response.statusText);
+          
+        // If we're in development mode and the file doesn't exist, try to read from a relative path
+        // This might help with some configuration issues
+        if (response.status === 404) {
+          console.warn(`File not found via API, trying direct fetch: ${path}`);
+          try {
+            const directResponse = await fetch(path);
+            // Clone the direct response to avoid the same issue
+            const directResponseClone = directResponse.clone();
+            if (directResponse.ok) {
+              return await directResponse.text();
+            } else {
+              console.error(`Direct fetch failed: ${directResponse.status} ${directResponse.statusText}`);
+              // Try to read error details from the cloned response
+              try {
+                const errorText = await directResponseClone.text();
+                console.error("Direct fetch error details:", errorText);
+              } catch {
+                // Ignore if we can't read error details
+              }
+            }
+          } catch (directError) {
+            console.error("Direct fetch also failed:", directError);
+          }
+          
+          // If both API and direct fetch failed, try to read from a server-side endpoint
+          // that serves static files from the project directory
+          console.warn("Trying static file server fallback");
+          try {
+            const staticResponse = await fetch(`/static/${path}`);
+            if (staticResponse.ok) {
+              return await staticResponse.text();
+            } else {
+              console.error(`Static file fetch failed: ${staticResponse.status} ${staticResponse.statusText}`);
+            }
+          } catch (staticError) {
+            console.error("Static file fetch also failed:", staticError);
+          }
+        }
+          
+        // Try to get more details from the response using the cloned response
+        let errorDetails = '';
+        try {
+          const errorData = await responseClone.json();
+          errorDetails = JSON.stringify(errorData);
+        } catch {
+          try {
+            errorDetails = await responseClone.text();
+          } catch {
+            errorDetails = 'Could not read error details';
+          }
+        }
+        console.error("Error details:", errorDetails);
+        throw new Error(`Failed to read file: ${path} - ${response.status} ${response.statusText}`);
+      }
+      return await response.text();
+    } catch (error) {
+      console.error("Network error reading file:", error);
+      if (error instanceof TypeError && error.message.includes('body stream already read')) {
+        throw new Error(`Network error reading file: ${path} - Response body was already read (this is a bug)`);
+      }
+      throw new Error(`Network error reading file: ${path}`);
+    }
   }
 
   async readDirectory(path: string): Promise<FileEntry[]> {
-    const response = await fetch(
-      `/api/files/list?path=${encodeURIComponent(path)}`
-    );
-    if (!response.ok) throw new Error(`Failed to list directory: ${path}`);
-    return await response.json();
+    try {
+      // Try to use the API endpoint first
+      const response = await fetch(
+        `/api/files/list?path=${encodeURIComponent(path)}`
+      );
+      if (response.ok) {
+        return await response.json();
+      } else {
+        // If API endpoint fails, try to use WebSocket fallback
+        console.warn(`API endpoint failed (${response.status}), trying WebSocket fallback`);
+        return await this.readDirectoryViaWebSocket(path);
+      }
+    } catch (error) {
+      console.warn('API endpoint unavailable, trying WebSocket fallback:', error);
+      return await this.readDirectoryViaWebSocket(path);
+    }
+  }
+
+  private async readDirectoryViaWebSocket(path: string): Promise<FileEntry[]> {
+    return new Promise((resolve, reject) => {
+      // Set up a timeout
+      const timeout = setTimeout(() => {
+        reject(new Error('WebSocket directory listing timeout'));
+      }, 5000);
+
+      // Create a temporary WebSocket connection for this request
+      const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+      const wsUrl = `${protocol}//${window.location.host}/api/files-ws`;
+      const ws = new WebSocket(wsUrl);
+      
+      ws.onopen = () => {
+        ws.send(JSON.stringify({
+          type: 'listDirectory',
+          path: path
+        }));
+      };
+      
+      ws.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data);
+          if (data.type === 'directoryListing') {
+            clearTimeout(timeout);
+            ws.close();
+            resolve(data.items);
+          } else if (data.type === 'error') {
+            clearTimeout(timeout);
+            ws.close();
+            reject(new Error(data.message));
+          }
+        } catch (error) {
+          clearTimeout(timeout);
+          ws.close();
+          reject(error);
+        }
+      };
+      
+      ws.onerror = (error) => {
+        clearTimeout(timeout);
+        ws.close();
+        reject(new Error('WebSocket connection failed'));
+      };
+      
+      ws.onclose = () => {
+        clearTimeout(timeout);
+      };
+    });
   }
 
   async exists(path: string): Promise<boolean> {
@@ -254,7 +387,9 @@ class DevelopmentFileService implements FileService {
   async getChanges(): Promise<FileChange[]> {
     const response = await fetch("/api/git/changes");
     if (!response.ok) return [];
-    return await response.json();
+    const changes = await response.json();
+    console.log("Raw changes from server:", JSON.stringify(changes, null, 2));
+    return changes;
   }
 
   async commitChanges(message: string, description?: string): Promise<void> {