testeranto 0.200.1 → 0.203.0

package/example/base_suite_test.go

@@ -0,0 +1,51 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"testing"
+
+	"github.com/adamwong246/testeranto/src/golingvu"
+)
+
+func TestBaseSuite(t *testing.T) {
+	// This test should only be executed via launchGolang which sets environment variables
+	testResources := os.Getenv("TEST_RESOURCES")
+	ipcFile := os.Getenv("IPC_FILE")
+
+	// If environment variables are not set, this test wasn't launched via the PM
+	if testResources == "" || ipcFile == "" {
+		t.Skip("Test must be executed via PM with TEST_RESOURCES and IPC_FILE environment variables set")
+		return
+	}
+
+	// Parse test resources
+	var testResourceConfig golingvu.ITTestResourceConfiguration
+	if err := json.Unmarshal([]byte(testResources), &testResourceConfig); err != nil {
+		t.Fatalf("Failed to parse test resources: %v", err)
+	}
+
+	// Create PM instance and connect to IPC
+	pm, err := golingvu.NewPM_Golang(testResourceConfig, ipcFile)
+	if err != nil {
+		t.Fatalf("Failed to create PM instance: %v", err)
+	}
+	// Ensure Stop method is accessible
+	if pm == nil {
+		t.Fatal("PM instance is nil")
+	}
+	defer func() {
+		if pm != nil {
+			err := pm.Stop()
+			if err != nil {
+				t.Logf("Error stopping PM: %v", err)
+			}
+		}
+	}()
+
+	// Run actual test logic here - this would be where you execute your BDD tests
+	// For now, just verify the connection was successful
+	fmt.Printf("Golang test executed successfully with IPC connection to %s\n", ipcFile)
+	fmt.Printf("Test resource: %+v\n", testResourceConfig)
+}

package/example/cmd/main.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Println("Usage: go run main.go <test-resources-json>")
+		os.Exit(1)
+	}
+	
+	// Parse test resource configuration would go here
+	fmt.Println("Main function executed with args:", os.Args[1:])
+}

package/example/go.mod

@@ -0,0 +1,9 @@
+module example
+
+go 1.19
+
+replace github.com/adamwong246/testeranto => ../
+
+replace github.com/adamwong246/testeranto/src/golingvu => ../src/golingvu
+
+require github.com/adamwong246/testeranto/src/golingvu v0.0.0-20250101000000-000000000000

package/example/test_example.py

@@ -1,37 +1,134 @@
 import asyncio
-from pitono import Pitono, SimpleTestAdapter
-from pitono.types import ITestSpecification, ITestImplementation, ITTestResourceRequest
-from pitono.core_generator import PitonoCoreGenerator
+import sys
+import os
 
-# Define a simple test specification
-def test_specification(suites, givens, whens, thens):
-    return {
-        'suites': suites,
-        'givens': givens,
-        'whens': whens,
-        'thens': thens
-    }
+# Add the src directory to Python path to find the pitono package
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+try:
+    from pitono import Pitono
+    from pitono.types import ITestSpecification, ITestImplementation, ITTestResourceRequest
+    from pitono.core_generator import PitonoCoreGenerator
+except ImportError as e:
+    print(f"Import error: {e}")
+    print("Current Python path:")
+    for path in sys.path:
+        print(f"  {path}")
+    print("Please make sure to activate the virtual environment and install the pitono package")
+    print("Run: python3 -m venv venv && source venv/bin/activate && pip install -e ./src/pitono")
+    raise
+
+# Define a simple Rectangle class to test
+class Rectangle:
+    def __init__(self, width, height):
+        self.width = width
+        self.height = height
+    
+    def set_width(self, width):
+        self.width = width
+    
+    def set_height(self, height):
+        self.height = height
+    
+    def get_width(self):
+        return self.width
+    
+    def get_height(self):
+        return self.height
+    
+    def area(self):
+        return self.width * self.height
+
+# Define test specification to match the TypeScript structure
+def test_specification(Suite, Given, When, Then, Check):
+    return [
+        Suite.Default("BaseSuite Core Funct", {
+            "initialization": Given["Default"](
+                ["BaseSuite should initialize with correct name and index"],
+                [],
+                [Then["SuiteNameMatches"]("testSuite"), Then["SuiteIndexMatches"](0)]
+            ),
+        }, [])
+    ]
 
-# Create a simple test implementation
+# Helper function for assertions
+def _assert_equal(actual, expected):
+    if actual != expected:
+        raise AssertionError(f"Expected {expected}, got {actual}")
+    return True
+
+# Define test implementation to match TypeScript
 test_implementation = ITestImplementation(
-    suites={},
-    givens={},
-    whens={},
-    thens={}
+    suites={
+        "Default": "BaseSuite Comprehensive Test Suite"
+    },
+    givens={
+        "Default": lambda: lambda: {"testStore": True, "testSelection": False}
+    },
+    whens={
+        "SuiteNameMatches": lambda name: lambda store, pm: store,
+        "SuiteIndexMatches": lambda index: lambda store, pm: store
+    },
+    thens={
+        "SuiteNameMatches": lambda expected: lambda store, pm: 
+            (_assert_equal(store.get("name", ""), expected), store)[1],
+        "SuiteIndexMatches": lambda expected: lambda store, pm: 
+            (_assert_equal(store.get("index", -1), expected), store)[1],
+    }
 )
 
