testeranto 0.200.1 → 0.203.0

package/src/golingvu/types.go

@@ -70,17 +70,3 @@ var DefaultTestResourceRequirement = ITTestResourceRequirement{
 	Fs:    "./",
 }
 
-// IFinalResults represents the final results of a test run
-type IFinalResults struct {
-	Failed    bool
-	Fails     int
-	Artifacts []interface{}
-	Features  []string
-}
-
-// ITestJob represents a test job
-type ITestJob interface {
-	ToObj() map[string]interface{}
-	Runner(pm interface{}, tLog func(...string)) (interface{}, error)
-	ReceiveTestResourceConfig(pm interface{}) (IFinalResults, error)
-}

package/src/helpo/directives.md

@@ -0,0 +1,5 @@
+# helpo
+
+## the helpful robot.
+
+You are a chat bot for the project "testeranto". Your job it to help users by answering their questions and directing them to the documentation. You will provided a readable file `testeranto/helpo_chat_history.json` and a writable file `testeranto/helpo_chat_message.txt`. You will be passed questions from the user via `helpo_chat_history.json`. Using `helpo_chat_history.json` and the documentation, respond to the user by writing to `helpo_chat_message.txt`.

package/src/helpo/prompt.txt

@@ -0,0 +1,38 @@
+/read README.md
+/read src/helpo/directives.md
+
+# Always read from the chat history file to see the conversation
+/read testeranto/helpo_chat_history.json
+/add testeranto/helpo_chat_message.txt
+
+# When you receive any input, always:
+# 1. Immediately read the latest messages from testeranto/helpo_chat_history.json
+# 2. Write your response to testeranto/helpo_chat_message.txt
+# 3. Do NOT add your response directly to the history file
+# 4. The Node process will handle adding your response to the history
+
+# Important: Always stay running and wait for further instructions
+# Do not exit after responding
+# Always be ready to process new messages immediately
+
+# When you see the "ask>" prompt, it means you're ready for a new command
+# If you're at the "ask>" prompt and receive any input, process it immediately
+
+# CRITICAL: You MUST write your response to testeranto/helpo_chat_message.txt
+# Do not just think about responding - actually write to the file!
+# Every time you receive input, write your response to the message file!
+
+# RIGHT NOW: Read the latest messages from testeranto/helpo_chat_history.json
+# and write your response to testeranto/helpo_chat_message.txt
+
+# When you see "PROCESS_CHAT_HISTORY_AND_RESPOND", immediately:
+# 1. Read testeranto/helpo_chat_history.json
+# 2. Write your response to testeranto/helpo_chat_message.txt
+# 3. Do not wait for further input
+# 4. Do NOT print your response to stdout - only write to the file!
+# 5. After writing to the file, continue waiting for more input
+
+# IMPORTANT: Your response must be written to testeranto/helpo_chat_message.txt
+# Do not include any other text or commentary in stdout
+# The success of this integration depends on you writing to the file
+

package/src/hooks/useGitMode.ts

@@ -0,0 +1,20 @@
+import { useState, useEffect } from 'react';
+import { useWebSocket } from '../App';
+
+export const useGitMode = () => {
+  const { isConnected } = useWebSocket();
+  const [mode, setMode] = useState<'static' | 'dev' | 'git'>(isConnected ? 'dev' : 'static');
+
+  useEffect(() => {
+    // Auto-detect mode based on WebSocket connection
+    setMode(isConnected ? 'dev' : 'static');
+  }, [isConnected]);
+
+  return {
+    mode,
+    setMode,
+    isStatic: mode === 'static',
+    isDev: mode === 'dev',
+    isGit: mode === 'git'
+  };
+};

package/src/hooks/useTerminalWebSocket.ts

@@ -0,0 +1,49 @@
+import { useState, useEffect, useCallback } from 'react';
+import { Process } from '../components/pure/ProcessManagerViewTypes';
+
+export const useTerminalWebSocket = (ws: WebSocket | null, selectedProcess: Process | null) => {
+  const [processLogs, setProcessLogs] = useState<string[]>([]);
+
+  // Handle WebSocket messages for the selected process
+  const handleMessage = useCallback((event: MessageEvent) => {
+    try {
+      const data = JSON.parse(event.data);
+      // Handle process data response
+      if (
+        data.type === "processData" &&
+        selectedProcess &&
+        data.processId === selectedProcess.processId
+      ) {
+        setProcessLogs(data.logs || []);
+      }
+      // Handle new log messages
+      else if (
+        (data.type === "processStdout" || data.type === "processStderr") &&
+        selectedProcess &&
+        data.processId === selectedProcess.processId
+      ) {
+        setProcessLogs((prev) => [...prev, data.data]);
+      }
+    } catch (error) {
+      console.error("Error parsing WebSocket message:", error);
+    }
+  }, [selectedProcess]);
+
+  // Reset logs when selected process changes
+  useEffect(() => {
+    setProcessLogs(selectedProcess?.logs || []);
+  }, [selectedProcess]);
+
+  useEffect(() => {
+    if (!ws) return;
+
+    ws.addEventListener('message', handleMessage);
+    return () => {
+      ws.removeEventListener('message', handleMessage);
+    };
+  }, [ws, handleMessage]);
+
+  return {
+    processLogs,
+  };
+};

