testeranto 0.202.0 → 0.203.0

package/src/lib/Tiposkripto.ts

@@ -111,13 +111,25 @@ export default abstract class Tiposkripto<
     const classyGivens = Object.entries(testImplementation.givens).reduce(
       (a, [key, g]) => {
         a[key] = (
-          name: string,
+          // name: string,
           features: string[],
           whens: BaseWhen<I>[],
           thens: BaseThen<I>[],
           gcb: I["given"],
           initialValues: any
         ) => {
+          // Debug the parameters being passed - check if features contains when-like objects
+          // console.log(`[Tiposkripto] Creating Given ${key} with:`);
+          // console.log(`  name: ${name}`);
+          // console.log(`  features:`, features);
+          // console.log(`  whens:`, whens);
+          // console.log(`  thens:`, thens);
+
+          // Ensure parameters are arrays and create copies to avoid reference issues
+          const safeFeatures = Array.isArray(features) ? [...features] : [];
+          const safeWhens = Array.isArray(whens) ? [...whens] : [];
+          const safeThens = Array.isArray(thens) ? [...thens] : [];
+
           return new (class extends BaseGiven<I> {
             uberCatcher = uberCatcher;
 
@@ -147,10 +159,10 @@ export default abstract class Tiposkripto<
               return Promise.resolve(fullAdapter.afterEach(store, key, pm));
             }
           })(
-            name,
-            features,
-            whens,
-            thens,
+            // name,
+            safeFeatures,
+            safeWhens,
+            safeThens,
             testImplementation.givens[key],
             initialValues
           );
@@ -163,11 +175,13 @@ export default abstract class Tiposkripto<
     const classyWhens = Object.entries(testImplementation.whens).reduce(
       (a, [key, whEn]: [string, (...x: any[]) => any]) => {
         a[key] = (...payload: any[]) => {
-          return new (class extends BaseWhen<I> {
+          const whenInstance = new (class extends BaseWhen<I> {
             async andWhen(store, whenCB, testResource, pm) {
               return await fullAdapter.andWhen(store, whenCB, testResource, pm);
             }
           })(`${key}: ${payload && payload.toString()}`, whEn(...payload));
+          // console.log(`[Tiposkripto] Created When ${key}:`, whenInstance.name);
+          return whenInstance;
         };
         return a;
       },
@@ -177,7 +191,7 @@ export default abstract class Tiposkripto<
     const classyThens = Object.entries(testImplementation.thens).reduce(
       (a, [key, thEn]: [string, (...x: any[]) => any]) => {
         a[key] = (...args: any[]) => {
-          return new (class extends BaseThen<I> {
+          const thenInstance = new (class extends BaseThen<I> {
             async butThen(
               store: any,
               thenCB,
@@ -187,6 +201,8 @@ export default abstract class Tiposkripto<
               return await fullAdapter.butThen(store, thenCB, testResource, pm);
             }
           })(`${key}: ${args && args.toString()}`, thEn(...args));
+          // console.log(`[Tiposkripto] Created Then ${key}:`, thenInstance.name);
+          return thenInstance;
         };
         return a;
       },
@@ -209,10 +225,24 @@ export default abstract class Tiposkripto<
       this.Then()
     );
 
+    // Debug: log the structure of the first suite to see if whens are properly set up
+    // if (this.specs.length > 0 && this.specs[0]) {
+    //   const firstSuite = this.specs[0] as any;
+    //   if (firstSuite.givens) {
+    //     Object.entries(firstSuite.givens).forEach(([givenKey, given]) => {
+    //       console.log(`[DEBUG] Given "${givenKey}":`, {
+    //         name: given.name,
+    //         whens: given.whens ? given.whens.map((w) => w?.name) : [],
+    //         thens: given.thens ? given.thens.map((t) => t?.name) : [],
+    //       });
+    //     });
+    //   }
+    // }
+
     // Calculate total number of tests (sum of all Givens across all Suites)
     // Each suite should have a 'givens' property that's a record of test names to BaseGiven instances
     this.totalTests = this.calculateTotalTests();
-    console.log(`Total tests calculated: ${this.totalTests}`);
+    // console.log(`Total tests calculated: ${this.totalTests}`);
 
     // Create test jobs
     this.testJobs = this.specs.map((suite: BaseSuite<I, O>) => {
@@ -336,12 +366,12 @@ export default abstract class Tiposkripto<
   private calculateTotalTests(): number {
     let total = 0;
     for (const suite of this.specs) {
-      if (suite && typeof suite === 'object') {
+      if (suite && typeof suite === "object") {
         // Access the givens property which should be a record of test names to BaseGiven instances
         // The givens property is typically on the suite instance
-        if ('givens' in suite) {
+        if ("givens" in suite) {
           const givens = (suite as any).givens;
-          if (givens && typeof givens === 'object') {
+          if (givens && typeof givens === "object") {
             total += Object.keys(givens).length;
           }
         }

package/src/lib/pmProxy.ts

@@ -90,6 +90,25 @@ export const butThenProxy: IProxy = (
     [
       "createWriteStream",
       (fp) => {
+        // Add debug logging to see what fp is
+        // console.log(
+        //   `[DEBUG] createWriteStream fp type: ${typeof fp}, value:`,
+        //   fp
+        // );
+
+        // // Ensure fp is always a string
+        // if (typeof fp !== "string") {
+        //   console.error(
+        //     `[PROXY ERROR] createWriteStream fp is not a string:`,
+        //     fp
+        //   );
+        //   // Don't convert, just throw to find the source
+        //   throw new Error(
+        //     `createWriteStream expected string for fp, got ${typeof fp}: ${JSON.stringify(
+        //       fp
+        //     )}`
+        //   );
+        // }
         const path = `${filepath}/butThen/${fp}`;
         addArtifact(path);
         return [path];
@@ -98,25 +117,17 @@ export const butThenProxy: IProxy = (
     [
       "writeFileSync",
       (fp, contents, testName) => {
-        console.log(
-          `[DEBUG] butThenProxy writeFileSync: fp="${fp}" (type: ${typeof fp}), contents="${contents}" (type: ${typeof contents}), testName="${testName}" (type: ${typeof testName})`
-        );
-        // Check if fp is being treated as individual characters
-        if (typeof fp !== "string") {
-          console.log(`[ERROR] fp is not a string:`, fp);
-          // If fp is not a string, try to handle it
-          if (Array.isArray(fp)) {
-            // If it's an array, join it back into a string
-            fp = fp.join("");
-            console.log(`[DEBUG] Converted array to string: "${fp}"`);
-          } else {
-            // For other cases, convert to string
-            fp = String(fp);
-            console.log(`[DEBUG] Converted to string: "${fp}"`);
-          }
-        }
+        // Add debug logging to see what fp is
+        // console.log(`[DEBUG] writeFileSync fp type: ${typeof fp}, value:`, fp);
+
+        // Ensure fp is always a string
+        // if (typeof fp !== "string") {
+        //   console.error(`[PROXY ERROR] writeFileSync fp is not a string:`, fp);
+        //   // Don't convert, just throw to find the source
+        //   throw new Error(`writeFileSync expected string for fp, got ${typeof fp}: ${JSON.stringify(fp)}`);
+        // }
         const path = `${filepath}/butThen/${fp}`;
-        console.log(`[DEBUG] Generated path: "${path}"`);
+        // console.log(`[DEBUG] Adding artifact: "${path}"`);
         addArtifact(path);
         return [path, contents, testName];
       },
@@ -162,6 +173,19 @@ export const andWhenProxy: IProxy = (
     [
       "createWriteStream",
       (fp) => {
+        // // Add debug logging to see what fp is
+        // console.log(
+        //   `[DEBUG] andWhen createWriteStream fp type: ${typeof fp}, value:`,
+        //   fp
+        // );
+
+        // if (typeof fp !== "string") {
+        //   throw new Error(
+        //     `andWhen createWriteStream expected string for fp, got ${typeof fp}: ${JSON.stringify(
+        //       fp
+        //     )}`
+        //   );
+        // }
         const path = `${filepath}/andWhen/${fp}`;
         addArtifact(path);
         return [path];
@@ -171,6 +195,19 @@ export const andWhenProxy: IProxy = (
     [
       "writeFileSync",
       (fp, contents, testName) => {
+        // Add debug logging to see what fp is
+        // console.log(
+        //   `[DEBUG] andWhen writeFileSync fp type: ${typeof fp}, value:`,
+        //   fp
+        // );
+
+        // if (typeof fp !== "string") {
+        //   throw new Error(
+        //     `andWhen writeFileSync expected string for fp, got ${typeof fp}: ${JSON.stringify(
+        //       fp
+        //     )}`
+        //   );
+        // }
         const path = `${filepath}/andWhen/${fp}`;
         addArtifact(path);
         return [path, contents, testName];

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)