-# Create a test resource requirement
+# Create test resource requirement
 test_resource_requirement = ITTestResourceRequest(ports=0)
 
-# Create a test adapter
-test_adapter = SimpleTestAdapter()
+# Create test adapter
+class TestAdapter:
+    async def beforeEach(self, subject, initializer, test_resource, initial_values, pm):
+        # Call the initializer with initial_values unpacked
+        # Handle case where initial_values might be None
+        if initial_values is None:
+            return initializer()
+        # Check if initial_values is iterable
+        try:
+            return initializer(*initial_values)
+        except TypeError:
+            # If it's not iterable, pass it directly
+            return initializer(initial_values)
+    
+    async def andWhen(self, store, when_cb, test_resource, pm):
+        # Execute the when callback which should modify the store and return it
+        # The when_cb is a function that takes the store and pm
+        result = when_cb(store, pm)
+        return result
+    
+    async def butThen(self, store, then_cb, test_resource, pm):
+        # Execute the then callback which should modify the store and return it
+        # The assertion is handled within the callback
+        result = then_cb(store, pm)
+        return result
+    
+    async def afterEach(self, store, key, pm):
+        # Clean up if necessary
+        pass
+    
+    async def beforeAll(self, input_val, test_resource, pm):
+        # Setup before all tests
+        # Return the initial subject which will be passed to beforeEach
+        return None
+    
+    async def afterAll(self, store, pm):
+        # Clean up after all tests
+        pass
+    
+    def assertThis(self, x):
+        # This seems to be used for assertions, but our assertions are in the then callbacks
+        # We can just pass through
+        pass
+
+test_adapter = TestAdapter()
 
 # Create uber_catcher
 def uber_catcher(func):
