testeranto 0.202.0 → 0.205.0

package/dist/module/src/app/frontend/testPage/TestPageView_utils.js

@@ -0,0 +1,120 @@
+import React from "react";
+// Determine language from file extension
+export const getLanguage = (path) => {
+    var _a;
+    const ext = (_a = path.split(".").pop()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    switch (ext) {
+        case "ts":
+            return "typescript";
+        case "tsx":
+            return "typescript";
+        case "js":
+            return "javascript";
+        case "json":
+            return "json";
+        case "md":
+            return "markdown";
+        case "py":
+            return "python";
+        default:
+            return "plaintext";
+    }
+};
+const statusToClassName = (status) => {
+    if (status === undefined)
+        return "bg-secondary";
+    if (status === false)
+        return "bg-danger";
+    if (status === true)
+        return "bg-success";
+    throw `idk status: ${status}`;
+};
+export const renderTestResults = (testData, buildErrors, projectName, testName, runtime) => {
+    return (React.createElement("div", { className: "test-results" },
+        testData.givens.map((given, i) => (React.createElement("div", { key: i, className: "mb-4 card " },
+            React.createElement("div", { className: `card-header ${statusToClassName(given.status)} text-white` },
+                React.createElement("div", { className: "d-flex justify-content-between align-items-center" },
+                    React.createElement("div", null,
+                        React.createElement("h4", null,
+                            "Given: ",
+                            given.name),
+                        given.features && given.features.length > 0 && (React.createElement("div", { className: "mt-1" },
+                            React.createElement("small", null, "Features:"),
+                            React.createElement("ul", { className: "list-unstyled" }, given.features.map((feature, fi) => (React.createElement("li", { key: fi }, feature.startsWith("http") ? (React.createElement("a", { href: feature, target: "_blank", rel: "noopener noreferrer", className: "text-white" }, new URL(feature).hostname)) : (React.createElement("span", { className: "text-white" }, feature))))))))),
+                    given.artifacts && given.artifacts.length > 0 && (React.createElement("div", { className: "dropdown" },
+                        React.createElement("button", { className: "btn btn-sm btn-light dropdown-toggle", type: "button", "data-bs-toggle": "dropdown" },
+                            "Artifacts (",
+                            given.artifacts.length,
+                            ")"),
+                        React.createElement("ul", { className: "dropdown-menu dropdown-menu-end" }, given.artifacts.map((artifact, ai) => (React.createElement("li", { key: ai },
+                            React.createElement("a", { className: "dropdown-item", href: `reports/${projectName}/${testName
+                                    .split(".")
+                                    .slice(0, -1)
+                                    .join(".")}/${runtime}/${artifact}`, target: "_blank", rel: "noopener noreferrer" }, artifact.split("/").pop()))))))))),
+            React.createElement("div", { className: "card-body" },
+                given.whens.map((when, j) => (React.createElement("div", { key: `w-${j}`, className: `p-3 mb-2 text-white ${statusToClassName(when.status)}` },
+                    React.createElement("div", { className: "d-flex justify-content-between align-items-start" },
+                        React.createElement("div", null,
+                            React.createElement("div", null,
+                                React.createElement("strong", null, "When:"),
+                                " ",
+                                when.name,
+                                when.features && when.features.length > 0 && (React.createElement("div", { className: "mt-2" },
+                                    React.createElement("small", null, "Features:"),
+                                    React.createElement("ul", { className: "list-unstyled" }, when.features.map((feature, fi) => (React.createElement("li", { key: fi }, feature.startsWith("http") ? (React.createElement("a", { href: feature, target: "_blank", rel: "noopener noreferrer" }, new URL(feature).hostname)) : (feature))))))),
+                                when.error && React.createElement("pre", { className: "mt-2" }, when.error))),
+                        when.artifacts && when.artifacts.length > 0 && (React.createElement("div", { className: "ms-3" },
+                            React.createElement("strong", null, "Artifacts:"),
+                            React.createElement("ul", { className: "list-unstyled" }, when.artifacts.map((artifact, ai) => (React.createElement("li", { key: ai },
+                                React.createElement("a", { href: `reports/${projectName}/${testName
+                                        .split(".")
+                                        .slice(0, -1)
+                                        .join(".")}/${runtime}/${artifact}`, target: "_blank", className: "text-white", rel: "noopener noreferrer" }, artifact.split("/").pop()))))))))))),
+                given.thens.map((then, k) => (React.createElement("div", { key: `t-${k}`, className: `p-3 mb-2 text-white ${statusToClassName(then.status)}` },
+                    React.createElement("div", { className: "d-flex justify-content-between align-items-start" },
+                        React.createElement("div", null,
+                            React.createElement("div", null,
+                                React.createElement("strong", null, "Then:"),
+                                " ",
+                                then.name,
+                                then.features && then.features.length > 0 && (React.createElement("div", { className: "mt-2" },
+                                    React.createElement("small", null, "Features:"),
+                                    React.createElement("ul", { className: "list-unstyled" }, then.features.map((feature, fi) => (React.createElement("li", { key: fi }, feature.startsWith("http") ? (React.createElement("a", { href: feature, target: "_blank", rel: "noopener noreferrer" }, new URL(feature).hostname)) : (feature))))))),
+                                then.error && React.createElement("pre", { className: "mt-2" }, then.error))),
+                        then.artifacts && then.artifacts.length > 0 && (React.createElement("div", { className: "ms-3" },
+                            React.createElement("strong", null, "Artifacts:"),
+                            React.createElement("ul", { className: "list-unstyled" }, then.artifacts.map((artifact, ai) => (React.createElement("li", { key: ai },
+                                React.createElement("a", { href: `reports/${projectName}/${testName
+                                        .split(".")
+                                        .slice(0, -1)
+                                        .join(".")}/${runtime}/${artifact}`, target: "_blank", className: "text-white", rel: "noopener noreferrer" }, artifact.split("/").pop()))))))))))))))),
+        (buildErrors.errors.length > 0 || buildErrors.warnings.length > 0) && (React.createElement("div", { className: "mb-4 card border-danger" },
+            React.createElement("div", { className: "card-header bg-danger text-white" },
+                React.createElement("h4", null, "Build Errors and Warnings")),
+            React.createElement("div", { className: "card-body" },
+                buildErrors.errors.length > 0 && (React.createElement(React.Fragment, null,
+                    React.createElement("h5", null, "Errors"),
+                    React.createElement("ul", null, buildErrors.errors.map((error, idx) => (React.createElement("li", { key: `build-error-${idx}` },
+                        React.createElement("strong", null, error.text),
+                        error.location && (React.createElement("div", null,
+                            "File: ",
+                            error.location.file,
+                            " Line:",
+                            " ",
+                            error.location.line,
+                            " Column: ",
+                            error.location.column)))))))),
+                buildErrors.warnings.length > 0 && (React.createElement(React.Fragment, null,
+                    React.createElement("h5", null, "Warnings"),
+                    React.createElement("ul", null, buildErrors.warnings.map((warning, idx) => (React.createElement("li", { key: `build-warning-${idx}` },
+                        React.createElement("strong", null, warning.text),
+                        warning.location && (React.createElement("div", null,
+                            "File: ",
+                            warning.location.file,
+                            " Line:",
+                            " ",
+                            warning.location.line,
+                            " Column:",
+                            " ",
+                            warning.location.column)))))))))))));
+};

package/dist/module/src/app/frontend/useFileSystemSync.js

@@ -0,0 +1,108 @@
+"use strict";
+// /* eslint-disable @typescript-eslint/no-unused-vars */
+// import { useState, useEffect, useCallback } from "react";
+// import { useWebSocket } from "../App";
+// // Remove any imports that might import backend-specific code
+// export interface FileEntry {
+//   name: string;
+//   type: "folder" | "file";
+//   path: string;
+// }
+// export interface FileSystemState {
+//   files: Record<string, FileEntry[]>;
+//   fileContents: Record<string, string>;
+// }
+// export const useFileSystemSync = (initialPath = "/") => {
+//   const [fileSystem, setFileSystem] = useState<FileSystemState>({
+//     files: {},
+//     fileContents: {},
+//   });
+//   const [loading, setLoading] = useState(false);
+//   const [error, setError] = useState<string | null>(null);
+//   const wsContext = useWebSocket();
+//   const ws = wsContext?.ws;
+//   const listDirectory = useCallback(async (project: string) => {
+//     setLoading(true);
+//     setError(null);
+//     try {
+//       // Use the project tree endpoint
+//       const response = await fetch(
+//         `/api/projects/tree?project=${encodeURIComponent(project)}`
+//       );
+//       if (response.ok) {
+//         const data = await response.json();
+//         // The API should return { sourceFiles: [...] }
+//         const items = data.sourceFiles || data;
+//         setFileSystem((prev) => ({
+//           ...prev,
+//           files: {
+//             ...prev.files,
+//             [project]: items,
+//           },
+//         }));
+//         setLoading(false);
+//         return items;
+//       } else {
+//         throw new Error(`Failed to list directory: ${response.status}`);
+//       }
+//     } catch (error) {
+//       const errorMessage =
+//         error instanceof Error ? error.message : "Unknown error";
+//       console.error("Error listing directory:", error);
+//       setError(errorMessage);
+//       setLoading(false);
+//       throw error;
+//     }
+//   }, []);
+//   const readFile = useCallback(async (path: string) => {
+//     try {
+//       // Use the read file endpoint
+//       const response = await fetch(
+//         `/api/files/read?path=${encodeURIComponent(path)}`
+//       );
+//       if (response.ok) {
+//         const content = await response.text();
+//         setFileSystem((prev) => ({
+//           ...prev,
+//           fileContents: {
+//             ...prev.fileContents,
+//             [path]: content,
+//           },
+//         }));
+//         return content;
+//       } else {
+//         throw new Error(`Failed to read file: ${response.status}`);
+//       }
+//     } catch (error) {
+//       console.error("Error reading file:", error);
+//       throw error;
+//     }
+//   }, []);
+//   useEffect(() => {
+//     if (!ws) return;
+//     const handleMessage = (event: MessageEvent) => {
+//       try {
+//         const data = JSON.parse(event.data);
+//         if (data.type === "fileChanged") {
+//           setFileSystem((prev) => ({
+//             ...prev,
+//             fileContents: {
+//               ...prev.fileContents,
+//               [data.path]: data.content,
+//             },
+//           }));
+//         }
+//       } catch (error) {
+//         console.error("Error processing WebSocket message:", error);
+//       }
+//     };
+//     ws.addEventListener("message", handleMessage);
+//     return () => ws.removeEventListener("message", handleMessage);
+//   }, [ws]);
+//   return {
+//     fileSystem,
+//     listDirectory,
+//     readFile,
+//     refresh: () => listDirectory(initialPath),
+//   };
+// };

package/dist/module/src/app/frontend/useFs.js

@@ -0,0 +1,11 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { createContext, useContext } from "react";
+import { DevelopmentFileService } from "./DevelopmentFileService";
+export const FileServiceContext = createContext(new DevelopmentFileService());
+export const useFs = () => {
+    const context = useContext(FileServiceContext);
+    if (!context) {
+        throw new Error("useFileService must be used within a FileServiceProvider");
+    }
+    return context;
+};

package/dist/module/src/app/frontend/useGitMode.js

@@ -0,0 +1,16 @@
+import { useState, useEffect } from "react";
+import { useWebSocket } from "./useWebSocket";
+export const useGitMode = () => {
+    const { isConnected } = useWebSocket();
+    const [mode, setMode] = useState(isConnected ? "dev" : "static");
+    useEffect(() => {
+        setMode(isConnected ? "dev" : "static");
+    }, [isConnected]);
+    return {
+        mode,
+        setMode,
+        isStatic: mode === "static",
+        isDev: mode === "dev",
+        isGit: mode === "git",
+    };
+};

package/dist/module/src/app/frontend/useTerminalWebSocket.js

@@ -0,0 +1,40 @@
+import { useState, useEffect, useCallback } from "react";
+export const useTerminalWebSocket = (ws, selectedProcess) => {
+    const [processLogs, setProcessLogs] = useState([]);
+    // Handle WebSocket messages for the selected process
+    const handleMessage = useCallback((event) => {
+        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 === null || selectedProcess === void 0 ? void 0 : selectedProcess.logs) || []);
+    }, [selectedProcess]);
+    useEffect(() => {
+        if (!ws)
+            return;
+        ws.addEventListener("message", handleMessage);
+        return () => {
+            ws.removeEventListener("message", handleMessage);
+        };
+    }, [ws, handleMessage]);
+    return {
+        processLogs,
+    };
+};

