testeranto 0.202.0 → 0.205.0

package/src/app/types.ts

@@ -0,0 +1 @@
+export type IMode = "once" | "dev";

package/src/builders/golang.ts

@@ -0,0 +1,29 @@
+console.log("Golang build process started");
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+async function runGolangBuild() {
+    try {
+        // Build Go code
+        console.log("Building Go code...");
+        const { stdout, stderr } = await execAsync('go build -o /tmp/golang-build ./example/Calculator.go');
+        if (stdout) console.log(stdout);
+        if (stderr) console.error(stderr);
+        
+        // Run tests if they exist
+        console.log("Running Go tests...");
+        const testResult = await execAsync('go test ./...');
+        if (testResult.stdout) console.log(testResult.stdout);
+        if (testResult.stderr) console.error(testResult.stderr);
+        
+        console.log("Golang build completed successfully");
+    } catch (error) {
+        console.error("Golang build failed:", error);
+        process.exit(1);
+    }
+}
+
+runGolangBuild();

package/src/builders/node.ts

@@ -0,0 +1,34 @@
+console.log("Node build process started");
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+async function runNodeBuild() {
+    try {
+        // Install dependencies
+        console.log("Installing Node.js dependencies...");
+        const installResult = await execAsync('npm install');
+        if (installResult.stdout) console.log(installResult.stdout);
+        
+        // Run tests
+        console.log("Running Node.js tests...");
+        const testResult = await execAsync('npm test');
+        if (testResult.stdout) console.log(testResult.stdout);
+        if (testResult.stderr) console.error(testResult.stderr);
+        
+        // Build the project
+        console.log("Building Node.js project...");
+        const buildResult = await execAsync('npm run build');
+        if (buildResult.stdout) console.log(buildResult.stdout);
+        if (buildResult.stderr) console.error(buildResult.stderr);
+        
+        console.log("Node.js build completed successfully");
+    } catch (error) {
+        console.error("Node.js build failed:", error);
+        process.exit(1);
+    }
+}
+
+runNodeBuild();

package/src/builders/python.ts

@@ -0,0 +1,28 @@
+console.log("Python build process started");
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+async function runPythonBuild() {
+    try {
+        // Run Python syntax check using local environment
+        console.log("Checking Python syntax...");
+        const syntaxCheck = await execAsync('python3 -m py_compile ./example/Calculator.py');
+        if (syntaxCheck.stdout) console.log(syntaxCheck.stdout);
+        
+        // Run Python tests if they exist using local environment
+        console.log("Running Python tests...");
+        const testResult = await execAsync('python3 -m pytest ./example/ -v');
+        if (testResult.stdout) console.log(testResult.stdout);
+        if (testResult.stderr) console.error(testResult.stderr);
+        
+        console.log("Python build completed successfully");
+    } catch (error) {
+        console.error("Python build failed:", error);
+        process.exit(1);
+    }
+}
+
+runPythonBuild();

package/src/builders/web.ts

@@ -0,0 +1,34 @@
+console.log("Web build process started");
+
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+
+async function runWebBuild() {
+    try {
+        // Install dependencies
+        console.log("Installing web dependencies...");
+        const installResult = await execAsync('npm install');
+        if (installResult.stdout) console.log(installResult.stdout);
+        
+        // Run linting
+        console.log("Running linting...");
+        const lintResult = await execAsync('npm run lint');
+        if (lintResult.stdout) console.log(lintResult.stdout);
+        if (lintResult.stderr) console.error(lintResult.stderr);
+        
+        // Build the web assets
+        console.log("Building web assets...");
+        const buildResult = await execAsync('npm run build');
+        if (buildResult.stdout) console.log(buildResult.stdout);
+        if (buildResult.stderr) console.error(buildResult.stderr);
+        
+        console.log("Web build completed successfully");
+    } catch (error) {
+        console.error("Web build failed:", error);
+        process.exit(1);
+    }
+}
+
+runWebBuild();

package/src/cjs-shim.js

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-undef */
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import url from 'node:url';

package/src/esbuildConfigs/node.ts

