testeranto 0.202.0 → 0.205.0

package/docker-compose.yml

@@ -0,0 +1,74 @@
+version: '3.8'
+
+services:
+  mothership:
+    build: 
+      context: .
+      dockerfile: Dockerfile.mothership
+    ports:
+      - "8080:8080"
+    environment:
+      - NODE_ENV=development
+    volumes:
+      - .:/workspace
+      - /var/run/docker.sock:/var/run/docker.sock
+    working_dir: /workspace
+    command: npm run mothership
+
+  node-build:
+    build:
+      context: .
+      dockerfile: Dockerfile.node
+    volumes:
+      - .:/workspace
+      - node_modules:/workspace/node_modules
+    working_dir: /workspace
+    command: tail -f /dev/null
+    environment:
+      - NODE_ENV=development
+    depends_on:
+      - mothership
+
+  web-build:
+    build:
+      context: .
+      dockerfile: Dockerfile.web
+    volumes:
+      - .:/workspace
+      - web_build_node_modules:/workspace/node_modules
+    working_dir: /workspace
+    command: tail -f /dev/null
+    environment:
+      - NODE_ENV=development
+    depends_on:
+      - mothership
+
+  golang-build:
+    build:
+      context: .
+      dockerfile: Dockerfile.golang
+    volumes:
+      - .:/workspace
+    working_dir: /workspace
+    command: tail -f /dev/null
+    environment:
+      - GOPATH=/workspace
+    depends_on:
+      - mothership
+
+  python-build:
+    build:
+      context: .
+      dockerfile: Dockerfile.python
+    volumes:
+      - .:/workspace
+    working_dir: /workspace
+    command: tail -f /dev/null
+    environment:
+      - PYTHONPATH=/workspace
+    depends_on:
+      - mothership
+
+volumes:
+  node_modules:
+  web_build_node_modules:

package/docs/testing.prompt.txt

@@ -1 +1,5 @@
-/add docs/index.md src/CoreTypes.ts src/lib/types.ts
+/read docs/index.md src/CoreTypes.ts src/lib/types.ts
+
+Do not introduce more than 1 change at a time.
+Do not introduce hacks, fallbacks of any kind or any change that does not address the root problem.
+You may use as much logging as you like.

package/example/Calculator.go

@@ -0,0 +1,99 @@
+package main
+
+// Calculator represents a simple calculator
+type Calculator struct {
+	values  map[string]interface{}
+	display string
+}
+
+// NewCalculator creates a new Calculator instance
+func NewCalculator() *Calculator {
+	return &Calculator{
+		values: make(map[string]interface{}),
+	}
+}
+
+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 {
+	if c == nil {
+		return ""
+	}
+	return c.display
+}
+
+// Press handles button presses
+func (c *Calculator) Press(button string) *Calculator {
+	if c == nil {
+		c = &Calculator{}
+	}
+	// Handle special buttons
+	if button == "C" {
+		c.display = ""
+		return c
+	}
+
+	// For regular buttons, append to display
+	c.display = c.display + button
+	return c
+}
+
+// DivisionByZeroError represents division by zero error
+type DivisionByZeroError struct{}
+
+func (e *DivisionByZeroError) Error() string {
+	return "Cannot divide by zero"
+}
+
+// press handles button presses (lowercase version for test compatibility)
+func (c *Calculator) press(button string) error {
+	c.Press(button)
+	return nil
+}
+
+// GetWidth is a placeholder method for testing
+func (c *Calculator) GetWidth() int {
+	return 0
+}
+
+// GetHeight is a placeholder method for testing
+func (c *Calculator) GetHeight() int {
+	return 0
+}
+
+// Area is a placeholder method for testing
+func (c *Calculator) Area() int {
+	return 0
+}

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.implementation.go

