testeranto 0.198.0 → 0.200.0

package/src/PM/pitonoRunner.ts

@@ -0,0 +1,49 @@
+import { execSync } from 'child_process';
+import path from 'path';
+import fs from 'fs';
+import { ITestconfig } from '../lib';
+
+export class PitonoRunner {
+    constructor(private config: ITestconfig, private testName: string) {}
+    
+    async run(): Promise<void> {
+        const coreJsonPath = path.join(process.cwd(), 'testeranto', 'pitono', this.testName, 'core.json');
+        
+        // Wait for the core.json file to be created with a timeout
+        const maxWaitTime = 10000; // 10 seconds
+        const startTime = Date.now();
+        while (!fs.existsSync(coreJsonPath) && (Date.now() - startTime) < maxWaitTime) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        
+        if (!fs.existsSync(coreJsonPath)) {
+            console.error(`Pitono core.json not found at: ${coreJsonPath} after waiting ${maxWaitTime}ms`);
+            return;
+        }
+        
+        try {
+            const coreData = JSON.parse(fs.readFileSync(coreJsonPath, 'utf-8'));
+            const entryPoints = coreData.entryPoints;
+            
+            for (const entryPoint of entryPoints) {
+                try {
+                    console.log(`Running pitono test: ${entryPoint}`);
+                    // Use python to execute the test file
+                    const absolutePath = path.resolve(entryPoint);
+                    // Check if the file exists
+                    if (!fs.existsSync(absolutePath)) {
+                        console.error(`Pitono test file not found: ${absolutePath}`);
+                        continue;
+                    }
+                    execSync(`python "${absolutePath}"`, { stdio: 'inherit' });
+                    console.log(`Pitono test completed: ${entryPoint}`);
+                } catch (error) {
+                    console.error(`Pitono test failed: ${entryPoint}`, error);
+                    throw error;
+                }
+            }
+        } catch (error) {
+            console.error(`Error reading or parsing core.json: ${error}`);
+        }
+    }
+}

package/src/Types.ts

@@ -177,7 +177,7 @@ export type IPluginFactory = (
   entrypoints?: string[]
 ) => Plugin;
 
-export type IRunTime = `node` | `web` | "pure" | `spawn`;
+export type IRunTime = `node` | `web` | "pure" | `golang` | `python`;
 
 export type ITestTypes = [string, IRunTime, { ports: number }, ITestTypes[]];
 

package/src/components/pure/TestPageView.tsx

