testeranto 0.202.0 → 0.205.0

package/example/Calculator.test.specification.ts

@@ -0,0 +1,213 @@
+// import { ITestSpecification } from "testeranto/src/CoreTypes";
+import { ITestSpecification } from "../src/CoreTypes";
+import { I, O } from "./Calculator.test.types";
+
+export const specification: ITestSpecification<I, O> = (
+  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")]
+      ),
+
+      // Complex expressions
+      testMixedOperations: Given.Default(
+        ["mixed operations are displayed correctly"],
+        [When.press("2"), When.press("+"), When.press("3"), When.press("*"), When.press("4")],
+        [Then.result("2+3*4")]
+      ),
+      testLongExpression: Given.Default(
+        ["long complex expression is displayed correctly"],
+        [
+          When.press("1"), When.press("+"), When.press("2"), 
+          When.press("*"), When.press("3"), When.press("-"), 
+          When.press("4"), When.press("/"), When.press("5")
+        ],
+        [Then.result("1+2*3-4/5")]
+      ),
+
+      // 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")]
+      ),
+
+      // Decimal numbers
+      testDecimalInput: Given.Default(
+        ["decimal number input"],
+        [When.press("3"), When.press("."), When.press("1"), When.press("4")],
+        [Then.result("3.14")]
+      ),
+      testDecimalCalculation: Given.Default(
+        ["decimal calculation"],
+        [
+          When.press("3"), When.press("."), When.press("1"), When.press("+"),
+          When.press("1"), When.press("."), When.press("8"), When.press("6"),
+          When.enter()
+        ],
+        [Then.result("4.96")]
+      ),
+
+      // Complex calculations
+      testOrderOfOperations: Given.Default(
+        ["order of operations is respected"],
+        [
+          When.press("2"), When.press("+"), When.press("3"),
+          When.press("*"), When.press("4"), When.enter()
+        ],
+        [Then.result("14")]
+      ),
+      testParenthesesExpression: Given.Default(
+        ["parentheses in expression"],
+        [
+          When.press("("), When.press("2"), When.press("+"),
+          When.press("3"), When.press(")"), When.press("*"),
+          When.press("4"), When.enter()
+        ],
+        [Then.result("20")]
+      ),
+
+      // 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.test.ts

@@ -0,0 +1,13 @@
+import Testeranto from "testeranto/src/Node";
+import { specification } from "./Calculator.test.specification";
+import { implementation } from "./Calculator.test.implementation";
+import { adapter } from "./Calculator.test.adapter";
+import { I, O, M } from "./Calculator.test.types";
+import { Calculator } from "./Calculator";
+
+export default Testeranto<I, O, M>(
+  Calculator,
+  specification,
+  implementation,
+  adapter
+);

package/example/Calculator.test.types.ts

@@ -0,0 +1,50 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { Ibdd_in, Ibdd_out } from "../src/CoreTypes";
+import { Calculator } from "./Calculator";
+
+export type I = Ibdd_in<
+  typeof Calculator,           // iinput
+  typeof Calculator,           // isubject
+  Calculator,                  // istore
+  string,                      // iselection (getDisplay returns string)
+  () => Calculator,            // given
+  (calculator: Calculator) => Calculator,  // when
+  (calculator: Calculator) => void         // then
+>;
+
+export type O = Ibdd_out<
+  {
+    Default: [string];
+  },
+  {
+    Default: [];
+  },
+  {
+    press: [string];
+    enter: [];
+    memoryStore: [];
+    memoryRecall: [];
+    memoryClear: [];
+    memoryAdd: [];
+  },
+  {
+    result: [string];
+  }
+>;
+
+export type M = {
+  givens: {
+    [K in keyof O["givens"]]: (...args: O["givens"][K]) => Calculator;
+  };
+  whens: {
+    [K in keyof O["whens"]]: (
+      ...args: O["whens"][K]
+    ) => (calculator: Calculator) => Calculator;
+  };
+  thens: {
+    [K in keyof O["thens"]]: (
+      ...args: O["thens"][K]
+    ) => (calculator: Calculator) => void;
+  };
+};

