testeranto 0.231.0 → 0.233.0

package/Cargo.toml

@@ -7,17 +7,15 @@ edition = "2021"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 md5 = "0.8.0"
-rusto = "0.0.1"
+rusto = { path = "src/lib/rusto", version = "0.1.22" }
 
 [lib]
-name = "rubeno" # The name of the library (defaults to package name)
-path = "src/lib.rs" # The entry point for the library
-crate-type = [
-  "rlib",
-] # The type of library to produce (e.g., rlib, dylib, staticlib)
-test = false # Whether to build/run unit tests by default
-doctest = false # Whether to run documentation tests
-bench = false # Whether to run benchmarks
-doc = true # Whether to include this in documentation
-proc-macro = false # Set to true if this is a procedural macro library
-harness = false # Use the standard libtest harness
+name = "rust_server_runtime"
+path = "src/lib.rs"
+crate-type = ["rlib"]
+test = false
+doctest = false
+bench = false
+doc = true
+proc-macro = false
+harness = false

package/README.md

@@ -10,7 +10,7 @@ In more conrete terms, testeranto is
 - a VS code extension
 - integrates static tests, unit tests, integration tests and source code into focused Aider sessions.
 - turns github issues, BDD specs and markdown documentation into packaged artifacts and human readable test reports.
-
+- supports multiple testing patterns: BDD (Given-When-Then), AAA (Arrange-Act-Assert), and TDT (Table Driven Testing)
 - a library of code split across 7 languages and 2 purposes
 
 ## getting started

package/bundle copy.js