package/src/lib/BaseGiven.ts

@@ -21,7 +21,7 @@ import { BaseSuite } from "./BaseSuite";
 export type IGivens<I extends Ibdd_in_any> = Record<string, BaseGiven<I>>;
 
 export abstract class BaseGiven<I extends Ibdd_in_any> {
-  name: string;
+  // name: string;
   features: string[];
   whens: any[];
   thens: any[];
@@ -36,24 +36,52 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
   artifacts: string[] = [];
 
   addArtifact(path: string) {
+    if (typeof path !== "string") {
+      throw new Error(
+        `[ARTIFACT ERROR] Expected string, got ${typeof path}: ${JSON.stringify(
+          path
+        )}`
+      );
+    }
     const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
     this.artifacts.push(normalizedPath);
   }
 
   constructor(
-    name: string,
     features: string[],
     whens: any[],
     thens: any[],
     givenCB: I["given"],
     initialValues: any
   ) {
-    this.name = name;
-    this.features = features || [];
-    this.whens = whens || [];
-    this.thens = thens || [];
+    // Ensure features are always strings
+    // Ensure features are always strings and not objects
+    // If features contains objects, it's likely a parameter shift error
+    this.features = (Array.isArray(features) ? features : [])
+      .map((feature) => {
+        // If feature is a string, use it directly
+        if (typeof feature === "string") return feature;
+        // If feature is an object, this is an error - log it and return empty string
+        if (feature && typeof feature === "object") {
+          console.error(
+            `[ERROR] Found object in features array: ${
+              feature.name || JSON.stringify(feature)
+            }`
+          );
+          return ""; // Return empty string to avoid issues
+        }
+        // For any other case, convert to string
+        return String(feature);
+      })
+      .filter((f) => f !== null && f !== undefined && f !== "");
+
+    // Ensure whens and thens are always arrays
+    this.whens = Array.isArray(whens) ? whens : [];
+    this.thens = Array.isArray(thens) ? thens : [];
+
     this.givenCB = givenCB;
     this.initialValues = initialValues;
+    this.fails = 0; // Initialize fail count
   }
 
   beforeAll(store: I["istore"]) {
@@ -63,18 +91,17 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
   toObj() {
     return {
       key: this.key,
-      name: this.name,
+      // name: this.name,
       whens: (this.whens || []).map((w) => {
         if (w && w.toObj) return w.toObj();
-
-        console.error("w is not as expected!", JSON.stringify(w));
+        console.error("When step is not as expected!", JSON.stringify(w));
         return {};
       }),
-      thens: (this.thens || []).map((t) => t && t.toObj ? t.toObj() : {}),
+      thens: (this.thens || []).map((t) => (t && t.toObj ? t.toObj() : {})),
       error: this.error ? [this.error, this.error.stack] : null,
       failed: this.failed,
       features: this.features || [],
-      artifacts: this.artifacts || [],
+      artifacts: this.artifacts,
     };
   }
 
@@ -109,6 +136,7 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
     suiteNdx: number
   ) {
     this.key = key;
+    this.fails = 0; // Initialize fail count for this given
 
     tLog(`\n ${this.key}`);
     tLog(`\n Given: ${this.name}`);
@@ -137,6 +165,7 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
     } catch (e) {
       // console.error("Given failure: ", e.stack);
       this.failed = true;
+      this.fails++; // Increment fail count
       this.error = e.stack;
       // throw e;
     }
@@ -144,25 +173,93 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
     try {
       // tLog(`\n Given this.store`, this.store);
 
-      for (const [whenNdx, whenStep] of this.whens.entries()) {
-        await whenStep.test(
-          this.store,
-          testResourceConfiguration,
-          tLog,
-          pm,
-          `suite-${suiteNdx}/given-${key}/when/${whenNdx}`
-        );
+      // Process when steps
+      const whens = this.whens || [];
+      // console.log(`[BaseGiven.give] Number of when steps: ${whens.length}`);
+      if (whens.length > 0) {
+        // console.log(`[BaseGiven.give] When steps exist, let's process them`);
+        for (const [whenNdx, whenStep] of whens.entries()) {
+          // console.log(
+          //   `[BaseGiven.give] Processing when step ${whenNdx}:`,
+          //   whenStep?.name
+          // );
+          // console.log(`[BaseGiven.give] Store before when step:`, this.store);
+          // console.log(`[BaseGiven.give] When step instance:`, whenStep);
+
+          // Check if this is actually a then step that was incorrectly placed in whens
+          if (
+            whenStep &&
+            whenStep.name &&
+            whenStep.name.startsWith("result:")
+          ) {
+            // console.error(
+            //   `[BaseGiven.give] ERROR: Found then step "${whenStep.name}" in whens array!`
+            // );
+            // Move it to thens array
+            this.thens.push(whenStep);
+            // console.log(
+            //   `[BaseGiven.give] Moved "${whenStep.name}" from whens to thens`
+            // );
+            continue; // Skip processing as a when step
+          }
+
+          // Check if whenStep exists and whenStep.test is a function
+          if (whenStep && typeof whenStep.test === "function") {
+            try {
+              // Update the store with the result of the when step
+              this.store = await whenStep.test(
+                this.store,
+                testResourceConfiguration,
+                tLog,
+                pm,
+                `suite-${suiteNdx}/given-${key}/when/${whenNdx}`
+              );
+              // console.log(
+              //   `[BaseGiven.give] Store after when step ${whenNdx}:`,
+              //   this.store
+              // );
+            } catch (e) {
+              // console.error(
+              //   `[BaseGiven.give] Error in when step ${whenNdx}:`,
+              //   e
+              // );
+              this.failed = true;
+              this.fails++; // Increment fail count
+              throw e;
+            }
+          } else {
+            // console.error(
+            //   `[BaseGiven.give] whenStep.test is not a function:`,
+            //   typeof whenStep?.test
+            // );
+            this.failed = true;
+            this.fails++; // Increment fail count
+            throw new Error(`When step ${whenNdx} does not have a test method`);
+          }
+        }
+      } else {
+        console.log(`[BaseGiven.give] No when steps to process`);
       }
 
+      // Process then steps
       for (const [thenNdx, thenStep] of this.thens.entries()) {
-        const t = await thenStep.test(
-          this.store,
-          testResourceConfiguration,
-          tLog,
-          pm,
-          `suite-${suiteNdx}/given-${key}/then-${thenNdx}`
-        );
-        tester(t);
+        try {
+          const t = await thenStep.test(
+            this.store,
+            testResourceConfiguration,
+            tLog,
+            pm,
+            `suite-${suiteNdx}/given-${key}/then-${thenNdx}`
+          );
+          // If the test doesn't throw, it passed
+          tester(t);
+        } catch (e) {
+          // Mark the given as failed if any then step fails
+          this.failed = true;
+          this.fails++; // Increment fail count
+          // Re-throw to propagate the error
+          throw e;
+        }
       }
     } catch (e) {
       this.error = e.stack;
@@ -182,7 +279,8 @@ export abstract class BaseGiven<I extends Ibdd_in_any> {
         // (proxiedPm as any).currentStep = this;
         await this.afterEach(this.store, this.key, givenArtifactory, proxiedPm);
       } catch (e) {
-        this.failed = e;
+        this.failed = true;
+        this.fails++; // Increment fail count
         throw e;
         // this.error = e.message;
       }

package/src/lib/BaseSuite.test/mock.ts

@@ -21,13 +21,13 @@ export class MockGiven extends BaseGiven<I> {
       features,
       whens,
       thens,
-      async () => ({ testStore: true }), // givenCB
+      async () => ({ testStore: true, testSelection: false }), // givenCB
       {} // initialValues
     );
   }
 
   async givenThat(): Promise<TestStore> {
-    return { testStore: true };
+    return { testStore: true, testSelection: false };
   }
 
   uberCatcher(e: Error): void {
@@ -38,15 +38,18 @@ export class MockGiven extends BaseGiven<I> {
 export class MockWhen extends BaseWhen<I> {
   async andWhen(
     store: TestStore,
-    whenCB: (x: TestSelection) => (store: TestStore) => Promise<TestSelection>,
+    whenCB: (s: TestSelection) => Promise<BaseSuite<any, any>>,
     testResource: any,
     pm: IPM
   ): Promise<TestStore> {
     // Create a TestSelection from the store
-    const selection: TestSelection = { testSelection: true };
-    const result = await whenCB(selection)(store);
-    // Convert back to TestStore
-    return { ...store, ...result };
+    const selection: TestSelection = { 
+      testSelection: store.testStore,
+      testStore: store.testStore
+    };
+    // Call whenCB with the selection
+    await whenCB(selection);
+    return store;
   }
 
   addArtifact(path: string): void {
@@ -59,11 +62,14 @@ export class MockThen extends BaseThen<I> {
     store: TestStore,
     thenCB: (s: TestSelection) => Promise<BaseSuite<any, any>>,
     testResourceConfiguration: any,
-    pm: IPM,
-    ...args: any[]
+    pm: IPM
   ): Promise<TestSelection> {
     // Create a TestSelection from the store
-    const selection: TestSelection = { testSelection: true };
+    const selection: TestSelection = { 
+      testSelection: store.testStore,
+      testStore: store.testStore
+    };
+    // Call thenCB with the selection
     await thenCB(selection);
     return selection;
   }