package/dist/module/src/app/frontend/useWebSocket.js

@@ -0,0 +1,12 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { createContext, useContext } from "react";
+export const WebSocketContext = createContext({
+    ws: null,
+    isConnected: false,
+    sendMessage: function (message) {
+        throw new Error("Function not implemented.");
+    },
+});
+export const useWebSocket = () => {
+    return useContext(WebSocketContext);
+};

package/dist/module/src/app/types.js

@@ -0,0 +1 @@
+export {};

package/dist/module/src/builders/golang.js

@@ -0,0 +1,28 @@
+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/dist/module/src/builders/node.js

@@ -0,0 +1,33 @@
+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/dist/module/src/builders/python.js

@@ -0,0 +1,26 @@
+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/dist/module/src/builders/web.js

@@ -0,0 +1,33 @@
+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/dist/module/src/esbuildConfigs/node.js

@@ -4,7 +4,9 @@ import featuresPlugin from "./featuresPlugin";
 import rebuildPlugin from "./rebuildPlugin.js";
 export default (config, entryPoints, testName) => {
     const { inputFilesPluginFactory, register } = inputFilesPlugin("node", testName);
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: `testeranto/bundles/node/${testName}/`, inject: [`./node_modules/testeranto/dist/cjs-shim.js`], metafile: true, supported: {
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: `testeranto/bundles/node/${testName}/`, 
+        // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
+        metafile: true, supported: {
             "dynamic-import": true,
         }, define: {
             "process.env.FLUENTFFMPEG_COV": "0",

package/dist/module/src/lib/BaseGiven.js

@@ -3,17 +3,20 @@
 import { afterEachProxy, beforeEachProxy } from "./pmProxy.js";
 export class BaseGiven {
     addArtifact(path) {
+        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, features, whens, thens, givenCB, initialValues) {
+    constructor(features, whens, thens, givenCB, initialValues) {
         this.artifacts = [];
-        this.name = name;
-        this.features = features || [];
-        this.whens = whens || [];
-        this.thens = thens || [];
+        this.features = features;
+        this.whens = whens;
+        this.thens = thens;
         this.givenCB = givenCB;
         this.initialValues = initialValues;
+        this.fails = 0; // Initialize fail count
     }
     beforeAll(store) {
         return store;
@@ -21,18 +24,18 @@ export class BaseGiven {
     toObj() {
         return {
             key: this.key,
-            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,
+            status: this.status,
         };
     }
     async afterEach(store, key, artifactory, pm) {
@@ -40,8 +43,9 @@ export class BaseGiven {
     }
     async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm, suiteNdx) {
         this.key = key;
+        this.fails = 0; // Initialize fail count for this given
         tLog(`\n ${this.key}`);
-        tLog(`\n Given: ${this.name}`);
+        tLog(`\n Given: ${this.key}`);
         const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
         this.uberCatcher((e) => {
             console.error(e.toString());
@@ -53,21 +57,94 @@ export class BaseGiven {
             const addArtifact = this.addArtifact.bind(this);
             const proxiedPm = beforeEachProxy(pm, suiteNdx.toString(), addArtifact);
             this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues, proxiedPm);
+            this.status = true;
         }
         catch (e) {
+            this.status = false;
             // console.error("Given failure: ", e.stack);
             this.failed = true;
+            this.fails++; // Increment fail count
             this.error = e.stack;
             // throw e;
         }
         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}`);
-            }
+            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`);
+            // }
             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) {
@@ -78,14 +155,14 @@ export class BaseGiven {
         }
         finally {
             try {
-                // Ensure addArtifact is properly bound to 'this'
                 const addArtifact = this.addArtifact.bind(this);
                 const proxiedPm = afterEachProxy(pm, suiteNdx.toString(), key, addArtifact);
                 // (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;
             }