@@ -0,0 +1,200 @@
+
+import fs from "fs"
+import path from "path"
+import * as esbuild from 'esbuild'
+
+await esbuild.build({
+  outExtension: { '.js': '.mjs' },
+  entryPoints: [
+    'src/server/runtimes/node/node.ts',
+    'src/server/runtimes/web/web.ts',
+    'src/server/runtimes/web/hoist.ts'
+  ],
+  bundle: true,
+  format: "esm",
+  splitting: false,
+  platform: "node",
+  target: "node20",
+  outdir: "dist/prebuild",
+  packages: "external",
+  // supported: {
+  //   "dynamic-import": true,
+  // },
+  // external: [
+  //   "fs", "path", "child_process", "util", "os", "events", "stream",
+  //   "http", "https", "zlib", "crypto", "buffer", "net", "dns", "tls",
+  //   "assert", "querystring", "punycode", "readline", "repl", "vm",
+  //   "perf_hooks", "async_hooks", "timers", "console", "module", "process",
+  //   "vscode"
+  // ],
+})
+
+await esbuild.build({
+  outExtension: { '.js': '.mjs' },
+  entryPoints: [
+    // 'src/init-docs.ts',
+    'src/esbuildConfigs/eslint-formatter-testeranto.ts',
+    // 'src/server/runtimes/node/node.ts',
+    // 'src/server/runtimes/web/web.ts',
+    // 'src/testeranto.ts',
+    // 'src/server/runtimes/web/hoist.ts'
+  ],
+  bundle: true,
+  format: "esm",
+  splitting: true,
+  platform: "node",
+  target: "node20",
+  outdir: "dist/prebuild",
+  packages: "external",
+  supported: {
+    "dynamic-import": true,
+  },
+  external: [
+    "fs", "path", "child_process", "util", "os", "events", "stream",
+    "http", "https", "zlib", "crypto", "buffer", "net", "dns", "tls",
+    "assert", "querystring", "punycode", "readline", "repl", "vm",
+    "perf_hooks", "async_hooks", "timers", "console", "module", "process",
+    "vscode"
+  ],
+})
+
+// Build VS Code extension
+try {
+  const result = await esbuild.build({
+    entryPoints: ['src/vscode/extension.ts'],
+    bundle: true,
+    format: "esm",  // Use ES modules
+    platform: "node",
+    target: "node20",
+    outdir: "dist/vscode",
+    external: ["vscode"],
+    outExtension: { '.js': '.mjs' },
+    logLevel: 'info',
+  });
+  console.log("VS Code extension built successfully to dist/vscode/extension.mjs");
+} catch (error) {
+  console.error("Failed to build VS Code extension:", error);
+  process.exit(1);
+}
+
+// Copy stakeholder app source for reference
+const stakeholderSrcPath = 'src/stakeholder/DefaultStakeholderApp.tsx';
+const stakeholderDistDir = 'dist/stakeholder';
+const stakeholderDestPath = path.join(stakeholderDistDir, 'DefaultStakeholderApp.tsx');
+
+if (!fs.existsSync(stakeholderDistDir)) {
+  fs.mkdirSync(stakeholderDistDir, { recursive: true });
+}
+
+if (fs.existsSync(stakeholderSrcPath)) {
+  fs.copyFileSync(stakeholderSrcPath, stakeholderDestPath);
+  console.log(`Copied stakeholder app source from ${stakeholderSrcPath} to ${stakeholderDestPath}`);
+} else {
+  console.warn(`Stakeholder source file not found: ${stakeholderSrcPath}`);
+}
+
+// Copy media files for webview
+const mediaDir = 'media';
+const distMediaDir = 'dist/vscode/media';
+
+if (!fs.existsSync(distMediaDir)) {
+  fs.mkdirSync(distMediaDir, { recursive: true });
+}
+
+// Copy icon files
+const mediaFiles = ['icon.svg'];
+for (const file of mediaFiles) {
+  const src = path.join(mediaDir, file);
+  const dest = path.join(distMediaDir, file);
+  if (fs.existsSync(src)) {
+    fs.copyFileSync(src, dest);
+    console.log(`Copied ${src} to ${dest}`);
+  } else {
+    console.warn(`Media file not found: ${src}`);
+  }
+}
+
+// Copy Ruby artifact to dist/ruby folder
+const rubySrcPath = 'src/server/runtimes/ruby/ruby.rb';
+const rubyDistDir = 'dist/ruby';
+const rubyDestPath = path.join(rubyDistDir, 'ruby.rb');
+
+if (!fs.existsSync(rubyDistDir)) {
+  fs.mkdirSync(rubyDistDir, { recursive: true });
+}
+
+if (fs.existsSync(rubySrcPath)) {
+  fs.copyFileSync(rubySrcPath, rubyDestPath);
+  console.log(`Copied Ruby artifact from ${rubySrcPath} to ${rubyDestPath}`);
+} else {
+  console.warn(`Ruby source file not found: ${rubySrcPath}`);
+}
+
+
+
+const pythonSrcPath = 'src/server/runtimes/python/python.py';
+const pythonDistDir = 'dist/python';
+const pythonDestPath = path.join(pythonDistDir, 'python.py');
+
+if (!fs.existsSync(pythonDistDir)) {
+  fs.mkdirSync(pythonDistDir, { recursive: true });
+}
+
+if (fs.existsSync(pythonSrcPath)) {
+  fs.copyFileSync(pythonSrcPath, pythonDestPath);
+  console.log(`Copied Python artifact from ${pythonSrcPath} to ${pythonDestPath}`);
+} else {
+  console.warn(`Python source file not found: ${pythonSrcPath}`);
+}
+
+
+
+const golangSrcPath = 'src/server/runtimes/golang/main.go';
+const golangDistDir = 'dist/golang';
+const golangDestPath = path.join(golangDistDir, 'main.go');
+
+if (!fs.existsSync(golangDistDir)) {
+  fs.mkdirSync(golangDistDir, { recursive: true });
+}
+
+if (fs.existsSync(golangSrcPath)) {
+  fs.copyFileSync(golangSrcPath, golangDestPath);
+  console.log(`Copied Golang artifact from ${golangSrcPath} to ${golangDestPath}`);
+} else {
+  console.warn(`Golang source file not found: ${golangSrcPath}`);
+}
+
+
+
+const rustSrcPath = 'src/server/runtimes/rust/main.rs';
+const rustDistDir = 'dist/rust';
+const rustDestPath = path.join(rustDistDir, 'main.rs');
+
+if (!fs.existsSync(rustDistDir)) {
+  fs.mkdirSync(rustDistDir, { recursive: true });
+}
+
+if (fs.existsSync(rustSrcPath)) {
+  fs.copyFileSync(rustSrcPath, rustDestPath);
+  console.log(`Copied Rust artifact from ${rustSrcPath} to ${rustDestPath}`);
+} else {
+  console.warn(`Golang source file not found: ${rustSrcPath}`);
+}
+
+
+
+const javaSrcPath = 'src/server/runtimes/java/main.java';
+const javaDistDir = 'dist/java';
+const javaDestPath = path.join(javaDistDir, 'main.java');
+
+if (!fs.existsSync(javaDistDir)) {
+  fs.mkdirSync(javaDistDir, { recursive: true });
+}
+
+if (fs.existsSync(javaSrcPath)) {
+  fs.copyFileSync(javaSrcPath, javaDestPath);
+  console.log(`Copied Java artifact from ${javaSrcPath} to ${javaDestPath}`);
+} else {
+  console.warn(`Java source file not found: ${javaSrcPath}`);
+}
+

package/bundle.js

@@ -77,6 +77,25 @@ try {
   process.exit(1);
 }
 
+// Build stakeholder app bundle
+try {
+  const stakeholderResult = await esbuild.build({
+    entryPoints: ['src/server/serverClasses/index.tsx'],
+    bundle: true,
+    format: "esm",
+    platform: "browser",
+    target: "es2020",
+    outdir: "dist/stakeholder",
+    external: ["react", "react-dom"],
+    outExtension: { '.js': '.mjs' },
+    logLevel: 'info',
+  });
+  console.log("Stakeholder app built successfully to dist/stakeholder/index.mjs");
+} catch (error) {
+  console.error("Failed to build stakeholder app:", error);
+  process.exit(1);
+}
+
 // Copy stakeholder app source for reference
 const stakeholderSrcPath = 'src/stakeholder/DefaultStakeholderApp.tsx';
 const stakeholderDistDir = 'dist/stakeholder';