-    try:
-        func()
-    except Exception as e:
-        print(f"Error: {e}")
+    return func()
 
 # Create Pitono instance
 pitono = Pitono(
@@ -47,60 +144,32 @@ print("Pitono initialized successfully!")
 
 # Test the core generator
 def test_core_generator():
-    entry_points = ["example/test1.py", "example/test2.py"]
+    entry_points = ["example/test_example.py"]
     generator = PitonoCoreGenerator("test_suite", entry_points)
     generator.write_core_json()
+    print("Pitono core.json written to: testeranto/pitono/test_suite/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
+    async def run_test():
+        try:
+            # Try to run the tests
+            # The exact method name might be different, but let's assume it's 'run_tests'
+            if hasattr(pitono, 'run_tests') and callable(pitono.run_tests):
+                result = await pitono.run_tests()
+                print(f"Test completed with result: {result}")
+            else:
+                print("run_tests method not found on Pitono instance")
+                # Print available methods
+                for attr_name in dir(pitono):
+                    if not attr_name.startswith('_'):
+                        attr = getattr(pitono, attr_name)
+                        if callable(attr):
+                            print(f"Callable: {attr_name}")
+        except Exception as e:
+            print(f"Error running tests: {e}")
+            import traceback
+            traceback.print_exc()
     
-    # Run the test suite
-    asyncio.run(test_suite())
+    asyncio.run(run_test())

package/example/testeranto/bundles/golang/core/Calculator.golingvu.go

@@ -0,0 +1,53 @@
+//go:build testeranto
+// +build testeranto
+
+// This file is auto-generated by testeranto
+// Signature: mfg01lcp
+// It imports and tests: /Users/adam/Code/testeranto/example/Calculator.go
+
+package testeranto_test
+
+import (
+	"fmt"
+	"os"
+	"testing"
+	
+	// Import the original implementation
+	"../example"
+)
+
+func TestCalculatorOperations(t *testing.T) {
+	// Create an instance of the Calculator
+	calc := &Calculator.Calculator{}
+	
+	// Test basic operations
+	// This is where testeranto would run its test scenarios
+	
+	// Example test: test that a new calculator has empty display
+	if calc.GetDisplay() != "" {
+		t.Errorf("Expected empty display, got: %s", calc.GetDisplay())
+	}
+	
+	// Example test: test pressing buttons
+	calc.Press("2")
+	if calc.GetDisplay() != "2" {
+		t.Errorf("Expected '2', got: %s", calc.GetDisplay())
+	}
+	
+	// Add more test scenarios based on the testeranto specification
+	fmt.Println("Testeranto tests completed")
+}
+
+func main() {
+	// This allows the file to be run as a standalone program
+	// while keeping it in the testeranto_test package
+	testing.Main(func(pat, str string) (bool, error) { return true, nil },
+		[]testing.InternalTest{
+			{
+				Name: "TestCalculatorOperations",
+				F:    TestCalculatorOperations,
+			},
+		},
+		[]testing.InternalBenchmark{},
+		[]testing.InternalExample{})
+}

package/example/testeranto/metafiles/golang/core.json

@@ -0,0 +1,198 @@
+{
+  "errors": [],
+  "warnings": [],
+  "metafile": {
+    "inputs": {
+      "/Users/adam/Code/testeranto/example/Calculator.go": {
+        "bytes": 1318,
+        "imports": [
+          {
+            "path": "encoding/json",
+            "kind": "import-statement",
+            "external": false
+          },
+          {
+            "path": "fmt",
+            "kind": "import-statement",
+            "external": false
+          },
+          {
+            "path": "github.com/adamwong246/testeranto/src/golingvu",
+            "kind": "import-statement",
+            "external": true
+          },
+          {
+            "path": "os",
+            "kind": "import-statement",
+            "external": false
+          }
+        ],
+        "format": "esm"
+      },
+      "/Users/adam/Code/testeranto/example/Calculator.golingvu.adapter.go": {
+        "bytes": 2483,
+        "imports": [
+          {
+            "path": "encoding/json",
+            "kind": "import-statement",
+            "external": false
+          },
+          {
+            "path": "fmt",
+            "kind": "import-statement",
+            "external": false
+          },
+          {
+            "path": "github.com/adamwong246/testeranto/src/golingvu",
+            "kind": "import-statement",
+            "external": true
+          },
+          {
+            "path": "os",
+            "kind": "import-statement",
+            "external": false
+          }
+        ],
+        "format": "esm"
+      },
+      "/Users/adam/Code/testeranto/example/Calculator.golingvu.go": {
+        "bytes": 1482,
+        "imports": [
+          {
+            "path": "encoding/json",
+            "kind": "import-statement",
+            "external": false
+          },
+          {
+            "path": "fmt",
+            "kind": "import-statement",
+            "external": false
+          },
+          {
+            "path": "github.com/adamwong246/testeranto/src/golingvu",
+            "kind": "import-statement",
+            "external": true
+          },
+          {
+            "path": "os",
+            "kind": "import-statement",
+            "external": false
+          }
+        ],
+        "format": "esm"
+      },
+      "/Users/adam/Code/testeranto/example/Calculator.golingvu.implementation.go": {
+        "bytes": 2517,
+        "imports": [
+          {
+            "path": "encoding/json",
+            "kind": "import-statement",
+            "external": false
+          },
+          {
+            "path": "fmt",
+            "kind": "import-statement",
+            "external": false
+          },
+          {
+            "path": "github.com/adamwong246/testeranto/src/golingvu",
+            "kind": "import-statement",
+            "external": true
+          },
+          {
+            "path": "os",
+            "kind": "import-statement",
+            "external": false
+          }
+        ],
+        "format": "esm"
+      },
+      "/Users/adam/Code/testeranto/example/Calculator.golingvu.specification.go": {
+        "bytes": 2150,
+        "imports": [
+          {
+            "path": "encoding/json",
+            "kind": "import-statement",
+            "external": false
+          },
+          {
+            "path": "fmt",
+            "kind": "import-statement",
+            "external": false
+          },
+          {
+            "path": "github.com/adamwong246/testeranto/src/golingvu",
+            "kind": "import-statement",
+            "external": true
+          },
+          {
+            "path": "os",
+            "kind": "import-statement",
+            "external": false
+          }
+        ],
+        "format": "esm"
+      },
+      "/Users/adam/Code/testeranto/example/base_suite_test.go": {
+        "bytes": 1457,
+        "imports": [
+          {
+            "path": "encoding/json",
+            "kind": "import-statement",
+            "external": false
+          },
+          {
+            "path": "fmt",
+            "kind": "import-statement",
+            "external": false
+          },
+          {
+            "path": "github.com/adamwong246/testeranto/src/golingvu",
+            "kind": "import-statement",
+            "external": true
+          },
+          {
+            "path": "os",
+            "kind": "import-statement",
+            "external": false
+          },
+          {
+            "path": "testing",
+            "kind": "import-statement",
+            "external": false
+          }
+        ],
+        "format": "esm"
+      }
+    },
+    "outputs": {
+      "golang/core/Calculator.golingvu.go": {
+        "imports": [],
+        "exports": [],
+        "entryPoint": "/Users/adam/Code/testeranto/example/Calculator.go",
+        "inputs": {
+          "/Users/adam/Code/testeranto/example/Calculator.go": {
+            "bytesInOutput": 1318
+          },
+          "/Users/adam/Code/testeranto/example/Calculator.golingvu.adapter.go": {
+            "bytesInOutput": 2483
+          },
+          "/Users/adam/Code/testeranto/example/Calculator.golingvu.go": {
+            "bytesInOutput": 1482
+          },
+          "/Users/adam/Code/testeranto/example/Calculator.golingvu.implementation.go": {
+            "bytesInOutput": 2517
+          },
+          "/Users/adam/Code/testeranto/example/Calculator.golingvu.specification.go": {
+            "bytesInOutput": 2150
+          },
+          "/Users/adam/Code/testeranto/example/base_suite_test.go": {
+            "bytesInOutput": 1457
+          }
+        },
+        "bytes": 11407,
+        "signature": "mfg01lcp"
+      }
+    }
+  }
+}