@@ -23,7 +23,7 @@ export default (
 
     outdir: `testeranto/bundles/node/${testName}/`,
 
-    inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
+    // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
     metafile: true,
     supported: {
       "dynamic-import": true,

package/src/golingvu/PM/golang_test.go

@@ -0,0 +1,103 @@
+// package golingvu
+
+// import (
+// 	"fmt"
+// 	"net"
+// 	"testing"
+// 	"time"
+// )
+
+// func TestPM_Golang_Stop(t *testing.T) {
+// 	// Create a test configuration
+// 	testConfig := ITTestResourceConfiguration{
+// 		Name:  "test",
+// 		Fs:    "./",
+// 		Ports: []int{},
+// 	}
+
+// 	// Test that Stop method exists and can be called
+// 	pm := &PM_Golang{
+// 		testResourceConfiguration: testConfig,
+// 		client:                    nil,
+// 	}
+
+// 	// This should not panic - test that the method exists
+// 	err := pm.Stop()
+// 	if err != nil {
+// 		t.Errorf("Stop() should return nil when client is nil, got: %v", err)
+// 	}
+
+// 	// Test with a mock connection
+// 	// Create a temporary listener to test connection handling
+// 	ln, err := net.Listen("unix", "/tmp/test_socket_"+fmt.Sprintf("%d", time.Now().UnixNano()))
+// 	if err != nil {
+// 		t.Fatalf("Failed to create listener: %v", err)
+// 	}
+// 	defer ln.Close()
+
+// 	// Connect to the listener
+// 	conn, err := net.Dial("unix", ln.Addr().String())
+// 	if err != nil {
+// 		t.Fatalf("Failed to dial: %v", err)
+// 	}
+
+// 	pmWithConn := &PM_Golang{
+// 		testResourceConfiguration: testConfig,
+// 		client:                    conn,
+// 	}
+
+// 	// Stop should close the connection
+// 	err = pmWithConn.Stop()
+// 	if err != nil {
+// 		t.Errorf("Stop() should close connection successfully, got: %v", err)
+// 	}
+
+// 	// The connection should now be closed
+// 	_, err = conn.Write([]byte("test"))
+// 	if err == nil {
+// 		t.Error("Connection should be closed after Stop()")
+// 	}
+// }
+
+// // TestPM_Golang_Start tests that the Start method exists
+// func TestPM_Golang_Start(t *testing.T) {
+// 	testConfig := ITTestResourceConfiguration{
+// 		Name:  "test",
+// 		Fs:    "./",
+// 		Ports: []int{},
+// 	}
+
+// 	pm := &PM_Golang{
+// 		testResourceConfiguration: testConfig,
+// 		client:                    nil,
+// 	}
+
+// 	// Test that Start method exists and can be called
+// 	err := pm.Start()
+// 	if err != nil {
+// 		t.Errorf("Start() should return nil, got: %v", err)
+// 	}
+// }
+
+// func TestPM_Golang_WriteFileSync(t *testing.T) {
+// 	testConfig := ITTestResourceConfiguration{
+// 		Name:  "test",
+// 		Fs:    "./",
+// 		Ports: []int{},
+// 	}
+
+// 	pm := &PM_Golang{
+// 		testResourceConfiguration: testConfig,
+// 		client:                    nil,
+// 	}
+
+// 	// Test that WriteFileSync method exists and can be called
+// 	// Since we don't have a real connection, this will fail, but we just want to check compilation
+// 	_, err := pm.WriteFileSync("test.txt", "content", "testName")
+// 	// We expect an error due to nil client, but the method should exist
+// 	if err == nil {
+// 		t.Log("WriteFileSync method exists and was called")
+// 	} else {
+// 		t.Logf("WriteFileSync method exists but returned error (expected): %v", err)
+// 	}
+// }

package/src/golingvu/README.md

@@ -1,3 +1,187 @@
-# Golingvu
+# Golingvu - Testeranto Implementation for Go
 
-## implementation of testeranto in "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/src/golingvu/base_given.go

@@ -1,23 +1,24 @@
 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{}
+	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())
+	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
@@ -28,9 +29,9 @@ func (bg *BaseGiven) AddArtifact(path string) {
 }
 
 // NewBaseGiven creates a new BaseGiven instance
-func NewBaseGiven(name string, features []string, whens []*BaseWhen, thens []*BaseThen, givenCB, initialValues interface{}) *BaseGiven {
+func NewBaseGiven(key string, features []string, whens []*BaseWhen, thens []*BaseThen, givenCB, initialValues interface{}) *BaseGiven {
 	return &BaseGiven{
-		Name:          name,
+		Key:           key,
 		Features:      features,
 		Whens:         whens,
 		Thens:         thens,
@@ -47,14 +48,24 @@ func (bg *BaseGiven) BeforeAll(store interface{}) interface{} {
 
 // 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":    bg.Whens,
-		"thens":    bg.Thens,
-		"error":    bg.Error,
-		"failed":   bg.Failed,
-		"features": bg.Features,
+		"key": bg.Key,
+
+		"whens":     whenObjs,
+		"thens":     thenObjs,
+		"error":     bg.Error,
+		"failed":    bg.Failed,
+		"features":  bg.Features,
 		"artifacts": bg.Artifacts,
 	}
 }
@@ -74,3 +85,78 @@ func (bg *BaseGiven) AfterEach(store interface{}, key string, artifactory, pm in
 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.Key)
+
+	// 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
+}

package/src/golingvu/base_suite.go

@@ -2,23 +2,64 @@ package golingvu
 
 // BaseSuite represents a test suite
 type BaseSuite struct {
-	Name           string
-	Givens         map[string]*BaseGiven
-	AfterAllFunc   func(store interface{}, artifactory func(string, interface{}), pm interface{}) interface{}
-	AssertThatFunc func(t interface{}) bool
-	SetupFunc      func(s interface{}, artifactory func(string, interface{}), tr ITTestResourceConfiguration, pm interface{}) interface{}
+	Key                       string
+	Givens                    map[string]*BaseGiven
+	AfterAllFunc              func(store interface{}, artifactory func(string, interface{}), pm interface{}) interface{}
+	AssertThatFunc            func(t interface{}) bool
+	SetupFunc                 func(s interface{}, artifactory func(string, interface{}), tr ITTestResourceConfiguration, pm interface{}) interface{}
+	Store                     interface{}
+	TestResourceConfiguration ITTestResourceConfiguration
+	Index                     int
+	Failed                    bool
+	Fails                     int
+	Artifacts                 []string
 }
 
 // Run executes the test suite
 func (bs *BaseSuite) Run(input interface{}, testResourceConfiguration ITTestResourceConfiguration, artifactory func(string, interface{}), tLog func(...string), pm interface{}) (*BaseSuite, error) {
-	// Implementation would go here
+	bs.TestResourceConfiguration = testResourceConfiguration
+
+	// Setup
+	subject := bs.SetupFunc(input, artifactory, testResourceConfiguration, pm)
+
+	// Run each given
+	for gKey, g := range bs.Givens {
+		_, err := g.Give(
+			subject,
+			gKey,
+			testResourceConfiguration,
+			bs.AssertThatFunc,
+			artifactory,
+			tLog,
+			pm,
+			bs.Index,
+		)
+		if err != nil {
+			bs.Failed = true
+			bs.Fails++
+			return bs, err
+		}
+	}
+
+	// After all
+	bs.AfterAllFunc(bs.Store, artifactory, pm)
+
 	return bs, nil
 }
 
 // ToObj converts the suite to a serializable object
 func (bs *BaseSuite) ToObj() map[string]interface{} {
+	givens := make([]map[string]interface{}, 0)
+	for _, given := range bs.Givens {
+		givens = append(givens, given.ToObj())
+	}
+
 	return map[string]interface{}{
-		"name": bs.Name,
+		"key":      bs.Key,
+		"givens":   givens,
+		"fails":    bs.Fails,
+		"failed":   bs.Failed,
+		"features": bs.Features(),
 	}
 }
 
@@ -26,7 +67,7 @@ func (bs *BaseSuite) ToObj() map[string]interface{} {
 func (bs *BaseSuite) Features() []string {
 	features := make([]string, 0)
 	seen := make(map[string]bool)
-	
+
 	for _, given := range bs.Givens {
 		for _, feature := range given.Features {
 			if !seen[feature] {
@@ -37,3 +78,8 @@ func (bs *BaseSuite) Features() []string {
 	}
 	return features
 }
+
+// AddArtifact adds an artifact to the suite
+func (bs *BaseSuite) AddArtifact(path string) {
+	bs.Artifacts = append(bs.Artifacts, path)
+}