@@ -125,10 +125,46 @@ export const TestPageView = ({
   const [expandedSections, setExpandedSections] = useState({
     standardLogs: true,
     runtimeLogs: true,
-    sourceFiles: true
+    sourceFiles: true,
+    buildErrors: true,
   });
   const [isNavbarCollapsed, setIsNavbarCollapsed] = useState(false);
 
+  // Extract build errors and warnings relevant to this test
+  const [buildErrors, setBuildErrors] = useState<{ errors: any[]; warnings: any[] }>({ errors: [], warnings: [] });
+
+  useEffect(() => {
+    const metafile = logs.build_logs?.metafile;
+    if (!metafile) {
+      setBuildErrors({ errors: [], warnings: [] });
+      return;
+    }
+    const sourceFilesSet = new Set<string>();
+    // Collect all input files from metafile outputs related to this test
+    Object.entries(metafile.outputs || {}).forEach(([outputPath, output]) => {
+      // Normalize paths for comparison
+      const normalizedTestName = testName.replace(/\\/g, '/');
+      const normalizedEntryPoint = output.entryPoint ? output.entryPoint.replace(/\\/g, '/') : '';
+      if (normalizedEntryPoint.includes(normalizedTestName)) {
+        Object.keys(output.inputs || {}).forEach((inputPath) => {
+          sourceFilesSet.add(inputPath.replace(/\\/g, '/'));
+        });
+      }
+    });
+
+    // Filter errors and warnings to those originating from source files of this test
+    const filteredErrors = (logs.build_logs?.errors || []).filter((err: any) => {
+      if (!err.location || !err.location.file) return false;
+      return sourceFilesSet.has(err.location.file.replace(/\\/g, '/'));
+    });
+    const filteredWarnings = (logs.build_logs?.warnings || []).filter((warn: any) => {
+      if (!warn.location || !warn.location.file) return false;
+      return sourceFilesSet.has(warn.location.file.replace(/\\/g, '/'));
+    });
+
+    setBuildErrors({ errors: filteredErrors, warnings: filteredWarnings });
+  }, [logs, testName]);
+
   // Update customMessage when logs change
   useEffect(() => {
     if (typeof logs['message.txt'] === 'string' && logs['message.txt'].trim()) {
@@ -370,6 +406,50 @@ export const TestPageView = ({
             </div>
           </div>
         ))}
+        {/* Render build errors and warnings */}
+        {(buildErrors.errors.length > 0 || buildErrors.warnings.length > 0) && (
+          <div className="mb-4 card border-danger">
+            <div className="card-header bg-danger text-white">
+              <h4>Build Errors and Warnings</h4>
+            </div>
+            <div className="card-body">
+              {buildErrors.errors.length > 0 && (
+                <>
+                  <h5>Errors</h5>
+                  <ul>
+                    {buildErrors.errors.map((error, idx) => (
+                      <li key={`build-error-${idx}`}>
+                        <strong>{error.text}</strong>
+                        {error.location && (
+                          <div>
+                            File: {error.location.file} Line: {error.location.line} Column: {error.location.column}
+                          </div>
+                        )}
+                      </li>
+                    ))}
+                  </ul>
+                </>
+              )}
+              {buildErrors.warnings.length > 0 && (
+                <>
+                  <h5>Warnings</h5>
+                  <ul>
+                    {buildErrors.warnings.map((warning, idx) => (
+                      <li key={`build-warning-${idx}`}>
+                        <strong>{warning.text}</strong>
+                        {warning.location && (
+                          <div>
+                            File: {warning.location.file} Line: {warning.location.line} Column: {warning.location.column}
+                          </div>
+                        )}
+                      </li>
+                    ))}
+                  </ul>
+                </>
+              )}
+            </div>
+          </div>
+        )}
       </div>
     );
   };
@@ -552,10 +632,10 @@ export const TestPageView = ({
             {expandedSections.standardLogs && (
               <div>
                 {Object.values(STANDARD_LOGS).map((logName) => {
-                  const logContent = logs[logName];
+                  const logContent = logs ? logs[logName] : undefined;
                   const exists = logContent !== undefined &&
                     ((typeof logContent === "string" && logContent.trim() !== "") ||
-                      (typeof logContent === "object" && Object.keys(logContent).length > 0));
+                      (typeof logContent === "object" && logContent !== null && Object.keys(logContent).length > 0));
 
                   return (
                     <FileTreeItem
@@ -590,7 +670,8 @@ export const TestPageView = ({
           </div>
 
           {/* Runtime Logs Section */}
-          {Object.values(RUNTIME_SPECIFIC_LOGS[runtime as RuntimeName]).length > 0 && (
+          {runtime && RUNTIME_SPECIFIC_LOGS[runtime as RuntimeName] && 
+           Object.values(RUNTIME_SPECIFIC_LOGS[runtime as RuntimeName]).length > 0 && (
             <div className="p-2">
               <div
                 className="d-flex align-items-center text-muted mb-1"
@@ -603,10 +684,10 @@ export const TestPageView = ({
               {expandedSections.runtimeLogs && (
                 <div>
                   {Object.values(RUNTIME_SPECIFIC_LOGS[runtime as RuntimeName]).map((logName) => {
-                    const logContent = logs[logName];
+                    const logContent = logs ? logs[logName] : undefined;
                     const exists = logContent !== undefined &&
                       ((typeof logContent === "string" && logContent.trim() !== "") ||
-                        (typeof logContent === "object" && Object.keys(logContent).length > 0));
+                        (typeof logContent === "object" && logContent !== null && Object.keys(logContent).length > 0));
 
                     return (
                       <FileTreeItem
@@ -642,7 +723,7 @@ export const TestPageView = ({
           )}
 
           {/* Source Files Section */}
-          {logs.source_files && (
+          {logs && logs.source_files && (
             <div className="p-2">
               <div
                 className="d-flex align-items-center text-muted mb-1"
@@ -725,7 +806,93 @@ export const TestPageView = ({
                 </div>
               </div>
             )}
-            {selectedFile?.path.endsWith(".json") && !selectedFile.path.endsWith("tests.json") && (
+            {selectedFile?.path.endsWith("build.json") && (
+              <div>
+                <h5>Build Information</h5>
+                {(() => {
+                  try {
+                    const buildData = JSON.parse(selectedFile.content);
+                    return (
+                      <>
+                        {buildData.errors?.length > 0 && (
+                          <div className="mb-3">
+                            <h6 className="text-danger">Errors ({buildData.errors.length})</h6>
+                            <ul className="list-unstyled">
+                              {buildData.errors.map((error: any, index: number) => (
+                                <li key={index} className="mb-2 p-2 bg-light rounded">
+                                  <div className="text-danger fw-bold">{error.text}</div>
+                                  {error.location && (
+                                    <div className="small text-muted">
+                                      File: {error.location.file} 
+                                      Line: {error.location.line} 
+                                      Column: {error.location.column}
+                                    </div>
+                                  )}
+                                  {error.notes && error.notes.length > 0 && (
+                                    <div className="small">
+                                      Notes:
+                                      <ul>
+                                        {error.notes.map((note: any, noteIndex: number) => (
+                                          <li key={noteIndex}>{note.text}</li>
+                                        ))}
+                                      </ul>
+                                    </div>
+                                  )}
+                                </li>
+                              ))}
+                            </ul>
+                          </div>
+                        )}
+                        {buildData.warnings?.length > 0 && (
+                          <div className="mb-3">
+                            <h6 className="text-warning">Warnings ({buildData.warnings.length})</h6>
+                            <ul className="list-unstyled">
+                              {buildData.warnings.map((warning: any, index: number) => (
+                                <li key={index} className="mb-2 p-2 bg-light rounded">
+                                  <div className="text-warning fw-bold">{warning.text}</div>
+                                  {warning.location && (
+                                    <div className="small text-muted">
+                                      File: {warning.location.file} 
+                                      Line: {warning.location.line} 
+                                      Column: {warning.location.column}
+                                    </div>
+                                  )}
+                                  {warning.notes && warning.notes.length > 0 && (
+                                    <div className="small">
+                                      Notes:
+                                      <ul>
+                                        {warning.notes.map((note: any, noteIndex: number) => (
+                                          <li key={noteIndex}>{note.text}</li>
+                                        ))}
+                                      </ul>
+                                    </div>
+                                  )}
+                                </li>
+                              ))}
+                            </ul>
+                          </div>
+                        )}
+                        {(!buildData.errors || buildData.errors.length === 0) && 
+                         (!buildData.warnings || buildData.warnings.length === 0) && (
+                          <div className="alert alert-success">
+                            No build errors or warnings
+                          </div>
+                        )}
+                      </>
+                    );
+                  } catch (e) {
+                    return (
+                      <div className="alert alert-danger">
+                        Error parsing build.json: {e.message}
+                      </div>
+                    );
+                  }
+                })()}
+              </div>
+            )}
+            {selectedFile?.path.endsWith(".json") && 
+             !selectedFile.path.endsWith("tests.json") && 
+             !selectedFile.path.endsWith("build.json") && (
               <pre className="bg-light p-2 small">
                 <code>{selectedFile.content}</code>
               </pre>

package/src/components/stateful/TestPage.tsx

@@ -58,6 +58,7 @@ export const TestPage = () => {
         const receivedLogs = await testResponse.logs;
         console.log('Received logs:', Object.keys(receivedLogs));
         let sourceFiles = {};
+        let buildLogs = {};
         
         if (metafileRes.ok) {
           const metafile = await metafileRes.json();
@@ -65,42 +66,49 @@ export const TestPage = () => {
             // 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 || 
                   outputPath.includes(normalizedTestPath) ||
+                  normalizedOutputPath.includes(normalizedTestPath) ||
                   (testBaseName && outputPath.includes(testBaseName));
               });
 
             // Then collect all inputs from matching outputs
             matchingOutputs.forEach(([_, output]) => {
               Object.keys(output.inputs).forEach(inputPath => {
-                // Check if this input is a TypeScript file and not in node_modules
-                if ((inputPath.endsWith('.ts') || inputPath.endsWith('.tsx')) &&
+                // 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')) {
                   // Get the full input details from metafile.inputs
                   const inputDetails = metafile.metafile.inputs[inputPath];
                   if (inputDetails) {
                     tsSources.add(inputPath);
-                    // Also include any imported TypeScript files
-                    inputDetails.imports.forEach(imp => {
-                      if ((imp.path.endsWith('.ts') || imp.path.endsWith('.tsx')) &&
-                          !imp.path.includes('node_modules') &&
-                          !imp.external) {
-                        tsSources.add(imp.path);
-                      }
-                    });
+                    // Also include any imported source files (for TypeScript)
+                    // Go files don't have imports in the same way, so we'll only process for TypeScript
+                    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) {
+                          tsSources.add(imp.path);
+                        }
+                      });
+                    }
                   }
                 }
               });
             });
-            
+              
             // Organize source files into directory tree structure
             const fileTree = {};
             const filesList = await Promise.all(
@@ -126,10 +134,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) {
@@ -146,12 +154,15 @@ export const TestPage = () => {
             });
 
             sourceFiles = fileTree;
+            buildLogs = metafile;
           }
         }
 
-        // Add source files to logs
+        // Add source files and build logs to logs
         receivedLogs['source_files'] = sourceFiles;
+        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']) {
@@ -191,6 +202,36 @@ export const TestPage = () => {
         } catch (err) {
           console.error('Failed to load summary:', err);
         }
+
+        // Fetch build.json to get build errors and warnings
+        try {
+          // The build.json is in the runtime directory directly under the test path
+          // testPath is "src/lib/pmProxy.test/index.ts"
+          // We need to use the directory path without the filename
+          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();
+            console.log('Build data received:', buildData);
+            // Add build errors and warnings to logs
+            receivedLogs['build.json'] = buildData;
+          } else {
+            console.log('Build.json not found or not accessible, status:', buildResponse.status);
+            // Add an empty build.json to logs to prevent errors
+            receivedLogs['build.json'] = { errors: [], warnings: [] };
+          }
+        } catch (err) {
+          console.log('No build.json found or error fetching it:', err);
+          // Add an empty build.json to logs to prevent errors
+          receivedLogs['build.json'] = { errors: [], warnings: [] };
+        }
       } catch (err) {
         setError(err instanceof Error ? err.message : 'Unknown error');
         setTestsExist(false);

package/src/core/types.go

@@ -0,0 +1,36 @@
+package core
+
+// Ibdd_in_any represents the input types for BDD
+type Ibdd_in_any interface {
+    Iinput() interface{}
+    Isubject() interface{}
+    Istore() interface{}
+    Iselection() interface{}
+    Then() interface{}
+    Given() interface{}
+}
+
+// Ibdd_out_any represents the output types for BDD
+type Ibdd_out_any interface{}
+
+// ITestSpecification defines the test specification function
+type ITestSpecification func(suites, givens, whens, thens interface{}) interface{}
+
+// ITestImplementation defines the test implementation structure
+type ITestImplementation struct {
+    Suites map[string]interface{}
+    Givens map[string]interface{}
+    Whens  map[string]interface{}
+    Thens  map[string]interface{}
+}
+
+// ITestAdapter defines the adapter interface
+type ITestAdapter interface {
+    BeforeAll(input interface{}, tr ITTestResourceConfiguration, pm interface{}) interface{}
+    AfterAll(store interface{}, pm interface{}) interface{}
+    BeforeEach(subject, initializer interface{}, testResource ITTestResourceConfiguration, initialValues interface{}, pm interface{}) interface{}
+    AfterEach(store interface{}, key string, pm interface{}) interface{}
+    AndWhen(store, whenCB interface{}, testResource interface{}, pm interface{}) interface{}
+    ButThen(store, thenCB interface{}, testResource interface{}, pm interface{}) interface{}
+    AssertThis(t interface{}) bool
+}

package/src/golingvu/README.md

@@ -0,0 +1,3 @@
+# Golingvu
+
+## implementation of testeranto in "go"

package/src/golingvu/base_given.go

@@ -0,0 +1,76 @@
+package golingvu
+
+// 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{} {
+	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,
+		"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
+}

package/src/golingvu/base_suite.go

@@ -0,0 +1,39 @@
+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{}
+}
+
+// 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
+	return bs, nil
+}
+
+// ToObj converts the suite to a serializable object
+func (bs *BaseSuite) ToObj() map[string]interface{} {
+	return map[string]interface{}{
+		"name": bs.Name,
+	}
+}
+
+// Features returns the features covered by this suite
+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] {
+				features = append(features, feature)
+				seen[feature] = true
+			}
+		}
+	}
+	return features
+}