package/dist/golang/main.go

@@ -5,12 +5,12 @@ import (
 	"encoding/hex"
 	"encoding/json"
 	"fmt"
-
-	// "log"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"
+	
+	frameworkconverters "src/server/runtimes/golang/framework-converters"
 )
 
 // Package struct maps the fields we need from 'go list'
@@ -203,7 +203,22 @@ func main() {
 			// Continue anyway, as the build might still work
 		}
 
-		// Collect input files in a simple way, similar to rust builder
+		// Use framework converters to detect test type
+		converter := frameworkconverters.DetectFramework(entryPointPath)
+		fmt.Printf("  Detected framework: %s\n", converter.Name())
+		
+		// Run native detection for more detailed analysis
+		detectionResult, err := TranslateNativeTest(entryPointPath)
+		if err != nil {
+			fmt.Printf("  ⚠️  Native detection failed: %v\n", err)
+			detectionResult = &DetectionResult{
+				IsNativeTest:   true,
+				FrameworkType:  converter.Name(),
+				TestStructure:  map[string]interface{}{},
+			}
+		}
+		
+		// Collect input files
 		var inputs []string
 		
 		// Add the entry point file itself
@@ -211,14 +226,12 @@ func main() {
 		if errRel == nil && !strings.HasPrefix(relEntryToWorkspace, "..") {
 			inputs = append(inputs, relEntryToWorkspace)
 		} else {
-			// Fallback
 			inputs = append(inputs, entryPoint)
 		}
 		
 		// Add go.mod and go.sum if they exist
 		goModPath := filepath.Join(moduleRoot, "go.mod")
-		// goSumPath is already declared above, so use assignment
-		goSumPath = filepath.Join(moduleRoot, "go.sum")
+		goSumPath := filepath.Join(moduleRoot, "go.sum")
 		fmt.Printf("  Module root: %s\n", moduleRoot)
 		fmt.Printf("  go.mod path: %s\n", goModPath)
 		for _, filePath := range []string{goModPath, goSumPath} {
@@ -233,10 +246,9 @@ func main() {
 		}
 		
 		// Add all .go files in the module root and subdirectories
-		// This is similar to rust builder which adds all .rs files in src/
 		errWalk := filepath.Walk(moduleRoot, func(path string, info os.FileInfo, errWalkInner error) error {
 			if errWalkInner != nil {
-				return nil // skip errors
+				return nil
 			}
 			if !info.IsDir() && strings.HasSuffix(path, ".go") {
 				relToWorkspace, errRel := filepath.Rel(workspace, path)
@@ -250,7 +262,50 @@ func main() {
 			fmt.Printf("  ⚠️  Warning while walking directory: %v\n", errWalk)
 		}
 		
-		fmt.Printf("  Found %d input files (simplified collection)\n", len(inputs))
+		fmt.Printf("  Found %d input files\n", len(inputs))
+		
+		// Generate framework-specific wrapper if needed
+		if detectionResult.IsNativeTest {
+			fmt.Printf("  Generating %s wrapper...\n", converter.Name())
+			
+			// Create wrapper directory
+			wrapperDir := filepath.Join(bundlesDir, "wrappers")
+			if err := os.MkdirAll(wrapperDir, 0755); err != nil {
+				fmt.Printf("  ⚠️  Failed to create wrapper directory: %v\n", err)
+			} else {
+				// Convert detection result to map for converter
+				detectionMap := map[string]interface{}{
+					"isNativeTest":  detectionResult.IsNativeTest,
+					"frameworkType": detectionResult.FrameworkType,
+					"testStructure": detectionResult.TestStructure,
+				}
+				
+				// Generate wrapper content
+				wrapperContent := converter.GenerateWrapper(entryPointPath, detectionMap, hash)
+				
+				// Write wrapper file
+				wrapperFileName := fmt.Sprintf("%s_wrapper.go", binaryName)
+				wrapperPath := filepath.Join(wrapperDir, wrapperFileName)
+				if err := os.WriteFile(wrapperPath, []byte(wrapperContent), 0644); err != nil {
+					fmt.Printf("  ⚠️  Failed to write wrapper: %v\n", err)
+				} else {
+					fmt.Printf("  ✅ Wrapper generated: %s\n", wrapperPath)
+					
+					// Also compile the wrapper
+					wrapperExePath := filepath.Join(bundlesDir, fmt.Sprintf("%s_wrapper", binaryName))
+					buildWrapperCmd := exec.Command("go", "build", "-o", wrapperExePath, wrapperPath)
+					buildWrapperCmd.Stdout = os.Stdout
+					buildWrapperCmd.Stderr = os.Stderr
+					buildWrapperCmd.Dir = moduleRoot
+					
+					if err := buildWrapperCmd.Run(); err != nil {
+						fmt.Printf("  ⚠️  Failed to compile wrapper: %v\n", err)
+					} else {
+						fmt.Printf("  ✅ Wrapper compiled: %s\n", wrapperExePath)
+					}
+				}
+			}
+		}
 
 		// Compute hash
 		hash, err2 := computeFilesHash(inputs)