package/example/Calculator.ts

@@ -0,0 +1,114 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+export class Calculator {
+  private display: string = "";
+  private values: { [key: string]: any } = {};
+  private id: number = Math.random(); // Add a unique ID to track instances
+
+  press(button: string): Calculator {
+    this.display = this.display + button;
+    return this;
+  }
+
+  enter(): void {
+    try {
+      // Simple expression evaluation
+      // Note: Using eval is not recommended for production code
+      // This is just for testing purposes
+      const result = eval(this.display);
+      this.display = result.toString();
+    } catch (error) {
+      this.display = "Error";
+      throw error;
+    }
+  }
+
+  memoryStore(): void {
+    this.setValue("memory", parseFloat(this.display) || 0);
+    this.clear();
+  }
+
+  memoryRecall(): void {
+    const memoryValue = this.getValue("memory") || 0;
+    this.display = memoryValue.toString();
+  }
+
+  memoryClear(): void {
+    this.setValue("memory", 0);
+  }
+
+  memoryAdd(): void {
+    const currentValue = parseFloat(this.display) || 0;
+    const memoryValue = this.getValue("memory") || 0;
+    this.setValue("memory", memoryValue + currentValue);
+    this.clear();
+  }
+
+  handleSpecialButton(button: string): boolean {
+    switch (button) {
+      case "C":
+        this.clear();
+        return true;
+      case "MS":
+        this.memoryStore();
+        return true;
+      case "MR":
+        this.memoryRecall();
+        return true;
+      case "MC":
+        this.memoryClear();
+        return true;
+      case "M+":
+        this.memoryAdd();
+        return true;
+      default:
+        return false;
+    }
+  }
+
+  press(button: string): Calculator {
+    // Handle special buttons first
+    if (this.handleSpecialButton(button)) {
+      return this;
+    }
+
+    // For regular buttons, append to display
+    this.display = this.display + button;
+    return this;
+  }
+
+  getDisplay(): string {
+    return this.display;
+  }
+
+  clear(): void {
+    this.display = "";
+  }
+
+  // Keep these methods for backward compatibility if needed
+  add(a: number, b: number): number {
+    return a + b;
+  }
+
+  subtract(a: number, b: number): number {
+    return a - b;
+  }
+
+  multiply(a: number, b: number): number {
+    return a * b;
+  }
+
+  divide(a: number, b: number): number {
+    if (b === 0) {
+      throw new Error("Cannot divide by zero");
+    }
+    return a / b;
+  }
+
+  setValue(identifier: string, value: any): void {
+    this.values[identifier] = value;
+  }
+
+  getValue(identifier: string): any {
+    return this.values[identifier] ?? null;
+  }
+}

package/example/README.md

@@ -0,0 +1 @@
+this is an example of a project using testeranto. ATM it supports python and golang.

package/example/go.mod

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

package/example/go.sum

@@ -0,0 +1,2 @@
+github.com/adamwong246/testeranto/src/golingvu v0.0.0-20250916161432-df2d728242b4 h1:28znIELoL9rAVstmz2m19APuAOXIJoD5w1Wy8t1NZLA=
+github.com/adamwong246/testeranto/src/golingvu v0.0.0-20250916161432-df2d728242b4/go.mod h1:AbfGhZiV/wrGmLg7N4NjH8duxc2Rc3on5WPOGEdGddY=

package/example/requirements.txt

@@ -0,0 +1,9 @@
+flake8==7.3.0
+mccabe==0.7.0
+mypy==1.17.1
+mypy_extensions==1.1.0
+pathspec==0.12.1
+-e git+https://github.com/adamwong246/testeranto.ts.git@7d3e6e2818f1c7e3d868fbb0a368adc1f02cf391#egg=pitono&subdirectory=src/pitono
+pycodestyle==2.14.0
+pyflakes==3.4.0
+typing_extensions==4.15.0

package/example/single-kanban-process.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Container fluid="true">
+  <Row>
+    <Col xs="12">
+      <Text class="">hello hello hello</Text>
+      <Text class="" />
+    </Col>
+  </Row>
+</Container>

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())