@@ -0,0 +1,144 @@
+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{}{
+		"CalculatorSuite": func(name string, givens map[string]*golingvu.BaseGiven) *golingvu.BaseSuite {
+			return &golingvu.BaseSuite{
+				Name:   name,
+				Givens: givens,
+			}
+		},
+	}
+
+	impl.GivensMap = map[string]interface{}{
+		"testEmptyDisplay": 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,
+			}
+		},
+		"testSingleDigit": 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,
+	}
+}
+
+// // CalculatorSpecification defines the test specification
+// func CalculatorSpecification(suites, givens, whens, thens interface{}) interface{} {
+// 	suite := suites.(map[string]interface{})["CalculatorSuite"].(func(string, map[string]*golingvu.BaseGiven) *golingvu.BaseSuite)
+
+// 	// Create the when and then functions
+// 	press := whens.(map[string]interface{})["press"].(func(interface{}) *golingvu.BaseWhen)
+// 	enter := whens.(map[string]interface{})["enter"].(func(interface{}) *golingvu.BaseWhen)
+// 	result := thens.(map[string]interface{})["result"].(func(interface{}) *golingvu.BaseThen)
+
+// 	// Create the test suite
+// 	return []interface{}{
+// 		suite("Testing Calculator operations", map[string]*golingvu.BaseGiven{
+// 			"testEmptyDisplay": givens.(map[string]interface{})["testEmptyDisplay"].(func(string, []string, []*golingvu.BaseWhen, []*golingvu.BaseThen, interface{}, interface{}) *golingvu.BaseGiven)(
+// 				"testEmptyDisplay",
+// 				[]string{"pressing nothing, the display is empty"},
+// 				[]*golingvu.BaseWhen{},
+// 				[]*golingvu.BaseThen{
+// 					result(""),
+// 				},
+// 				nil,
+// 				nil,
+// 			),
+// 			"testSingleDigit": givens.(map[string]interface{})["testSingleDigit"].(func(string, []string, []*golingvu.BaseWhen, []*golingvu.BaseThen, interface{}, interface{}) *golingvu.BaseGiven)(
+// 				"testSingleDigit",
+// 				[]string{"entering a number puts it on the display"},
+// 				[]*golingvu.BaseWhen{
+// 					press("2"),
+// 				},
+// 				[]*golingvu.BaseThen{
+// 					result("2"),
+// 				},
+// 				nil,
+// 				nil,
+// 			),
+// 			// Add more test cases here following the same pattern
+// 		}),
+// 	}
+// }

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.golingvu.test.go

