testeranto 0.200.1 → 0.203.0

package/example/Calculator.py

@@ -0,0 +1,93 @@
+class Calculator:
+    def __init__(self):
+        self.display = ""
+        self.values = {}
+        self.id = id(self)  # Add a unique ID to track instances
+
+    def press(self, button: str):
+        print(f"[CALCULATOR {self.id}] Pressing: {button}, current display: '{self.display}'")
+        
+        # Handle special buttons first
+        if button == "C":
+            return self.clear()
+        elif button == "MS":
+            return self.memory_store()
+        elif button == "MR":
+            return self.memory_recall()
+        elif button == "MC":
+            return self.memory_clear()
+        elif button == "M+":
+            return self.memory_add()
+        
+        # For regular buttons, append to display
+        self.display = self.display + button
+        print(f"[CALCULATOR {self.id}] New display is: '{self.display}'")
+        return self
+
+    def enter(self):
+        try:
+            # Simple expression evaluation using eval
+            # Note: Using eval is not recommended for production code
+            # This is just for testing purposes
+            result = eval(self.display)
+            self.display = str(result)
+        except Exception as error:
+            self.display = "Error"
+        return self
+
+    def memory_store(self):
+        try:
+            value = float(self.display) if self.display else 0
+            self.set_value("memory", value)
+            self.clear()
+        except:
+            pass
+        return self
+
+    def memory_recall(self):
+        memory_value = self.get_value("memory") or 0
+        self.display = str(memory_value)
+        return self
+
+    def memory_clear(self):
+        self.set_value("memory", 0)
+        return self
+
+    def memory_add(self):
+        try:
+            current_value = float(self.display) if self.display else 0
+            memory_value = self.get_value("memory") or 0
+            self.set_value("memory", memory_value + current_value)
+            self.clear()
+        except:
+            pass
+        return self
+
+    def get_display(self):
+        print(f"[CALCULATOR {self.id}] getDisplay: '{self.display}'")
+        return self.display
+
+    def clear(self):
+        self.display = ""
+        return self
+
+    # Keep these methods for compatibility
+    def add(self, a, b):
+        return a + b
+
+    def subtract(self, a, b):
+        return a - b
+
+    def multiply(self, a, b):
+        return a * b
+
+    def divide(self, a, b):
+        if b == 0:
+            raise ValueError("Cannot divide by zero")
+        return a / b
+
+    def set_value(self, identifier, value):
+        self.values[identifier] = value
+
+    def get_value(self, identifier):
+        return self.values.get(identifier, None)

package/example/Calculator.test.adapter.ts

@@ -0,0 +1,86 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+// import { ITestAdapter } from "testeranto/src/CoreTypes";
+import { ITestAdapter } from "../src/CoreTypes";
+import { Calculator } from "./Calculator";
+import { I } from "./Calculator.test.types";
+import { ITTestResourceConfiguration } from "testeranto/src/lib";
+// import { IPM } from "testeranto/src/lib/types";
+
+export const adapter: ITestAdapter<I> = {
+  beforeAll: async (input, testResource, pm) => {
+    console.log("[ADAPTER] beforeAll called with input:", input);
+    // input is the Calculator constructor
+    return input;
+  },
+
+  beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+    console.log("[ADAPTER] beforeEach called with subject:", subject);
+    const result = await initializer();
+    console.log("[ADAPTER] beforeEach result:", result);
+    console.log("[ADAPTER] display:", result.getDisplay());
+    // Make sure we always have a valid Calculator instance
+    // if (!result) {
+    //   throw new Error("Initializer did not return a valid Calculator instance");
+    // }
+    // Ensure the display is empty
+    // result.clear();
+    return result;
+  },
+
+  andWhen: async (store, whenCB, testResource, pm) => {
+    console.log("[ADAPTER] andWhen called");
+    console.log("[ADAPTER] store display:", store.getDisplay());
+
+    // The whenCB should be a function that returns a function which takes the store
+    // For press("2"), whenCB is (calculator) => { calculator.press("2"); return calculator; }
+    try {
+      console.log("[ADAPTER] Calling whenCB which should return a function");
+      // whenCB is a function that returns a transformation function
+      const transform = whenCB;
+      console.log("[ADAPTER] Transform function:", transform);
+
+      // Apply the transformation to the store
+      const result = transform(store);
+      console.log("[ADAPTER] Result display:", result.getDisplay());
+
+      // Verify the result is a Calculator instance
+      if (!(result instanceof Calculator)) {
+        throw new Error(`Expected Calculator instance, got ${typeof result}`);
+      }
+      return result;
+    } catch (e) {
+      console.error("[ADAPTER] Error in andWhen:", e);
+      throw e;
+    }
+  },
+  butThen: async (store, thenCB, testResource, pm) => {
+    console.log("[ADAPTER] butThen called with store:", store);
+    // thenCB is the function that takes the store and makes assertions
+    try {
+      // Run the then callback which may throw if assertion fails
+      thenCB(store);
+      // Return the selection (the display value)
+      const display = store.getDisplay();
+      console.log("[ADAPTER] butThen returning selection:", display);
+      return display;
+    } catch (e) {
+      console.error("[ADAPTER] Error in butThen:", e);
+      throw e;
+    }
+  },
+  afterEach: async (store, key, pm) => {
+    // Clean up if needed
+    return store;
+  },
+  afterAll: async (store, pm) => {
+    // Clean up if needed
+    return store;
+  },
+
+  assertThis: (actual: string) => {
+    // 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 actual;
+  },
+};

