testeranto 0.200.1 → 0.203.0

package/example/Calculator.go

@@ -0,0 +1,63 @@
+package main
+
+type Calculator struct {
+    values  map[string]interface{}
+    display string
+}
+
+func (c *Calculator) Add(a, b float64) float64 {
+    return a + b
+}
+
+func (c *Calculator) Subtract(a, b float64) float64 {
+    return a - b
+}
+
+func (c *Calculator) Multiply(a, b float64) float64 {
+    return a * b
+}
+
+func (c *Calculator) Divide(a, b float64) (float64, error) {
+    if b == 0 {
+        return 0, &DivisionByZeroError{}
+    }
+    return a / b, nil
+}
+
+func (c *Calculator) SetValue(identifier string, value interface{}) {
+    if c.values == nil {
+        c.values = make(map[string]interface{})
+    }
+    c.values[identifier] = value
+}
+
+func (c *Calculator) GetValue(identifier string) interface{} {
+    if c.values == nil {
+        return nil
+    }
+    return c.values[identifier]
+}
+
+// GetDisplay returns the current display value
+func (c *Calculator) GetDisplay() string {
+    return c.display
+}
+
+// Press handles button presses
+func (c *Calculator) Press(button string) *Calculator {
+    // Handle special buttons
+    if button == "C" {
+        c.display = ""
+        return c
+    }
+    
+    // For regular buttons, append to display
+    c.display = c.display + button
+    return c
+}
+
+type DivisionByZeroError struct{}
+
+func (e *DivisionByZeroError) Error() string {
+    return "Cannot divide by zero"
+}

package/example/Calculator.golingvu.adapter.go

@@ -0,0 +1,81 @@
+//go:build testeranto
+// +build testeranto
+
+package testeranto_test
+
+import (
+	"github.com/adamwong246/testeranto/src/golingvu"
+)
+
+// SimpleTestAdapter is a basic implementation of ITestAdapter for Calculator tests
+type SimpleTestAdapter struct{}
+
+// AfterAll implements golingvu.ITestAdapter.
+func (a SimpleTestAdapter) AfterAll(store interface{}, pm interface{}) interface{} {
+	// Clean up after all tests
+	return store
+}
+
+// AfterEach implements golingvu.ITestAdapter.
+func (a SimpleTestAdapter) AfterEach(store interface{}, key string, pm interface{}) interface{} {
+	// Clean up after each test
+	return store
+}
+
+// AndWhen implements golingvu.ITestAdapter.
+func (a SimpleTestAdapter) AndWhen(store interface{}, whenCB interface{}, testResource interface{}, pm interface{}) interface{} {
+	// Execute the when callback
+	if whenFunc, ok := whenCB.(func(interface{}, interface{}, interface{}) (interface{}, error)); ok {
+		result, err := whenFunc(store, testResource, pm)
+		if err != nil {
+			panic(err)
+		}
+		return result
+	}
+	return store
+}
+
+// AssertThis implements golingvu.ITestAdapter.
+func (a SimpleTestAdapter) AssertThis(t interface{}) bool {
+	// Simple assertion - check if the result is true or if there's no error
+	switch v := t.(type) {
+	case bool:
+		return v
+	case error:
+		return v == nil
+	case nil:
+		return true
+	default:
+		return true
+	}
+}
+
+// BeforeAll implements golingvu.ITestAdapter.
+func (a SimpleTestAdapter) BeforeAll(input interface{}, tr golingvu.ITTestResourceConfiguration, pm interface{}) interface{} {
+	// Initialize before all tests - create a new calculator
+	return &Calculator{}
+}
+
+// BeforeEach implements golingvu.ITestAdapter.
+func (a SimpleTestAdapter) BeforeEach(subject interface{}, initializer interface{}, testResource golingvu.ITTestResourceConfiguration, initialValues interface{}, pm interface{}) interface{} {
+	// Initialize before each test - reset the calculator
+	if calc, ok := subject.(*Calculator); ok {
+		calc.display = ""
+		calc.values = make(map[string]interface{})
+		return calc
+	}
+	return subject
+}
+
+// ButThen implements golingvu.ITestAdapter.
+func (a SimpleTestAdapter) ButThen(store interface{}, thenCB interface{}, testResource interface{}, pm interface{}) interface{} {
+	// Execute the then callback
+	if thenFunc, ok := thenCB.(func(interface{}, interface{}, interface{}) (interface{}, error)); ok {
+		result, err := thenFunc(store, testResource, pm)
+		if err != nil {
+			panic(err)
+		}
+		return result
+	}
+	return store
+}