@@ -0,0 +1,216 @@
+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 := golingvu.SimpleTestAdapter{}
+
+	// Create test implementation
+	implementation := NewCalculatorTestImplementation()
+
+	// Create Golingvu instance
+	gv := golingvu.NewGolingvu(
+		nil,
+		CalculatorSpecification,
+		implementation,
+		golingvu.DefaultTestResourceRequest,
+		adapter,
+		func(f func()) {
+			defer func() {
+				if r := recover(); r != nil {
+					fmt.Printf("Test panic recovered: %v\n", r)
+				}
+			}()
+			f()
+		},
+	)
+
+	// The test resource configuration should be provided via command line
+	if len(os.Args) < 2 {
+		fmt.Println("Error: Test resource configuration not provided")
+		os.Exit(1)
+	}
+
+	// Parse the test resource configuration
+	var testResource golingvu.ITTestResourceConfiguration
+	err := json.Unmarshal([]byte(os.Args[1]), &testResource)
+	if err != nil {
+		fmt.Printf("Error parsing test resource: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Create PM instance
+	pm, err := golingvu.NewPM_Golang(testResource, "/tmp/testeranto_ipc.sock")
+	if err != nil {
+		fmt.Printf("Error creating PM: %v\n", err)
+		// Continue without PM for now
+		pm = nil
+	}
+
+	// Run tests
+	results, err := gv.ReceiveTestResourceConfig(os.Args[1], pm)
+	if err != nil {
+		fmt.Printf("Error running tests: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Exit with appropriate code
+	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)
+	}
+}
+
+// NewCalculatorTestImplementation creates the test implementation with proper callbacks
+// func NewCalculatorTestImplementation() golingvu.ITestImplementation {
+// 	return golingvu.ITestImplementation{
+// 		Suites: map[string]interface{}{
+// 			"CalculatorSuite": func(name string, givens map[string]*golingvu.BaseGiven) *golingvu.BaseSuite {
+// 				return &golingvu.BaseSuite{
+// 					Key:    name,
+// 					Givens: givens,
+// 					AfterAllFunc: func(store interface{}, artifactory func(string, interface{}), pm interface{}) interface{} {
+// 						return store
+// 					},
+// 					AssertThatFunc: func(t interface{}) bool {
+// 						// Simple assertion - always return true for now
+// 						return true
+// 					},
+// 					SetupFunc: func(s interface{}, artifactory func(string, interface{}), tr golingvu.ITTestResourceConfiguration, pm interface{}) interface{} {
+// 						return s
+// 					},
+// 				}
+// 			},
+// 		},
+// 		Givens: map[string]interface{}{
+// 			"testEmptyDisplay": func(key string, features []string, whens []*golingvu.BaseWhen, thens []*golingvu.BaseThen, gcb interface{}, initialValues interface{}) *golingvu.BaseGiven {
+// 				return &golingvu.BaseGiven{
+// 					Key:           key,
+// 					Features:      features,
+// 					Whens:         whens,
+// 					Thens:         thens,
+// 					GivenCB:       gcb,
+// 					InitialValues: initialValues,
+// 					Artifacts:     []string{},
+// 					GivenThatFunc: func(subject, testResource, artifactory, initializer, initialValues, pm interface{}) (interface{}, error) {
+// 						// Create a new Calculator instance
+// 						calc := &Calculator{
+// 							display: "",
+// 							values:  make(map[string]interface{}),
+// 						}
+// 						return calc, nil
+// 					},
+// 					AfterEachFunc: func(store interface{}, key string, artifactory, pm interface{}) (interface{}, error) {
+// 						return store, nil
+// 					},
+// 				}
+// 			},
+// 			"testSingleDigit": func(key string, features []string, whens []*golingvu.BaseWhen, thens []*golingvu.BaseThen, gcb interface{}, initialValues interface{}) *golingvu.BaseGiven {
+// 				return &golingvu.BaseGiven{
+// 					Key:           key,
+// 					Features:      features,
+// 					Whens:         whens,
+// 					Thens:         thens,
+// 					GivenCB:       gcb,
+// 					InitialValues: initialValues,
+// 					Artifacts:     []string{},
+// 					GivenThatFunc: func(subject, testResource, artifactory, initializer, initialValues, pm interface{}) (interface{}, error) {
+// 						calc := &Calculator{
+// 							display: "",
+// 							values:  make(map[string]interface{}),
+// 						}
+// 						return calc, nil
+// 					},
+// 					AfterEachFunc: func(store interface{}, key string, artifactory, pm interface{}) (interface{}, error) {
+// 						return store, nil
+// 					},
+// 				}
+// 			},
+// 			// Add more test cases here following the same pattern
+// 		},
+// 		Whens: map[string]interface{}{
+// 			"press": func(button string) func(*Calculator) error {
+// 				return func(calc *Calculator) error {
+// 					calc.press(button)
+// 					return nil
+// 				}
+// 			},
+// 			"enter": func() func(*Calculator) error {
+// 				return func(calc *Calculator) error {
+// 					// Handle enter press if needed
+// 					return nil
+// 				}
+// 			},
+// 		},
+// 		Thens: map[string]interface{}{
+// 			"result": func(expected string) func(*Calculator) error {
+// 				return func(calc *Calculator) error {
+// 					if calc.display != expected {
+// 						return fmt.Errorf("expected %s, got %s", expected, calc.display)
+// 					}
+// 					return nil
+// 				}
+// 			},
+// 		},
+// 	}
+// }
+
+// CalculatorSpecification defines the test specification
+// func CalculatorSpecification(suites, givens, whens, thens interface{}) interface{} {
+// 	suite := suites.(map[string]interface{})["CalculatorSuite"].(func(string, map[string]*golingvu.BaseGiven) *golingvu.BaseSuite)
+
+// 	// Create the when and then functions
+// 	press := whens.(map[string]interface{})["press"].(func(string) func(*Calculator) error)
+// 	enter := whens.(map[string]interface{})["enter"].(func() func(*Calculator) error)
+// 	result := thens.(map[string]interface{})["result"].(func(string) func(*Calculator) error)
+
+// 	// Create the test suite
+// 	return []interface{}{
+// 		suite("Testing Calculator operations", map[string]*golingvu.BaseGiven{
+// 			"testEmptyDisplay": givens.(map[string]interface{})["testEmptyDisplay"].(func(string, []string, []*golingvu.BaseWhen, []*golingvu.BaseThen, interface{}, interface{}) *golingvu.BaseGiven)(
+// 				"testEmptyDisplay",
+// 				[]string{"pressing nothing, the display is empty"},
+// 				[]*golingvu.BaseWhen{},
+// 				[]*golingvu.BaseThen{
+// 					&golingvu.BaseThen{
+// 						Key:    "result: ",
+// 						ThenCB: result(""),
+// 					},
+// 				},
+// 				nil,
+// 				nil,
+// 			),
+// 			"testSingleDigit": givens.(map[string]interface{})["testSingleDigit"].(func(string, []string, []*golingvu.BaseWhen, []*golingvu.BaseThen, interface{}, interface{}) *golingvu.BaseGiven)(
+// 				"testSingleDigit",
+// 				[]string{"entering a number puts it on the display"},
+// 				[]*golingvu.BaseWhen{
+// 					&golingvu.BaseWhen{
+// 						Key:    "press: 2",
+// 						WhenCB: press("2"),
+// 					},
+// 				},
+// 				[]*golingvu.BaseThen{
+// 					&golingvu.BaseThen{
+// 						Key:    "result: 2",
+// 						ThenCB: result("2"),
+// 					},
+// 				},
+// 				nil,
+// 				nil,
+// 			),
+// 			// Add more test cases here following the same pattern
+// 		}),
+// 	}
+// }