package/example/Calculator.test.implementation.ts

@@ -0,0 +1,82 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+// import { ITestImplementation } from "testeranto/src/CoreTypes";
+import { I, O, M } from "./Calculator.test.types";
+import { Calculator } from "./Calculator";
+import { ITestImplementation } from "../src/CoreTypes";
+import { assert } from "chai";
+
+export const implementation: ITestImplementation<I, O, M> = {
+  suites: {
+    Default: "Default test suite for Calculator",
+  },
+
+  givens: {
+    Default: () => {
+      const calc = new Calculator();
+      console.log(
+        "[IMPLEMENTATION] Default given, display:",
+        calc.getDisplay()
+      );
+      return calc;
+    },
+  },
+
+  whens: {
+    press: (button: string) => (calculator: Calculator) => {
+      console.log("[IMPLEMENTATION] press called with button:", button);
+      console.log(
+        "[IMPLEMENTATION] calculator before press:",
+        calculator.getDisplay()
+      );
+
+      const result = calculator.press(button);
+      console.log(
+        "[IMPLEMENTATION] calculator after press:",
+        result.getDisplay()
+      );
+
+      return result;
+    },
+    enter: () => (calculator: Calculator) => {
+      console.log("[IMPLEMENTATION] enter called");
+      console.log(
+        "[IMPLEMENTATION] calculator before enter:",
+        calculator.getDisplay()
+      );
+      calculator.enter();
+      console.log(
+        "[IMPLEMENTATION] calculator after enter:",
+        calculator.getDisplay()
+      );
+      return calculator;
+    },
+    // Memory operations
+    memoryStore: () => (calculator: Calculator) => {
+      console.log("[IMPLEMENTATION] memoryStore called");
+      calculator.memoryStore();
+      return calculator;
+    },
+    memoryRecall: () => (calculator: Calculator) => {
+      console.log("[IMPLEMENTATION] memoryRecall called");
+      calculator.memoryRecall();
+      return calculator;
+    },
+    memoryClear: () => (calculator: Calculator) => {
+      console.log("[IMPLEMENTATION] memoryClear called");
+      calculator.memoryClear();
+      return calculator;
+    },
+    memoryAdd: () => (calculator: Calculator) => {
+      console.log("[IMPLEMENTATION] memoryAdd called");
+      calculator.memoryAdd();
+      return calculator;
+    },
+  },
+
+  thens: {
+    result: (expected: string) => (calculator: Calculator) => {
+      assert.equal(calculator.getDisplay(), expected);
+    },
+  },
+};

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,130 @@
+/* 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 {
+    console.log(" ---- PRESS ---");
+    // Append the button to the display
+    console.log(
+      `[CALCULATOR ${this.id}] Pressing: ${button}, current display: '${this.display}'`
+    );
+    // Make sure we're actually modifying the instance's display
+    this.display = this.display + button;
+    console.log(`[CALCULATOR ${this.id}] New display is: '${this.display}'`);
+    // Return this to allow method chaining
+    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";
+    }
+  }
+
+  // Memory functions
+  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();
+  }
+
+  // Handle special buttons
+  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 {
+    console.log(" ---- PRESS ---");
+    console.log(
+      `[CALCULATOR ${this.id}] Pressing: ${button}, current display: '${this.display}'`
+    );
+    
+    // Handle special buttons first
+    if (this.handleSpecialButton(button)) {
+      return this;
+    }
+    
+    // For regular buttons, append to display
+    this.display = this.display + button;
+    console.log(`[CALCULATOR ${this.id}] New display is: '${this.display}'`);
+    return this;
+  }
+
+  getDisplay(): string {
+    console.log(`[CALCULATOR ${this.id}] getDisplay: '${this.display}'`);
+    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.