testeranto 0.200.1 → 0.203.0

package/src/components/stateful/TestPage.tsx

@@ -2,7 +2,8 @@
 import React, { useEffect, useState } from 'react';
 import { useLocation, useNavigate, useParams } from 'react-router-dom';
 import { DesignEditor } from '../../../design-editor/DesignEditor';
-import { fetchTestData } from '../../utils/api';
+import { fetchTestData, summaryDotJson } from '../../utils/api';
+import { useWebSocket } from '../../App';
 
 import { TestPageView } from '../pure/TestPageView';
 
@@ -11,6 +12,8 @@ export const TestPage = () => {
   const navigate = useNavigate();
   const location = useLocation();
   const [route, setRoute] = useState('results');
+  const wsContext = useWebSocket();
+  const isConnected = wsContext?.isConnected || false;
 
   // Sync route with hash changes
   useEffect(() => {
@@ -51,33 +54,33 @@ export const TestPage = () => {
       try {
         const [testResponse, metafileRes] = await Promise.all([
           fetchTestData(projectName, testPath, runtime),
-          fetch(`/metafiles/${runtime}/${projectName}.json`)
+          fetch(`metafiles/${runtime}/${projectName}.json`)
         ]);
-        
-        console.log('Fetching test data for:', { projectName, testPath, runtime });
+
+        // console.log('Fetching test data for:', { projectName, testPath, runtime });
         const receivedLogs = await testResponse.logs;
-        console.log('Received logs:', Object.keys(receivedLogs));
+        // console.log('Received logs:', Object.keys(receivedLogs));
         let sourceFiles = {};
         let buildLogs = {};
-        
+
         if (metafileRes.ok) {
           const metafile = await metafileRes.json();
           if (metafile?.metafile?.outputs) {
             // Find input files only for this test's entry point
             const tsSources = new Set<string>();
             const testEntryPoint = `src/${testPath}`;
-              
+
             // First find all outputs that match this test
             const matchingOutputs = Object.entries(metafile.metafile.outputs)
               .filter(([outputPath, output]) => {
                 const normalizedTestPath = testPath.replace(/\./g, '_');
                 const testFileName = testPath.split('/').pop();
                 const testBaseName = testFileName?.split('.').slice(0, -1).join('.');
-                  
+
                 // Also check outputPath normalized for slashes replaced by underscores
                 const normalizedOutputPath = outputPath.replace(/\//g, '_');
-                  
-                return output.entryPoint === testEntryPoint || 
+
+                return output.entryPoint === testEntryPoint ||
                   outputPath.includes(normalizedTestPath) ||
                   normalizedOutputPath.includes(normalizedTestPath) ||
                   (testBaseName && outputPath.includes(testBaseName));
@@ -87,8 +90,8 @@ export const TestPage = () => {
             matchingOutputs.forEach(([_, output]) => {
               Object.keys(output.inputs).forEach(inputPath => {
                 // Check if this input is a source file (TypeScript or Go) and not in node_modules
-                if ((inputPath.endsWith('.ts') || inputPath.endsWith('.tsx') || inputPath.endsWith('.go')) &&
-                    !inputPath.includes('node_modules')) {
+                if ((inputPath.endsWith('.ts') || inputPath.endsWith('.tsx') || inputPath.endsWith('.go') || inputPath.endsWith('.py')) &&
+                  !inputPath.includes('node_modules')) {
                   // Get the full input details from metafile.inputs
                   const inputDetails = metafile.metafile.inputs[inputPath];
                   if (inputDetails) {
@@ -98,8 +101,8 @@ export const TestPage = () => {
                     if (inputPath.endsWith('.ts') || inputPath.endsWith('.tsx')) {
                       inputDetails.imports.forEach(imp => {
                         if ((imp.path.endsWith('.ts') || imp.path.endsWith('.tsx')) &&
-                            !imp.path.includes('node_modules') &&
-                            !imp.external) {
+                          !imp.path.includes('node_modules') &&
+                          !imp.external) {
                           tsSources.add(imp.path);
                         }
                       });
@@ -108,14 +111,14 @@ export const TestPage = () => {
                 }
               });
             });
-              
+
             // Organize source files into directory tree structure
             const fileTree = {};
             const filesList = await Promise.all(
               Array.from(tsSources).map(async (filePath) => {
                 try {
-                  const fetchPath = filePath.startsWith('/') 
-                    ? filePath 
+                  const fetchPath = filePath.startsWith('/')
+                    ? filePath
                     : `/${filePath.replace(/^\.\//, '')}`;
                   const res = await fetch(fetchPath);
                   if (res.ok) {
@@ -134,10 +137,10 @@ export const TestPage = () => {
 
             filesList.forEach(file => {
               if (!file) return;
-                
+
               const parts = file.path.split('/');
               let currentLevel = fileTree;
-                
+
               parts.forEach((part, index) => {
                 if (!currentLevel[part]) {
                   if (index === parts.length - 1) {
@@ -163,7 +166,7 @@ export const TestPage = () => {
         receivedLogs['build_logs'] = buildLogs;
         console.log('Source files structure:', sourceFiles);
         console.log('Build logs:', buildLogs);
-        
+
         // Ensure tests.json is properly formatted
         if (receivedLogs['tests.json']) {
           console.log('tests.json content type:', typeof receivedLogs['tests.json']);
@@ -183,7 +186,7 @@ export const TestPage = () => {
         // setLintErrors(testResponse.lintErrors);
 
         try {
-          const summaryResponse = await fetch(`/reports/${projectName}/summary.json`);
+          const summaryResponse = await fetch(summaryDotJson(projectName));
           if (!summaryResponse.ok) throw new Error('Failed to fetch summary');
           const allSummaries = await summaryResponse.json();
           const testSummary = allSummaries[testPath];
@@ -211,11 +214,11 @@ export const TestPage = () => {
           const pathParts = testPath.split('/');
           const fileName = pathParts.pop();
           const directoryPath = pathParts.join('/');
-          
+
           // Construct the path without the filename without extension
           const buildUrl = `/reports/${projectName}/${directoryPath}/${runtime}/build.json`;
           console.log(`Fetching build.json from: ${buildUrl}`);
-          
+
           const buildResponse = await fetch(buildUrl);
           if (buildResponse.ok) {
             const buildData = await buildResponse.json();
@@ -259,6 +262,7 @@ export const TestPage = () => {
         logs={logs}
         testsExist={testsExist}
         errorCounts={errorCounts}
+        isWebSocketConnected={isConnected}
       />
     </>
   );

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/example/go.mod

@@ -0,0 +1,9 @@
+module example
+
+go 1.19
+
+replace testeranto/src/golingvu => ../../src/golingvu
+
+require (
+    testeranto/src/golingvu v0.0.0
+)

package/src/example/main.go

@@ -0,0 +1,61 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+	"testeranto/src/golingvu"
+)
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+func main() {
+	if len(os.Args) < 2 {
+		fmt.Println("Usage: go run main.go <test-resources-json>")
+		os.Exit(1)
+	}
+
+	// Parse test resource configuration
+	var testResourceConfig golingvu.ITTestResourceConfiguration
+	err := json.Unmarshal([]byte(os.Args[1]), &testResourceConfig)
+	if err != nil {
+		fmt.Printf("Error parsing test resources: %v\n", err)
+		os.Exit(1)
+	}
+
+	// Here you would set up your test runner
+	// For now, this is a placeholder
+	fmt.Println("Golang test runner started")
+	fmt.Printf("Test resources: %+v\n", testResourceConfig)
+	
+	// The actual test execution would go here
+	// You would need to integrate with your test framework
+	
+	// Write a basic tests.json to satisfy the framework
+	testsJsonPath := filepath.Join(testResourceConfig.Fs, "tests.json")
+	basicTestResult := map[string]interface{}{
+		"tests":    []interface{}{},
+		"features": []interface{}{},
+		"givens":   []interface{}{},
+	}
+	
+	data, err := json.MarshalIndent(basicTestResult, "", "  ")
+	if err != nil {
+		fmt.Printf("Error marshaling tests.json: %v\n", err)
+		os.Exit(1)
+	}
+	
+	err = os.WriteFile(testsJsonPath, data, 0644)
+	if err != nil {
+		fmt.Printf("Error writing tests.json: %v\n", err)
+		os.Exit(1)
+	}
+	
+	fmt.Println("Test execution completed")
+}

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,5 +1,7 @@
 package golingvu
 
+import "fmt"
+
 // BaseGiven represents a base Given condition
 type BaseGiven struct {
 	Name           string
@@ -47,11 +49,21 @@ 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,
+		"whens":    whenObjs,
+		"thens":    thenObjs,
 		"error":    bg.Error,
 		"failed":   bg.Failed,
 		"features": bg.Features,
@@ -74,3 +86,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.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
+}