testeranto 0.203.0 → 0.206.0

package/example/Calculator.test.adapter.ts

@@ -1,73 +1,33 @@
 /* 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;
-    }
+    const transform = whenCB;
+    const result = transform(store);
+    return result;
   },
   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;
-    }
+    thenCB(store);
+
+    const display = store.getDisplay();
+
+    return display;
   },
   afterEach: async (store, key, pm) => {
     // Clean up if needed

package/example/Calculator.test.implementation.ts

@@ -1,6 +1,7 @@
 /* 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";
@@ -14,61 +15,33 @@ export const implementation: ITestImplementation<I, O, M> = {
   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;
     },

package/example/Calculator.ts

@@ -5,15 +5,7 @@ export class Calculator {
   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;
   }
 
@@ -26,10 +18,10 @@ export class Calculator {
       this.display = result.toString();
     } catch (error) {
       this.display = "Error";
+      throw error;
     }
   }
 
-  // Memory functions
   memoryStore(): void {
     this.setValue("memory", parseFloat(this.display) || 0);
     this.clear();
@@ -51,7 +43,6 @@ export class Calculator {
     this.clear();
   }
 
-  // Handle special buttons
   handleSpecialButton(button: string): boolean {
     switch (button) {
       case "C":
@@ -75,24 +66,17 @@ export class Calculator {
   }
 
   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;
   }
 

package/example/go.mod

@@ -4,6 +4,4 @@ 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
+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/vendor/github.com/adamwong246/testeranto/src/golingvu/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 [Adam Wong, Demiurge Labs]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/example/vendor/github.com/adamwong246/testeranto/src/golingvu/README.md

@@ -0,0 +1,187 @@
+# Golingvu - Testeranto Implementation for Go
+
+## Understanding the Build Process
+
+The build process in Testeranto is inspired by esbuild's approach to bundling and metafile generation, adapted for multiple programming languages including Go, Python, and JavaScript variants.
+
+### Core Concepts
+
+#### 1. Metafile Generation
+Each language implementation generates a `core.json` metafile that tracks:
+- **Inputs**: Source files with their dependencies (imports) and metadata
+- **Outputs**: Generated/bundled files with their relationships to inputs
+- **Signatures**: Unique identifiers to track changes and trigger rebuilds
+
+#### 2. File Watching
+Two separate watchers work in tandem:
+1. **Source Watcher**: Monitors source files for changes and triggers metafile regeneration
+2. **Bundle Watcher**: Monitors generated files and schedules test execution when signatures change
+
+#### 3. Signature-based Change Detection
+- Each output file contains a unique signature in a comment
+- When source files change, new signatures are generated
+- Bundle watcher detects signature changes to trigger test execution
+
+### How esbuild's Approach is Adapted
+
+#### Original esbuild Flow:
+1. Parse entry points and resolve imports
+2. Bundle dependencies into output files
+3. Generate metafile with input/output relationships
+4. Watch for file changes and rebuild
+
+#### Testeranto Adaptation:
+1. **For each language**: Parse entry points and track dependencies
+2. **Instead of bundling**: Generate wrapper files that import/run the original tests
+3. **Generate metafile**: Track relationships between source files and generated wrappers
+4. **Watch system**: Dual watchers for source changes and bundle updates
+
+### Implementation Pattern for New Languages
+
+To add support for a new language (e.g., Rust, Java, C#), follow this pattern:
+
+#### 1. Metafile Generator (`src/utils/[language]Metafile.ts`)
+```typescript
+export async function generate[Language]Metafile(
+  testName: string,
+  entryPoints: string[]
+): Promise<[Language]Metafile> {
+  // Parse entry point files to find imports/dependencies
+  // Generate unique signature
+  // Return metafile structure with inputs and outputs
+}
+
+export function write[Language]Metafile(
+  testName: string,
+  metafile: [Language]Metafile
+): void {
+  // Write metafile to disk
+  // Generate output wrapper files with signatures
+}
+```
+
+#### 2. File Watcher (`src/utils/[language]Watcher.ts`)
+```typescript
+export class [Language]Watcher {
+  async start() {
+    // Set up source file watcher
+    // Set up bundle file watcher
+    // Handle file change events
+  }
+  
+  private async regenerateMetafile() {
+    // Regenerate metafile and output files
+  }
+}
+```
+
+#### 3. Language-specific Types (`src/[language]/types.[ext]`)
+Define interfaces for:
+- Test adapters
+- Resource configurations
+- Base test components (Given, When, Then)
+
+#### 4. Process Manager (`src/[language]/PM/[language].go`)
+Implement process communication for:
+- Starting/stopping tests
+- IPC communication
+- Resource management
+
+### Key Implementation Details
+
+#### Signature Handling
+- Use timestamp-based or content-hash signatures
+- Embed signatures in comments to avoid breaking code
+- Ensure consistent output filenames for reliable watching
+
+#### File Watching Strategy
+- Use `chokidar` for Node.js-based watching
+- Implement polling for reliability across filesystems
+- Handle edge cases: file deletions, renames, permission changes
+
+#### Metafile Structure
+```json
+{
+  "errors": [],
+  "warnings": [],
+  "metafile": {
+    "inputs": {
+      "path/to/file.ext": {
+        "bytes": 1024,
+        "imports": ["dependency1", "dependency2"]
+      }
+    },
+    "outputs": {
+      "output/path/file.ext": {
+        "imports": [],
+        "exports": [],
+        "entryPoint": "original/file.ext",
+        "inputs": {
+          "original/file.ext": {
+            "bytesInOutput": 1024
+          }
+        },
+        "bytes": 1024,
+        "signature": "unique_id"
+      }
+    }
+  }
+}
+```
+
+### Current Language Implementations
+
+#### Go (Golingvu)
+- **Entry points**: `.go` files with test functions
+- **Output**: Wrapper files that run `go test`
+- **Signature**: Timestamp in comments
+
+#### Python (Pitono)
+- **Entry points**: `.py` files with test cases
+- **Output**: Python modules with test runners
+- **Signature**: Content hash or timestamp
+
+#### JavaScript/TypeScript
+- **Entry points**: `.js`/`.ts` files
+- **Output**: Bundled JavaScript with esbuild
+- **Signature**: Integrated into build process
+
+### Common Challenges and Solutions
+
+1. **File Change Detection**
+   - Use polling with appropriate intervals
+   - Handle filesystem event limitations
+   - Implement manual fallback checks
+
+2. **Dependency Resolution**
+   - Parse language-specific import syntax
+   - Handle relative vs absolute imports
+   - Account for language-specific module systems
+
+3. **Cross-platform Compatibility**
+   - Normalize file paths
+   - Handle different line endings
+   - Account for filesystem case sensitivity
+
+4. **Performance**
+   - Debounce file change events
+   - Cache parsing results where possible
+   - Use efficient data structures for dependency tracking
+
+### Testing the Implementation
+
+For each new language, verify:
+1. Source file changes trigger metafile regeneration
+2. Bundle file changes trigger test execution
+3. Signatures are properly updated and detected
+4. All file paths are handled consistently
+5. Error cases are properly handled (missing files, parse errors)
+
+### Future Considerations
+
+- **Incremental builds**: Only rebuild changed portions
+- **Dependency caching**: Store parsed dependencies to avoid re-parsing
+- **Cross-language dependencies**: Handle cases where tests in one language depend on another
+- **Remote execution**: Support running tests in containers or remote environments
+
+This pattern allows Testeranto to maintain a consistent architecture while supporting multiple programming languages, each with their own unique characteristics and requirements.

package/example/vendor/github.com/adamwong246/testeranto/src/golingvu/base_given.go

@@ -0,0 +1,163 @@
+package golingvu
+
+import "fmt"
+
+// BaseGiven represents a base Given condition
+type BaseGiven struct {
+	Name           string
+	Features       []string
+	Whens          []*BaseWhen
+	Thens          []*BaseThen
+	Error          error
+	Fail           interface{}
+	Store          interface{}
+	RecommendedFsPath string
+	GivenCB        interface{}
+	InitialValues  interface{}
+	Key            string
+	Failed         bool
+	Artifacts      []string
+	GivenThatFunc  func(subject, testResource, artifactory, initializer, initialValues, pm interface{}) (interface{}, error)
+	AfterEachFunc  func(store interface{}, key string, artifactory, pm interface{}) (interface{}, error)
+	UberCatcherFunc func(func())
+}
+
+// AddArtifact adds an artifact path
+func (bg *BaseGiven) AddArtifact(path string) {
+	// Normalize path separators
+	// For simplicity, we'll assume paths are already normalized
+	bg.Artifacts = append(bg.Artifacts, path)
+}
+
+// NewBaseGiven creates a new BaseGiven instance
+func NewBaseGiven(name string, features []string, whens []*BaseWhen, thens []*BaseThen, givenCB, initialValues interface{}) *BaseGiven {
+	return &BaseGiven{
+		Name:          name,
+		Features:      features,
+		Whens:         whens,
+		Thens:         thens,
+		GivenCB:       givenCB,
+		InitialValues: initialValues,
+		Artifacts:     make([]string, 0),
+	}
+}
+
+// BeforeAll is called before all tests
+func (bg *BaseGiven) BeforeAll(store interface{}) interface{} {
+	return store
+}
+
+// ToObj converts the instance to a map for serialization
+func (bg *BaseGiven) ToObj() map[string]interface{} {
+	whenObjs := make([]map[string]interface{}, len(bg.Whens))
+	for i, w := range bg.Whens {
+		whenObjs[i] = w.ToObj()
+	}
+	
+	thenObjs := make([]map[string]interface{}, len(bg.Thens))
+	for i, t := range bg.Thens {
+		thenObjs[i] = t.ToObj()
+	}
+	
+	return map[string]interface{}{
+		"key":      bg.Key,
+		"name":     bg.Name,
+		"whens":    whenObjs,
+		"thens":    thenObjs,
+		"error":    bg.Error,
+		"failed":   bg.Failed,
+		"features": bg.Features,
+		"artifacts": bg.Artifacts,
+	}
+}
+
+// GivenThat is an abstract method to be implemented
+func (bg *BaseGiven) GivenThat(subject, testResourceConfiguration, artifactory, givenCB, initialValues, pm interface{}) (interface{}, error) {
+	// To be implemented by concrete types
+	return nil, nil
+}
+
+// AfterEach is called after each test
+func (bg *BaseGiven) AfterEach(store interface{}, key string, artifactory, pm interface{}) (interface{}, error) {
+	return store, nil
+}
+
+// UberCatcher handles errors
+func (bg *BaseGiven) UberCatcher(e error) {
+	bg.Error = e
+}
+
+// Give executes the given condition
+func (bg *BaseGiven) Give(
+	subject interface{},
+	key string,
+	testResourceConfiguration ITTestResourceConfiguration,
+	tester func(interface{}) bool,
+	artifactory func(string, interface{}),
+	tLog func(...string),
+	pm interface{},
+	suiteNdx int,
+) (interface{}, error) {
+	bg.Key = key
+	tLog("\n " + bg.Key)
+	tLog("\n Given: " + bg.Name)
+
+	// Setup
+	store, err := bg.GivenThat(
+		subject,
+		testResourceConfiguration,
+		artifactory,
+		bg.GivenCB,
+		bg.InitialValues,
+		pm,
+	)
+	if err != nil {
+		bg.Failed = true
+		bg.Error = err
+		return nil, err
+	}
+	bg.Store = store
+
+	// Process Whens
+	for whenNdx, when := range bg.Whens {
+		_, err := when.Test(
+			bg.Store,
+			testResourceConfiguration,
+			tLog,
+			pm,
+			fmt.Sprintf("suite-%d/given-%s/when/%d", suiteNdx, key, whenNdx),
+		)
+		if err != nil {
+			bg.Failed = true
+			bg.Error = err
+			return nil, err
+		}
+	}
+
+	// Process Thens
+	for thenNdx, then := range bg.Thens {
+		result, err := then.Test(
+			bg.Store,
+			testResourceConfiguration,
+			tLog,
+			pm,
+			fmt.Sprintf("suite-%d/given-%s/then-%d", suiteNdx, key, thenNdx),
+		)
+		if err != nil {
+			bg.Failed = true
+			bg.Error = err
+			return nil, err
+		}
+		tester(result)
+	}
+
+	// Cleanup
+	_, err = bg.AfterEach(bg.Store, bg.Key, artifactory, pm)
+	if err != nil {
+		bg.Failed = true
+		bg.Error = err
+		return nil, err
+	}
+
+	return bg.Store, nil
+}