package/example/Calculator.golingvu.go

@@ -0,0 +1,67 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+
+	"github.com/adamwong246/testeranto/src/golingvu"
+)
+
+func main() {
+	fmt.Println("Running Calculator BDD tests with Golingvu...")
+
+	// Create test adapter
+	adapter := SimpleTestAdapter{}
+
+	// Create test implementation
+	implementation := NewCalculatorTestImplementation()
+
+	// Create Golingvu instance
+	gv := golingvu.NewGolingvu(
+		nil,
+		CalculatorSpecification,
+		implementation,
+		golingvu.DefaultTestResourceRequest,
+		adapter,
+		func(f func()) {
+			// Simple uber catcher
+			defer func() {
+				if r := recover(); r != nil {
+					fmt.Printf("Test panic recovered: %v\n", r)
+				}
+			}()
+			f()
+		},
+	)
+
+	// Create a test resource configuration
+	testResource := golingvu.ITTestResourceConfiguration{
+		Name:  "CalculatorTest",
+		Fs:    "./testeranto/reports/core/example/Calculator.golingvu.test/golang",
+		Ports: []int{},
+	}
+
+	// Convert to JSON string
+	testResourceJSON, err := json.Marshal(testResource)
+	if err != nil {
+		fmt.Printf("Error marshaling test resource: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Run the tests
+	results, err := gv.ReceiveTestResourceConfig(string(testResourceJSON), nil)
+	if err != nil {
+		fmt.Printf("Error running tests: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Print results
+	if results.Failed {
+		fmt.Printf("Tests failed: %d out of %d tests failed\n", results.Fails, results.Tests)
+		os.Exit(1)
+	} else {
+		fmt.Printf("All tests passed: %d tests executed successfully\n", results.Tests)
+		os.Exit(0)
+	}
+}

package/example/Calculator.golingvu.implementation.go

@@ -0,0 +1,95 @@
+package main
+
+import (
+	"fmt"
+
+	"github.com/adamwong246/testeranto/src/golingvu"
+)
+
+// Implementation for Calculator tests
+type CalculatorTestImplementation struct {
+	SuitesMap map[string]interface{}
+	GivensMap map[string]interface{}
+	WhensMap  map[string]interface{}
+	ThensMap  map[string]interface{}
+}
+
+func NewCalculatorTestImplementation() golingvu.ITestImplementation {
+	impl := &CalculatorTestImplementation{}
+
+	impl.SuitesMap = map[string]interface{}{
+		"Default": func(name string, givens map[string]*golingvu.BaseGiven) *golingvu.BaseSuite {
+			return &golingvu.BaseSuite{
+				Name:   name,
+				Givens: givens,
+			}
+		},
+	}
+
+	impl.GivensMap = map[string]interface{}{
+		"Default": func(name string, features []string, whens []*golingvu.BaseWhen, thens []*golingvu.BaseThen, givenCB interface{}, initialValues interface{}) *golingvu.BaseGiven {
+			return &golingvu.BaseGiven{
+				Name:          name,
+				Features:      features,
+				Whens:         whens,
+				Thens:         thens,
+				GivenCB:       givenCB,
+				InitialValues: initialValues,
+			}
+		},
+	}
+
+	impl.WhensMap = map[string]interface{}{
+		"press": func(payload interface{}) *golingvu.BaseWhen {
+			button := payload.(string)
+			return &golingvu.BaseWhen{
+				Name: "press",
+				WhenCB: func(store, testResource, pm interface{}) (interface{}, error) {
+					if calc, ok := store.(*Calculator); ok {
+						calc.Press(button)
+						return calc, nil
+					}
+					return store, nil
+				},
+			}
+		},
+		"enter": func(payload interface{}) *golingvu.BaseWhen {
+			return &golingvu.BaseWhen{
+				Name: "enter",
+				WhenCB: func(store, testResource, pm interface{}) (interface{}, error) {
+					if calc, ok := store.(*Calculator); ok {
+						// For now, we'll just return the calculator
+						return calc, nil
+					}
+					return store, nil
+				},
+			}
+		},
+	}
+
+	impl.ThensMap = map[string]interface{}{
+		"result": func(payload interface{}) *golingvu.BaseThen {
+			expected := payload.(string)
+			return &golingvu.BaseThen{
+				Name: "result",
+				ThenCB: func(store, testResource, pm interface{}) (interface{}, error) {
+					if calc, ok := store.(*Calculator); ok {
+						actual := calc.GetDisplay()
+						if actual != expected {
+							return nil, fmt.Errorf("expected %s, got %s", expected, actual)
+						}
+						return true, nil
+					}
+					return nil, fmt.Errorf("store is not a Calculator")
+				},
+			}
+		},
+	}
+
+	return golingvu.ITestImplementation{
+		Suites: impl.SuitesMap,
+		Givens: impl.GivensMap,
+		Whens:  impl.WhensMap,
+		Thens:  impl.ThensMap,
+	}
+}

package/example/Calculator.golingvu.specification.go

@@ -0,0 +1,68 @@
+package main
+
+import "github.com/adamwong246/testeranto/src/golingvu"
+
+// Specification for Calculator tests
+var CalculatorSpecification golingvu.ITestSpecification = func(
+	suites interface{},
+	givens interface{},
+	whens interface{},
+	thens interface{},
+) interface{} {
+	// The parameters are maps containing the functions
+	suitesMap := suites.(map[string]interface{})
+	givensMap := givens.(map[string]interface{})
+	whensMap := whens.(map[string]interface{})
+	thensMap := thens.(map[string]interface{})
+
+	// Get the functions from the maps with the correct type assertions
+	suiteFunc := suitesMap["Default"].(func(string, map[string]*golingvu.BaseGiven) *golingvu.BaseSuite)
+	givenFunc := givensMap["Default"].(func(string, []string, []*golingvu.BaseWhen, []*golingvu.BaseThen, interface{}, interface{}) *golingvu.BaseGiven)
+	whenFunc := whensMap["press"].(func(interface{}) *golingvu.BaseWhen)
+	thenFunc := thensMap["result"].(func(interface{}) *golingvu.BaseThen)
+
+	// Create the givens map with the correct type
+	givensForSuite := make(map[string]*golingvu.BaseGiven)
+
+	// Create and add the testEmptyDisplay given
+	emptyWhens := make([]*golingvu.BaseWhen, 0)
+	emptyThens := make([]*golingvu.BaseThen, 0)
+	
+	// Add the then result
+	thenResult := thenFunc("")
+	emptyThens = append(emptyThens, thenResult)
+	
+	givensForSuite["testEmptyDisplay"] = givenFunc(
+		"Default",
+		[]string{"pressing nothing, the display is empty"},
+		emptyWhens, // whens
+		emptyThens, // thens
+		nil,        // givenCB
+		nil,        // initialValues
+	)
+
+	// Create and add the testSingleDigit given
+	singleWhens := make([]*golingvu.BaseWhen, 0)
+	singleThens := make([]*golingvu.BaseThen, 0)
+	
+	// Add the when action
+	whenResult := whenFunc("2")
+	singleWhens = append(singleWhens, whenResult)
+	
+	// Add the then result
+	thenResult2 := thenFunc("2")
+	singleThens = append(singleThens, thenResult2)
+	
+	givensForSuite["testSingleDigit"] = givenFunc(
+		"Default",
+		[]string{"entering a number puts it on the display"},
+		singleWhens, // whens
+		singleThens, // thens
+		nil,
+		nil,
+	)
+
+	return []interface{}{
+		suiteFunc("Testing Calculator operations", givensForSuite),
+	}
+}

package/example/Calculator.pitono.adapter.py

@@ -0,0 +1,68 @@
+from typing import Any
+# Use relative import
+from ..Calculator import Calculator
+
+class SimpleTestAdapter:
+    def before_all(self, input_val, tr, pm):
+        return input_val
+    
+    def after_all(self, store, pm):
+        return store
+    
+    def before_each(self, subject, initializer, test_resource, initial_values, pm):
+        print("[ADAPTER] beforeEach called")
+        # The initializer should be a function that returns a Calculator instance
+        result = initializer()
+        print(f"[ADAPTER] beforeEach result: {result}")
+        if hasattr(result, 'get_display'):
+            print(f"[ADAPTER] display: {result.get_display()}")
+        # Make sure we always have a valid Calculator instance
+        return result
+    
+    def after_each(self, store, key, pm):
+        return store
+    
+    def and_when(self, store, when_cb, test_resource, pm):
+        print("[ADAPTER] andWhen called")
+        if hasattr(store, 'get_display'):
+            print(f"[ADAPTER] store display: {store.get_display()}")
+        
+        # The when_cb is a function that takes the store and returns the modified store
+        try:
+            print("[ADAPTER] Calling when_cb which should be a function")
+            # Apply the transformation to the store
+            result = when_cb(store)
+            if hasattr(result, 'get_display'):
+                print(f"[ADAPTER] Result display: {result.get_display()}")
+            
+            # Verify the result is a Calculator instance
+            if not isinstance(result, Calculator):
+                raise TypeError(f"Expected Calculator instance, got {type(result)}")
+            return result
+        except Exception as e:
+            print(f"[ADAPTER] Error in andWhen: {e}")
+            raise e
+    
+    def but_then(self, store, then_cb, test_resource, pm):
+        print("[ADAPTER] butThen called")
+        if hasattr(store, 'get_display'):
+            print(f"[ADAPTER] store: {store}, display: {store.get_display()}")
+        
+        # then_cb is the function that takes the store and makes assertions
+        try:
+            # Run the then callback which may throw if assertion fails
+            then_cb(store)
+            # Return the selection (the display value)
+            if hasattr(store, 'get_display'):
+                display = store.get_display()
+                print(f"[ADAPTER] butThen returning selection: {display}")
+                return display
+            return None
+        except Exception as e:
+            print(f"[ADAPTER] Error in butThen: {e}")
+            raise e
+    
+    def assert_this(self, t):
+        # The actual value comes from butThen which returns the display
+        # We don't need to do anything here as assertions are done in thenCB
+        return t

package/example/Calculator.pitono.implementation.py

@@ -0,0 +1,30 @@
+from typing import Any, Callable, Dict
+from ..Calculator import Calculator
+
+class Implementation:
+    def __init__(self):
+        self.suites = {
+            "Default": "Default test suite for Calculator"
+        }
+        self.givens = {
+            "Default": lambda: Calculator()
+        }
+        self.whens = {
+            "press": lambda button: lambda calc: calc.press(button),
+            "enter": lambda: lambda calc: calc.enter(),
+            "memoryStore": lambda: lambda calc: calc.memory_store(),
+            "memoryRecall": lambda: lambda calc: calc.memory_recall(),
+            "memoryClear": lambda: lambda calc: calc.memory_clear(),
+            "memoryAdd": lambda: lambda calc: calc.memory_add()
+        }
+        self.thens = {
+            "result": lambda expected: lambda calc: self._assert_result(calc, expected)
+        }
+
+    def _assert_result(self, calculator, expected):
+        actual = calculator.get_display()
+        if actual != expected:
+            raise AssertionError(f"Expected display '{expected}', got '{actual}'")
+
+# Create an instance
+implementation = Implementation()

package/example/Calculator.pitono.specification.py

@@ -0,0 +1,154 @@
+from typing import Any, Dict, List
+
+def specification(Suite, Given, When, Then):
+    return [
+        Suite.Default("Testing Calculator operations", {
+            # Basic number input
+            "testEmptyDisplay": Given.Default(
+                ["pressing nothing, the display is empty"],
+                [],
+                [Then.result("")]
+            ),
+            "testSingleDigit": Given.Default(
+                ["entering a number puts it on the display"],
+                [When.press("2")],
+                [Then.result("2")]
+            ),
+            "testMultipleDigits": Given.Default(
+                ["entering multiple digits concatenates them"],
+                [When.press("2"), When.press("2")],
+                [Then.result("22")]
+            ),
+            "testLargeNumber": Given.Default(
+                ["entering a large number works correctly"],
+                [When.press("1"), When.press("2"), When.press("3"), When.press("4"), When.press("5")],
+                [Then.result("12345")]
+            ),
+
+            # Basic operations
+            "testAdditionExpression": Given.Default(
+                ["addition expression is displayed correctly"],
+                [When.press("2"), When.press("+"), When.press("3")],
+                [Then.result("2+3")]
+            ),
+            "testIncompleteAddition": Given.Default(
+                ["incomplete addition expression is displayed correctly"],
+                [When.press("2"), When.press("+")],
+                [Then.result("2+")]
+            ),
+            "testSubtractionExpression": Given.Default(
+                ["subtraction expression is displayed correctly"],
+                [When.press("7"), When.press("-"), When.press("3")],
+                [Then.result("7-3")]
+            ),
+            "testMultiplicationExpression": Given.Default(
+                ["multiplication expression is displayed correctly"],
+                [When.press("4"), When.press("*"), When.press("5")],
+                [Then.result("4*5")]
+            ),
+            "testDivisionExpression": Given.Default(
+                ["division expression is displayed correctly"],
+                [When.press("8"), When.press("/"), When.press("2")],
+                [Then.result("8/2")]
+            ),
+
+            # Calculation tests
+            "testSimpleAddition": Given.Default(
+                ["simple addition calculation"],
+                [
+                    When.press("2"), When.press("3"), When.press("+"),
+                    When.press("4"), When.press("5"), When.enter()
+                ],
+                [Then.result("68")]
+            ),
+            "testSimpleSubtraction": Given.Default(
+                ["simple subtraction calculation"],
+                [
+                    When.press("9"), When.press("5"), When.press("-"),
+                    When.press("3"), When.press("2"), When.enter()
+                ],
+                [Then.result("63")]
+            ),
+            "testSimpleMultiplication": Given.Default(
+                ["simple multiplication calculation"],
+                [
+                    When.press("6"), When.press("*"), When.press("7"),
+                    When.enter()
+                ],
+                [Then.result("42")]
+            ),
+            "testSimpleDivision": Given.Default(
+                ["simple division calculation"],
+                [
+                    When.press("8"), When.press("4"), When.press("/"),
+                    When.press("2"), When.enter()
+                ],
+                [Then.result("42")]
+            ),
+
+            # Edge cases
+            "testClearOperation": Given.Default(
+                ["clear operation resets the display"],
+                [
+                    When.press("1"), When.press("2"), When.press("3"),
+                    When.press("C"), When.press("4")
+                ],
+                [Then.result("4")]
+            ),
+            "testStartingWithOperator": Given.Default(
+                ["starting with operator should work"],
+                [When.press("+"), When.press("5")],
+                [Then.result("+5")]
+            ),
+            "testMultipleOperators": Given.Default(
+                ["multiple operators in sequence"],
+                [When.press("5"), When.press("+"), When.press("-"), When.press("3")],
+                [Then.result("5+-3")]
+            ),
+
+            # Error cases
+            "testDivisionByZero": Given.Default(
+                ["division by zero shows error"],
+                [
+                    When.press("5"), When.press("/"), When.press("0"),
+                    When.enter()
+                ],
+                [Then.result("Error")]
+            ),
+            "testInvalidExpression": Given.Default(
+                ["invalid expression shows error"],
+                [
+                    When.press("2"), When.press("+"), When.press("+"),
+                    When.press("3"), When.enter()
+                ],
+                [Then.result("Error")]
+            ),
+
+            # Memory functions
+            "testMemoryStoreRecall": Given.Default(
+                ["memory store and recall"],
+                [
+                    When.press("1"), When.press("2"), When.press("3"),
+                    When.press("MS"), When.press("C"), When.press("MR")
+                ],
+                [Then.result("123")]
+            ),
+            "testMemoryClear": Given.Default(
+                ["memory clear"],
+                [
+                    When.press("4"), When.press("5"), When.press("6"),
+                    When.press("MS"), When.press("MC"), When.press("MR")
+                ],
+                [Then.result("0")]
+            ),
+            "testMemoryAddition": Given.Default(
+                ["memory addition"],
+                [
+                    When.press("1"), When.press("0"), When.press("M+"),
+                    When.press("2"), When.press("0"), When.press("M+"),
+                    When.press("MR")
+                ],
+                [Then.result("30")]
+            )
+        })
+    ]

package/example/Calculator.pitono.test.py

@@ -0,0 +1,47 @@
+import sys
+import os
+
+# Add the current directory to the Python path to find local modules
+sys.path.insert(0, os.path.dirname(__file__))
+
+# Import Calculator from the current directory
+from Calculator import Calculator
+
+# Try to import pitono components
+try:
+    # Try relative import first
+    from ..src.pitono.Pitono import Pitono, set_default_instance, main
+except ImportError:
+    try:
+        # Try absolute import
+        from src.pitono.Pitono import Pitono, set_default_instance, main
+    except ImportError:
+        print("Could not import pitono. Make sure to run from the project root")
+        raise
+
+# Import specification, implementation, and adapter
+try:
+    from .Calculator.pitono.specification import specification
+    from .Calculator.pitono.implementation import implementation
+    from .Calculator.pitono.adapter import SimpleTestAdapter
+except ImportError as e:
+    print(f"Import error: {e}")
+    # Create fallback implementations if needed
+    raise
+
+# Create the test instance
+test_instance = Pitono(
+    Calculator,  # Pass the Calculator class as input
+    specification,
+    implementation,
+    SimpleTestAdapter(),
+    {"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__":
+    import asyncio
+    asyncio.run(main())