automation_model 1.0.842-dev → 1.0.844-dev

package/lib/route.js

@@ -47,15 +47,311 @@ async function loadRoutes(context, template) {
     }
     return context.loadedRoutes.get(template) || [];
 }
+export function pathFilter(savedPath, actualPath) {
+    if (typeof savedPath !== "string")
+        return false;
+    if (savedPath.includes("*")) {
+        // Escape regex special characters in savedPath
+        const escapedPath = savedPath.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+        // Treat it as a wildcard
+        const regex = new RegExp(escapedPath.replace(/\*/g, ".*"));
+        return regex.test(actualPath);
+    }
+    else {
+        return savedPath === actualPath;
+    }
+}
+export function queryParamsFilter(savedQueryParams, actualQueryParams) {
+    if (!savedQueryParams)
+        return true;
+    for (const [key, value] of Object.entries(savedQueryParams)) {
+        if (value === "*") {
+            // If the saved query param is a wildcard, it matches anything
+            continue;
+        }
+        if (actualQueryParams.get(key) !== value) {
+            return false;
+        }
+    }
+    return true;
+}
+export function methodFilter(savedMethod, actualMethod) {
+    if (!savedMethod)
+        return true;
+    if (savedMethod === "*") {
+        const httpMethodRegex = /^(GET|POST|PUT|DELETE|PATCH|OPTIONS|HEAD)$/;
+        return httpMethodRegex.test(actualMethod);
+    }
+    return savedMethod === actualMethod;
+}
 function matchRoute(routeItem, req) {
     const url = new URL(req.request().url());
-    const methodMatch = !routeItem.filters.method || routeItem.filters.method === req.request().method();
-    const pathMatch = routeItem.filters.path === url.pathname;
     const queryParams = routeItem.filters.queryParams;
-    const queryMatch = !queryParams || Object.entries(queryParams).every(([key, value]) => url.searchParams.get(key) === value);
-    return methodMatch && pathMatch && queryMatch;
+    return (methodFilter(routeItem.filters.method, req.request().method()) &&
+        pathFilter(routeItem.filters.path, url.pathname) &&
+        queryParamsFilter(queryParams, url.searchParams));
+}
+function handleAbortRequest(action, context) {
+    if (context.tracking.timer)
+        clearTimeout(context.tracking.timer);
+    const errorCode = action.config?.errorCode ?? "failed";
+    console.log(`[abort_request] Aborting with error code: ${errorCode}`);
+    context.route.abort(errorCode);
+    context.abortActionPerformed = true;
+    context.tracking.completed = true;
+    return {
+        type: action.type,
+        description: JSON.stringify(action.config),
+        status: "success",
+        message: `Request aborted with code: ${errorCode}`,
+    };
+}
+function handleStatusCodeVerification(action, context) {
+    const isSuccess = String(context.status) === String(action.config);
+    return {
+        type: action.type,
+        description: JSON.stringify(action.config),
+        status: isSuccess ? "success" : "fail",
+        message: `Status code verification ${isSuccess ? "passed" : "failed"}. Expected ${action.config}, got ${context.status}`,
+    };
+}
+function handleJsonModify(action, context) {
+    if (!context.json) {
+        return {
+            type: action.type,
+            description: JSON.stringify(action.config),
+            status: "fail",
+            message: "JSON modification failed. Response is not JSON",
+        };
+    }
+    objectPath.set(context.json, action.config.path, action.config.modifyValue);
+    context.finalBody = JSON.parse(JSON.stringify(context.json));
+    return {
+        type: action.type,
+        description: JSON.stringify(action.config),
+        status: "success",
+        message: `JSON modified at path '${action.config.path}'`,
+    };
+}
+function handleJsonWholeModify(action, context) {
+    if (!context.json) {
+        return {
+            type: action.type,
+            description: JSON.stringify(action.config),
+            status: "fail",
+            message: "JSON modification failed. Response is not JSON",
+        };
+    }
+    try {
+        const parsedConfig = typeof action.config === "string" ? JSON.parse(action.config) : action.config;
+        context.json = parsedConfig;
+        context.finalBody = JSON.parse(JSON.stringify(context.json));
+        return {
+            type: action.type,
+            description: JSON.stringify(action.config),
+            status: "success",
+            message: "Whole JSON body was replaced.",
+        };
+    }
+    catch (e) {
+        const message = `JSON modification failed. Invalid JSON in config: ${e instanceof Error ? e.message : String(e)}`;
+        return { type: action.type, description: JSON.stringify(action.config), status: "fail", message };
+    }
+}
+function handleStatusCodeChange(action, context) {
+    context.status = Number(action.config);
+    return {
+        type: action.type,
+        description: JSON.stringify(action.config),
+        status: "success",
+        message: `Status code changed to ${context.status}`,
+    };
+}
+function handleChangeText(action, context) {
+    if (context.isBinary) {
+        return {
+            type: action.type,
+            description: JSON.stringify(action.config),
+            status: "fail",
+            message: "Change text action failed. Body is not text.",
+        };
+    }
+    context.body = action.config;
+    context.finalBody = context.body;
+    return {
+        type: action.type,
+        description: JSON.stringify(action.config),
+        status: "success",
+        message: "Response body text was replaced.",
+    };
+}
+function handleAssertJson(action, context) {
+    if (!context.json) {
+        return {
+            type: action.type,
+            description: JSON.stringify(action.config),
+            status: "fail",
+            message: "JSON assertion failed. Response is not JSON.",
+        };
+    }
+    const actual = objectPath.get(context.json, action.config.path);
+    const expected = action.config.expectedValue;
+    const isSuccess = JSON.stringify(actual) === JSON.stringify(expected);
+    return {
+        type: action.type,
+        description: JSON.stringify(action.config),
+        status: isSuccess ? "success" : "fail",
+        message: isSuccess
+            ? `JSON assertion passed for path '${action.config.path}'.`
+            : `JSON assertion failed for path '${action.config.path}': expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`,
+    };
+}
+function handleAssertWholeJson(action, context) {
+    if (!context.json) {
+        return {
+            type: action.type,
+            description: JSON.stringify(action.config),
+            status: "fail",
+            message: "Whole JSON assertion failed. Response is not JSON.",
+        };
+    }
+    const originalJSON = JSON.stringify(context.json, null, 2);
+    let isSuccess = false;
+    let message = "";
+    if ("contains" in action.config) {
+        isSuccess = originalJSON.includes(action.config.contains);
+        message = isSuccess
+            ? "Whole JSON assertion passed."
+            : `Whole JSON assertion failed. Expected to contain: "${action.config.contains}".`;
+    }
+    else {
+        isSuccess = originalJSON === action.config.equals;
+        message = isSuccess
+            ? "Whole JSON assertion passed."
+            : `Whole JSON assertion failed. Expected exact match: "${action.config.equals}".`;
+    }
+    return {
+        type: action.type,
+        description: JSON.stringify(action.config),
+        status: isSuccess ? "success" : "fail",
+        message,
+    };
+}
+function handleAssertText(action, context) {
+    if (typeof context.body !== "string") {
+        return {
+            type: action.type,
+            description: JSON.stringify(action.config),
+            status: "fail",
+            message: "Text assertion failed. Body is not text.",
+        };
+    }
+    let isSuccess = false;
+    let message = "";
+    if ("contains" in action.config) {
+        isSuccess = context.body.includes(action.config.contains);
+        message = isSuccess
+            ? "Text assertion passed."
+            : `Text assertion failed. Expected to contain: "${action.config.contains}".`;
+    }
+    else {
+        isSuccess = context.body === action.config.equals;
+        message = isSuccess
+            ? "Text assertion passed."
+            : `Text assertion failed. Expected exact match: "${action.config.equals}".`;
+    }
+    return {
+        type: action.type,
+        description: JSON.stringify(action.config),
+        status: isSuccess ? "success" : "fail",
+        message,
+    };
+}
+function handleStubAction(stubAction, route, tracking) {
+    let actionStatus = "success";
+    const description = JSON.stringify(stubAction.config);
+    const request = route.request();
+    let stubActionPerformed = false;
+    debug(`Stub action found for ${request.url()}. Skipping fetch.`);
+    if (tracking.timer)
+        clearTimeout(tracking.timer);
+    const fullFillConfig = {};
+    if (!tracking.actionResults)
+        tracking.actionResults = [];
+    if (stubAction.config.path) {
+        const filePath = path.join(process.cwd(), "data", "fixtures", stubAction.config.path);
+        debug(`Stub action file path: ${filePath}`);
+        if (existsSync(filePath)) {
+            fullFillConfig.path = filePath;
+            debug(`Stub action fulfilled with file: ${filePath}`);
+        }
+        else {
+            actionStatus = "fail";
+            tracking.actionResults.push({
+                type: "stub_request",
+                description,
+                status: actionStatus,
+                message: `Stub action failed for ${tracking.url}: File not found at ${filePath}`,
+            });
+            stubActionPerformed = true;
+        }
+    }
+    if (!fullFillConfig.path) {
+        if (stubAction.config.statusCode) {
+            fullFillConfig.status = Number(stubAction.config.statusCode);
+        }
+        if (stubAction.config.contentType) {
+            if (stubAction.config.contentType === "application/json") {
+                fullFillConfig.contentType = "application/json";
+                if (stubAction.config.body) {
+                    try {
+                        fullFillConfig.json = JSON.parse(stubAction.config.body);
+                    }
+                    catch (e) {
+                        debug(`Invalid JSON in stub action body: ${stubAction.config.body}, `, e instanceof Error ? e.message : String(e));
+                        debug("Invalid JSON, defaulting to empty object");
+                        fullFillConfig.json = {};
+                    }
+                }
+            }
+            else {
+                fullFillConfig.contentType = stubAction.config.contentType;
+                fullFillConfig.body = stubAction.config.body || "";
+            }
+        }
+        if (!fullFillConfig.json && !fullFillConfig.body) {
+            if (stubAction.config.body) {
+                fullFillConfig.body = stubAction.config.body;
+            }
+        }
+    }
+    if (actionStatus === "success") {
+        try {
+            route.fulfill(fullFillConfig);
+            stubActionPerformed = true;
+            tracking.completed = true;
+            tracking.actionResults.push({
+                type: "stub_request",
+                description,
+                status: actionStatus,
+                message: `Stub action executed for ${request.url()}`,
+            });
+        }
+        catch (e) {
+            actionStatus = "fail";
+            debug(`Failed to fulfill stub request for ${request.url()}`, e);
+            tracking.actionResults.push({
+                type: "stub_request",
+                description,
+                status: actionStatus,
+                message: `Stub action failed for ${request.url()}: ${e instanceof Error ? e.message : String(e)}`,
+            });
+        }
+    }
+    return stubActionPerformed;
 }
 export async function registerBeforeStepRoutes(context, stepName, world) {
+    const debug = createDebug("automation_model:route:registerBeforeStepRoutes");
     const page = context.web.page;
     if (!page)
         throw new Error("context.web.page is missing");
@@ -67,22 +363,35 @@ export async function registerBeforeStepRoutes(context, stepName, world) {
     }
     for (let i = 0; i < allRouteItems.length; i++) {
         const item = allRouteItems[i];
+        debug(`Setting up mandatory route with timeout ${item.timeout}ms: ${JSON.stringify(item.filters)}`);
+        let content = JSON.stringify(item);
+        try {
+            content = await replaceWithLocalTestData(content, context.web.world, true, false, content, context.web, false);
+            allRouteItems[i] = JSON.parse(content); // Modify the original array
+            debug(`After replacing test data: ${JSON.stringify(allRouteItems[i])}`);
+        }
+        catch (error) {
+            debug("Error replacing test data:", error);
+        }
         if (item.mandatory) {
-            debug(`Setting up mandatory route with timeout ${item.timeout}ms: ${JSON.stringify(item.filters)}`);
-            let content = JSON.stringify(item);
-            try {
-                content = await replaceWithLocalTestData(content, context.web.world, true, false, content, context.web, false);
-                allRouteItems[i] = JSON.parse(content); // Modify the original array
-                debug(`After replacing test data: ${JSON.stringify(allRouteItems[i])}`);
-            }
-            catch (error) {
-                debug("Error replacing test data:", error);
-            }
+            const path = item.filters.path;
+            const queryParams = Object.entries(item.filters.queryParams || {})
+                .map(([key, value]) => `${key}=${value}`)
+                .join("&");
+            const tracking = {
+                routeItem: item,
+                url: `${path}${queryParams ? `?${queryParams}` : ""}`,
+                completed: false,
+                startedAt: Date.now(),
+                actionResults: [],
+            };
+            context.__routeState.matched.push(tracking);
         }
     }
     debug("New allrouteItems", JSON.stringify(allRouteItems));
     let message = null;
     page.route("**/*", async (route) => {
+        const debug = createDebug("automation_model:route:intercept");
         const request = route.request();
         debug(`Intercepting request: ${request.method()} ${request.url()}`);
         const matchedItem = allRouteItems.find((item) => matchRoute(item, route));
@@ -90,7 +399,7 @@ export async function registerBeforeStepRoutes(context, stepName, world) {
             return route.continue();
         debug(`Matched route item: ${JSON.stringify(matchedItem)}`);
         debug("Initial context route state", context.__routeState);
-        let tracking = context.__routeState.matched.find((t) => t.routeItem === matchedItem && !t.completed);
+        let tracking = context.__routeState.matched.find((t) => JSON.stringify(t.routeItem) === JSON.stringify(matchedItem) && !t.completed);
         debug("Tracking", tracking);
         let stubActionPerformed = false;
         if (!tracking) {
@@ -112,88 +421,12 @@ export async function registerBeforeStepRoutes(context, stepName, world) {
         }
         const stubAction = matchedItem.actions.find((a) => a.type === "stub_request");
         if (stubAction) {
-            let actionStatus = "success";
-            const description = JSON.stringify(stubAction.config);
-            debug(`Stub action found for ${request.url()}. Skipping fetch.`);
-            if (tracking.timer)
-                clearTimeout(tracking.timer);
-            const fullFillConfig = {};
-            if (stubAction.config.path) {
-                const filePath = path.join(process.cwd(), "data", "fixtures", stubAction.config.path);
-                debug(`Stub action file path: ${filePath}`);
-                if (existsSync(filePath)) {
-                    fullFillConfig.path = filePath;
-                    debug(`Stub action fulfilled with file: ${filePath}`);
-                }
-                else {
-                    actionStatus = "fail";
-                    tracking.actionResults.push({
-                        type: "stub_request",
-                        description,
-                        status: actionStatus,
-                        message: `Stub action failed for ${tracking.url}: File not found at ${filePath}`,
-                    });
-                    stubActionPerformed = true;
-                }
-            }
-            if (!fullFillConfig.path) {
-                if (stubAction.config.statusCode) {
-                    fullFillConfig.status = Number(stubAction.config.statusCode);
-                }
-                if (stubAction.config.contentType) {
-                    if (stubAction.config.contentType === "application/json") {
-                        fullFillConfig.contentType = "application/json";
-                        if (stubAction.config.body) {
-                            try {
-                                fullFillConfig.json = JSON.parse(stubAction.config.body);
-                            }
-                            catch (e) {
-                                debug(`Invalid JSON in stub action body: ${stubAction.config.body}, `, e instanceof Error ? e.message : String(e));
-                                debug("Invalid JSON, defaulting to empty object");
-                                fullFillConfig.json = {};
-                            }
-                        }
-                    }
-                    else {
-                        fullFillConfig.contentType = stubAction.config.contentType;
-                        fullFillConfig.body = stubAction.config.body || "";
-                    }
-                }
-                if (!fullFillConfig.json && !fullFillConfig.body) {
-                    if (stubAction.config.body) {
-                        fullFillConfig.body = stubAction.config.body;
-                    }
-                }
-            }
-            if (actionStatus === "success") {
-                try {
-                    route.fulfill(fullFillConfig);
-                    stubActionPerformed = true;
-                    tracking.completed = true;
-                    tracking.actionResults.push({
-                        type: "stub_request",
-                        description,
-                        status: actionStatus,
-                        message: `Stub action executed for ${request.url()}`,
-                    });
-                }
-                catch (e) {
-                    actionStatus = "fail";
-                    debug(`Failed to fulfill stub request for ${request.url()}`, e);
-                    tracking.actionResults.push({
-                        type: "stub_request",
-                        description,
-                        status: actionStatus,
-                        message: `Stub action failed for ${request.url()}: ${e instanceof Error ? e.message : String(e)}`,
-                    });
-                }
-            }
+            stubActionPerformed = handleStubAction(stubAction, route, tracking);
         }
         if (!stubActionPerformed) {
             let response;
             try {
                 response = await route.fetch();
-                // debug("Matched item response", response);
             }
             catch (e) {
                 console.error("Fetch failed for", request.url(), e);
@@ -201,213 +434,79 @@ export async function registerBeforeStepRoutes(context, stepName, world) {
                     clearTimeout(tracking.timer);
                 return route.abort();
             }
-            let status = response.status();
-            let headers = response.headers();
-            const isBinary = !headers["content-type"]?.includes("application/json") &&
-                !headers["content-type"]?.includes("text") &&
-                !headers["content-type"]?.includes("application/csv");
-            // debug("Matched item isBinary", isBinary);
-            const isJSON = headers["content-type"]?.includes("application/json") || headers["content-type"]?.includes("json")
-                ? true
-                : false;
-            // debug("Matched item isJSON", isJSON);
-            let body;
-            if (isBinary) {
-                body = await response.body(); // returns a Buffer
-            }
-            else {
-                body = await response.text();
-            }
+            const headers = response.headers();
+            const isBinary = !headers["content-type"]?.includes("application/json") && !headers["content-type"]?.includes("text");
+            const body = isBinary ? await response.body() : await response.text();
             let json;
             try {
-                // check if the body is string
-                if (typeof body === "string") {
+                if (typeof body === "string")
                     json = JSON.parse(body);
-                }
             }
             catch (_) { }
+            const actionHandlerContext = {
+                route,
+                tracking,
+                status: response.status(),
+                body,
+                json,
+                isBinary,
+                finalBody: json ?? body,
+                abortActionPerformed: false,
+            };
             const actionResults = [];
-            let abortActionPerformed = false;
-            let finalBody = isJSON && json ? json : body;
-            // debug("Matched item actions", matchedItem.actions);
             for (const action of matchedItem.actions) {
-                let actionStatus = "success";
-                const description = JSON.stringify(action.config);
+                let result;
                 switch (action.type) {
                     case "abort_request":
-                        if (tracking?.timer)
-                            clearTimeout(tracking.timer);
-                        const errorCode = action.config?.errorCode ?? "failed";
-                        console.log(`[abort_request] Aborting  with error code: ${errorCode}`);
-                        await route.abort(errorCode);
-                        abortActionPerformed = true;
-                        tracking.completed = true;
+                        result = handleAbortRequest(action, actionHandlerContext);
                         break;
                     case "status_code_verification":
-                        if (String(status) !== String(action.config)) {
-                            actionStatus = "fail";
-                            message = `Status code verification failed. Expected ${action.config}, got ${status}`;
-                            debug(`[status_code_verification] Failed: ${message}`);
-                        }
-                        else {
-                            console.log(`[status_code_verification] Passed`);
-                            message = `Status code verification passed. Expected ${action.config}, got ${status}`;
-                        }
+                        result = handleStatusCodeVerification(action, actionHandlerContext);
                         break;
                     case "json_modify":
-                        if (!json) {
-                            actionStatus = "fail";
-                            message = "JSON modification failed. Response is not JSON";
-                            debug(`[json_modify] Failed: ${message}`);
-                        }
-                        else {
-                            if (action.config && action.config.path && action.config.modifyValue) {
-                                objectPath.set(json, action.config.path, action.config.modifyValue);
-                                console.log(`[json_modify] Modified path ${action.config.path} to ${action.config.modifyValue}`);
-                                console.log(`[json_modify] Modified JSON`);
-                                message = `JSON modified successfully`;
-                                finalBody = JSON.parse(JSON.stringify(json));
-                            }
-                        }
+                        result = handleJsonModify(action, actionHandlerContext);
                         break;
                     case "json_whole_modify":
-                        if (!json) {
-                            actionStatus = "fail";
-                            message = "JSON modification failed. Response is not JSON";
-                            debug(`[json_whole_modify] Failed: ${message}`);
-                        }
-                        else {
-                            try {
-                                const parsedConfig = JSON.parse(action.config);
-                                json = parsedConfig;
-                                finalBody = JSON.parse(JSON.stringify(json));
-                            }
-                            catch (e) {
-                                actionStatus = "fail";
-                                message = `JSON modification failed. Invalid JSON: ${e instanceof Error ? e.message : String(e)}`;
-                                debug(`[json_whole_modify] Failed: ${message}`);
-                                break;
-                            }
-                            console.log(`[json_whole_modify] Whole JSON replaced`);
-                            message = `JSON replaced successfully`;
-                        }
+                        result = handleJsonWholeModify(action, actionHandlerContext);
                         break;
                     case "status_code_change":
-                        status = Number(action.config);
-                        console.log(`[status_code_change] Status changed to ${status}`);
-                        message = `Status code changed to ${status}`;
+                        result = handleStatusCodeChange(action, actionHandlerContext);
                         break;
                     case "change_text":
-                        if (isBinary) {
-                            actionStatus = "fail";
-                            message = "Change text action failed. Body is not a text";
-                            debug(`[change_text] Failed: ${message}`);
-                        }
-                        else {
-                            body = action.config;
-                            console.log(`[change_text] HTML body replaced`);
-                            message = `HTML body replaced successfully`;
-                            finalBody = body;
-                        }
+                        result = handleChangeText(action, actionHandlerContext);
                         break;
                     case "assert_json":
-                        if (!json) {
-                            actionStatus = "fail";
-                            message = "JSON assertion failed. Response is not JSON";
-                            debug(`[assert_json] Failed: ${message}`);
-                        }
-                        else {
-                            const actual = objectPath.get(json, action.config.path);
-                            if (typeof actual !== "object") {
-                                if (JSON.stringify(actual) !== JSON.stringify(action.config.expectedValue)) {
-                                    actionStatus = "fail";
-                                    message = `JSON assertion failed for path ${action.config.path}: expected ${JSON.stringify(action.config.expectedValue)}, got ${JSON.stringify(actual)}`;
-                                    debug(`[assert_json] Failed: ${message}`);
-                                }
-                            }
-                            else if (JSON.stringify(actual) !== action.config.expectedValue) {
-                                actionStatus = "fail";
-                                message = `JSON assertion failed for path ${action.config.path}: expected ${action.config.expectedValue}, got ${JSON.stringify(actual)}`;
-                                debug(`[assert_json] Failed: ${message}`);
-                            }
-                            else {
-                                console.log(`[assert_json] Assertion passed for path ${action.config.path}`);
-                                message = `JSON assertion passed for path ${action.config.path}`;
-                            }
-                        }
+                        result = handleAssertJson(action, actionHandlerContext);
                         break;
                     case "assert_whole_json":
-                        if (!json) {
-                            actionStatus = "fail";
-                            message = "Whole JSON assertion failed. Response is not JSON";
-                            debug(`[assert_whole_json] Failed: ${message}`);
-                        }
-                        else {
-                            if (action.config.contains) {
-                                const originalJSON = JSON.stringify(json, null, 2);
-                                if (!originalJSON.includes(action.config.contains)) {
-                                    actionStatus = "fail";
-                                    message = `Whole JSON assertion failed. Expected to contain: "${action.config.contains}", actual: "${body}"`;
-                                    debug(`[assert_whole_json] Failed: ${message}`);
-                                }
-                            }
-                            else if (action.config.equals) {
-                                const originalJSON = JSON.stringify(json, null, 2);
-                                if (originalJSON !== action.config.equals) {
-                                    actionStatus = "fail";
-                                    message = `Whole JSON assertion failed. Expected exact match: "${action.config.equals}", actual: "${body}"`;
-                                    debug(`[assert_whole_json] Failed: ${message}`);
-                                }
-                            }
-                            else {
-                                console.log(`[assert_whole_json] Assertion passed`);
-                                message = `Whole JSON assertion passed.`;
-                            }
-                        }
+                        result = handleAssertWholeJson(action, actionHandlerContext);
                         break;
                     case "assert_text":
-                        if (typeof body !== "string") {
-                            console.error(`[assert_text] Body is not text`);
-                            actionStatus = "fail";
-                            message = "Text assertion failed. Body is not text";
-                            debug(`[assert_text] Failed: ${message}`);
-                        }
-                        else {
-                            if (action.config.contains && !body.includes(action.config.contains)) {
-                                actionStatus = "fail";
-                                message = `Text assertion failed. Expected to contain: "${action.config.contains}", actual: "${body}"`;
-                                debug(`[assert_text] Failed: ${message}`);
-                            }
-                            else if (action.config.equals && body !== action.config.equals) {
-                                actionStatus = "fail";
-                                message = `Text assertion failed. Expected exact match: "${action.config.equals}", actual: "${body}"`;
-                                debug(`[assert_text] Failed: ${message}`);
-                            }
-                            else {
-                                console.log(`[assert_text] Assertion passed`);
-                                message = `Text assertion passed.`;
-                            }
-                        }
+                        result = handleAssertText(action, actionHandlerContext);
                         break;
                     default:
-                        console.warn(`Unknown action type: ${action.type}`);
+                        console.warn(`Unknown action type`);
                 }
-                actionResults.push({ type: action.type, description, status: actionStatus, message: message });
-                debug("Action results:", actionResults);
+                if (result)
+                    actionResults.push(result);
             }
             tracking.completed = true;
             tracking.actionResults = actionResults;
             if (tracking.timer)
                 clearTimeout(tracking.timer);
-            if (!abortActionPerformed) {
+            if (!actionHandlerContext.abortActionPerformed) {
                 try {
+                    const isJSON = headers["content-type"]?.includes("application/json");
                     if (isJSON) {
-                        await route.fulfill({ status, json: finalBody, headers });
+                        await route.fulfill({ status: actionHandlerContext.status, json: actionHandlerContext.finalBody, headers });
                     }
                     else {
-                        await route.fulfill({ status, body: finalBody, headers });
+                        await route.fulfill({
+                            status: actionHandlerContext.status,
+                            body: actionHandlerContext.finalBody,
+                            headers,
+                        });
                     }
-                    // await route.fulfill({ status, body: finalBody, headers });
                 }
                 catch (e) {
                     console.error("Failed to fulfill route:", e);