@dev-blinq/cucumber_client 1.0.1311-dev → 1.0.1313-dev

package/bin/client/recorderv3/network.js

@@ -0,0 +1,299 @@
+/**
+ * @typedef {Object} NetworkEvent
+ * @property {import('playwright').Request} request
+ * @property {import('playwright').Response|null} response
+ * @property {string} id
+ * @property {number} timestamp
+ * @property {string} status - 'completed', 'failed'
+ */
+
+class NetworkMonitor {
+  constructor() {
+    this.networkId = 0;
+    /** @type {Map<string, NetworkEvent>} */
+    this.requestIdMap = new Map();
+    this.networkEvents = new Map();
+    /** @type {Map<import('playwright').Page, {responseListener: Function, requestFailedListener: Function}>} */
+    this.pageListeners = new Map();
+  }
+
+  /**
+   * Add network event listeners to a page
+   * @param {import('playwright').Page} page
+   */
+  addNetworkEventListener(page) {
+    // Create the listener functions
+    const responseListener = async (response) => {
+      const request = response.request();
+      let eventId = this.requestIdMap.get(request);
+
+      if (!eventId) {
+        this.networkId++;
+        eventId = this.networkId.toString();
+        this.requestIdMap.set(request, eventId);
+      }
+
+      const networkEvent = {
+        id: eventId,
+        request,
+        response,
+        timestamp: Date.now(),
+        status: "completed",
+      };
+
+      this.networkEvents.set(eventId, networkEvent);
+    };
+
+    const requestFailedListener = (request) => {
+      let eventId = this.requestIdMap.get(request);
+
+      if (!eventId) {
+        this.networkId++;
+        eventId = this.networkId.toString();
+        this.requestIdMap.set(request, eventId);
+      }
+
+      const networkEvent = {
+        id: eventId,
+        request,
+        response: null,
+        timestamp: Date.now(),
+        status: "failed",
+      };
+
+      this.networkEvents.set(eventId, networkEvent);
+    };
+    // Store the listeners for later removal
+    this.pageListeners.set(page, {
+      responseListener,
+      requestFailedListener,
+    });
+
+    // Add the listeners to the page
+    page.on("response", responseListener);
+    page.on("requestfailed", requestFailedListener);
+  }
+
+  /**
+   * Remove network event listeners from a specific page
+   * @param {import('playwright').Page} page
+   */
+  removeNetworkEventListener(page) {
+    const listeners = this.pageListeners.get(page);
+    if (listeners) {
+      page.off("response", listeners.responseListener);
+      page.off("requestfailed", listeners.requestFailedListener);
+      this.pageListeners.delete(page);
+      console.log("Network event listeners removed from page");
+    }
+  }
+
+  /**
+   * Remove network event listeners from all pages
+   */
+  removeAllNetworkEventListeners() {
+    for (const [page, listeners] of this.pageListeners) {
+      page.off("response", listeners.responseListener);
+      page.off("requestfailed", listeners.requestFailedListener);
+    }
+    this.pageListeners.clear();
+    console.log("All network event listeners removed");
+  }
+
+  /**
+   * Check if a page has active listeners
+   * @param {import('playwright').Page} page
+   * @returns {boolean}
+   */
+  hasListeners(page) {
+    return this.pageListeners.has(page);
+  }
+
+  /**
+   * Get the number of pages with active listeners
+   * @returns {number}
+   */
+  getActiveListenersCount() {
+    return this.pageListeners.size;
+  }
+
+  /**
+   * Get all network events until now
+   */
+  getAllNetworkEvents() {
+    return Array.from(this.networkEvents.values());
+  }
+
+  /**
+   * Get network events within a range
+   * @param {number} startId
+   * @param {number} endId
+   * @returns {NetworkEvent[]}
+   */
+  getNetworkEventsInRange(startId, endId) {
+    const events = [];
+    for (let i = startId; i <= endId; i++) {
+      const event = this.networkEvents.get(i.toString());
+      if (event) {
+        events.push(event);
+      }
+    }
+    return events;
+  }
+
+  /**
+   * Get network events since a specific ID
+   * @param {number} sinceId
+   * @returns {NetworkEvent[]}
+   */
+  getNetworkEventsSince(sinceId) {
+    return this.getNetworkEventsInRange(sinceId + 1, this.networkId);
+  }
+
+  /**
+   * Get events by status
+   * @param {string} status - 'completed', 'failed'
+   * @returns {NetworkEvent[]}
+   */
+  getEventsByStatus(status) {
+    return Array.from(this.networkEvents.values()).filter((event) => event.status === status);
+  }
+
+  /**
+   * Get current network ID (latest)
+   * @returns {number}
+   */
+  getCurrentNetworkId() {
+    return this.networkId;
+  }
+
+  getCurrentNetworkEventsLength() {
+    return this.networkEvents.size;
+  }
+
+  /**
+   * Get statistics about stored events
+   * @returns {Object}
+   */
+  getStats() {
+    const events = Array.from(this.networkEvents.values());
+    return {
+      total: events.length,
+      completed: events.filter((e) => e.status === "completed").length,
+      failed: events.filter((e) => e.status === "failed").length,
+      oldestTimestamp: events.length > 0 ? Math.min(...events.map((e) => e.timestamp)) : null,
+      newestTimestamp: events.length > 0 ? Math.max(...events.map((e) => e.timestamp)) : null,
+    };
+  }
+
+  /**
+   * Marshall network event for serialization
+   * @param {NetworkEvent} networkEvent
+   * @returns {Promise<Object>}
+   */
+  async marshallNetworkEvent(networkEvent) {
+    const { request, response } = networkEvent;
+
+    try {
+      const url = new URL(request.url());
+      const marshalledEvent = {
+        id: networkEvent.id,
+        timestamp: networkEvent.timestamp,
+        status: networkEvent.status,
+        url: url.href,
+        method: request.method(),
+        statusCode: response?.status() ?? null,
+        statusText: response?.statusText() ?? null,
+        queryParams: Object.fromEntries(url.searchParams.entries()),
+      };
+
+      // Try to get response body safely (only for successful responses)
+      if (response && networkEvent.status === "completed") {
+        try {
+          const isBinary =
+            !response.headers()["content-type"]?.includes("application/json") &&
+            !response.headers()["content-type"]?.includes("text");
+          let body;
+          if (isBinary) {
+            body = await response.body();
+          } else {
+            body = await response.text();
+          }
+          let json;
+          try {
+            if (typeof body === "string") {
+              json = JSON.parse(body); // Check if body is valid JSON
+            }
+          } catch (_) {
+            //Ignore
+          }
+          const responseBody = isBinary ? body : json ? JSON.stringify(json) : body;
+          marshalledEvent.contentType = isBinary ? "binary" : json ? "json" : "text";
+          marshalledEvent.responseBody = responseBody;
+        } catch (error) {
+          marshalledEvent.responseBody = `[Error reading response: ${error.message}]`;
+        }
+      } else if (networkEvent.status === "failed") {
+        marshalledEvent.failureReason = request.failure()?.errorText || "Unknown error";
+      }
+
+      console.log("Marshalled network event:", marshalledEvent);
+
+      return marshalledEvent;
+    } catch (error) {
+      console.error("Error marshalling network event:", error);
+      return {
+        id: networkEvent.id,
+        timestamp: networkEvent.timestamp,
+        status: networkEvent.status,
+        url: request.url(),
+        method: request.method(),
+        error: error.message,
+      };
+    }
+  }
+
+  /**
+   *@returns {Promise<Object[]>}
+   * Get all marshalled network events
+   * This is useful for sending to the server or saving to a file.
+   *   */
+  async getAllMarshalledNetworkEvents() {
+    const events = this.getAllNetworkEvents();
+    const marshalledEvents = await Promise.all(events.map((event) => this.marshallNetworkEvent(event)));
+    return marshalledEvents;
+  }
+
+  /**
+   * Get marshalled network events since this ID
+   * @returns {Promise<Object[]>}
+   * @param {number} sinceId
+   */
+  async getMarshalledNetworkEvents(sinceId) {
+    const events = this.getNetworkEventsSince(sinceId);
+    const marshalledEvents = await Promise.all(events.map((event) => this.marshallNetworkEvent(event)));
+    return marshalledEvents;
+  }
+
+  /**
+   * Get marshalled network events in a range
+   * @param {number} startId
+   * @param {number} endId
+   * @returns {Promise<Object[]>}
+   */
+  async getMarshalledNetworkEventsInRange(startId, endId) {
+    const events = this.getNetworkEventsInRange(startId, endId);
+    const marshalledEvents = await Promise.all(events.map((event) => this.marshallNetworkEvent(event)));
+    return marshalledEvents;
+  }
+
+  /**
+   * Clear all network events
+   */
+  clearNetworkEvents() {
+    this.networkEvents.clear();
+    this.networkId = 0;
+  }
+}
+
+export default NetworkMonitor;

package/bin/client/recorderv3/step_runner.js

@@ -33,8 +33,9 @@ async function withAbort(fn, signal) {
 export class BVTStepRunner {
   #currentStepController;
   #port;
-  constructor({ projectDir }) {
+  constructor({ projectDir, sendExecutionStatus }) {
     this.projectDir = projectDir;
+    this.sendExecutionStatus = sendExecutionStatus;
   }
   setRemoteDebugPort(port) {
     this.#port = port;
@@ -74,6 +75,119 @@ export class BVTStepRunner {
     writeFileSync(tFilePath, tFileContent);
     return tFilePath;
   }
+
+  executeStepRemote = async ({ feature_file_path, scenario, tempFolderPath, stepText }, options) => {
+    if (!options) {
+      options = {
+        skipAfter: true,
+      };
+    }
+    const environment = {
+      ...process.env,
+    };
+
+    try {
+      const { loadConfiguration, loadSupport, runCucumber } = await import("@dev-blinq/cucumber-js/api");
+      const { runConfiguration } = await loadConfiguration(
+        {
+          provided: {
+            name: [scenario],
+            paths: [feature_file_path],
+            import: [path.join(tempFolderPath, "step_definitions", "**", "*.mjs")],
+            // format: ["bvt"],
+          },
+        },
+        { cwd: process.cwd(), env: environment }
+      );
+      // const files = glob.sync(path.join(tempFolderPath, "step_definitions", "**", "*.mjs"));
+      // console.log("Files found:", files);
+      const support = await loadSupport(runConfiguration, { cwd: process.cwd(), env: environment });
+      // console.log("found ", support.stepDefinitions.length, "step definitions");
+      // support.stepDefinitions.map((step) => {
+      //   console.log("step", step.pattern);
+      // });
+
+      if (options.skipAfter) {
+        // ignore afterAll/after hooks
+        support.afterTestCaseHookDefinitions = [];
+        support.afterTestRunHookDefinitions = [];
+      }
+
+      let errorMesssage = null;
+      let info = null;
+      let errInfo = null;
+      const result = await runCucumber({ ...runConfiguration, support }, environment, (message) => {
+        if (message.testStepFinished) {
+          const { testStepFinished } = message;
+          const { testStepResult } = testStepFinished;
+          if (testStepResult.status === "FAILED" || testStepResult.status === "AMBIGUOUS") {
+            if (!errorMesssage) {
+              errorMesssage = testStepResult.message;
+              if (info) {
+                errInfo = info;
+              }
+            }
+          }
+          if (testStepResult.status === "UNDEFINED") {
+            if (!errorMesssage) {
+              errorMesssage = `step ${JSON.stringify(stepText)} is ${testStepResult.status}`;
+              if (info) {
+                errInfo = info;
+              }
+            }
+          }
+        }
+        if (message.attachment) {
+          const attachment = message.attachment;
+          if (attachment.mediaType === "application/json" && attachment.body) {
+            const body = JSON.parse(attachment.body);
+            info = body.info;
+
+            if (body && body.payload) {
+              const payload = body.payload;
+              const content = payload.content;
+              const type = payload.type;
+              if (type === "cmdReport") {
+                if (content) {
+                  const report = JSON.parse(content);
+                  switch (report.status) {
+                    case "start":
+                      this.sendExecutionStatus({
+                        type: "cmdExecutionStart",
+                        cmdId: report.cmdId,
+                      });
+                      break;
+                    case "end":
+                      this.sendExecutionStatus({
+                        type: "cmdExecutionSuccess",
+                        cmdId: report.cmdId,
+                      });
+                      break;
+                    default:
+                      console.warn("Unknown command report status:", report.status);
+                  }
+                }
+              }
+            }
+          }
+        }
+      });
+      if (errorMesssage) {
+        const bvtError = new Error(errorMesssage);
+        Object.assign(bvtError, { info: errInfo });
+        throw bvtError;
+      }
+
+      return {
+        result,
+        info,
+      };
+    } catch (error) {
+      console.error("Error running cucumber-js", error);
+      throw error;
+    }
+  };
+
   async runStep({ step, parametersMap, envPath, tags }, bvtContext, options) {
     let codePage; // = getCodePage();
     // const tempFolderPath = process.env.tempFeaturesFolderPath;
@@ -121,7 +235,7 @@ export class BVTStepRunner {
     const stepExecController = new AbortController();
     this.#currentStepController = stepExecController;
     const { result, info } = await withAbort(async () => {
-      return await stepsDefinitions.executeStepRemote(
+      return await this.executeStepRemote(
         {
           feature_file_path,
           tempFolderPath,

package/bin/client/recorderv3/step_utils.js

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "fs";
 import path from "path";
 import url from "url";
 import logger from "../../logger.js";
@@ -9,6 +9,8 @@ import { Step } from "../cucumber/feature.js";
 import { locateDefinitionPath, StepsDefinitions } from "../cucumber/steps_definitions.js";
 import { Recording } from "../recording.js";
 import { generateApiCode } from "../code_gen/api_codegen.js";
+import { tmpdir } from "os";
+import { createHash } from "crypto";
 
 const __dirname = path.dirname(url.fileURLToPath(import.meta.url));
 
@@ -69,10 +71,35 @@ function makeStepTextUnique(step, stepsDefinitions) {
 }
 
 export async function saveRecording({ step, cucumberStep, codePage, projectDir, stepsDefinitions }) {
-  // console.log("saveRecording", step.text);
+  let routesPath = path.join(tmpdir(), "blinq_temp_routes");
+
+  if (process.env.TEMP_RUN) {
+    if (existsSync(routesPath)) {
+      rmSync(routesPath, { recursive: true });
+    }
+    mkdirSync(routesPath, { recursive: true });
+    saveRoutes({ step, folderPath: routesPath });
+  } else {
+    if (existsSync(routesPath)) {
+      // remove the folder
+      try {
+        rmSync(routesPath, { recursive: true });
+        console.log("Removed temp_routes_folder:", routesPath);
+      } catch (error) {
+        console.error("Error removing temp_routes folder", error);
+      }
+      routesPath = path.join(projectDir, "data", "routes");
+      if (!existsSync(routesPath)) {
+        mkdirSync(routesPath, { recursive: true });
+      }
+      saveRoutes({ step, folderPath: routesPath });
+    }
+  }
+
   if (step.isImplementedWhileRecording && !process.env.TEMP_RUN) {
     return;
   }
+
   if (step.isImplemented && step.shouldOverride) {
     let stepDef = stepsDefinitions.findMatchingStep(step.text);
     codePage = getCodePage(stepDef.file);
@@ -82,6 +109,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       return;
     }
   }
+
   cucumberStep.text = step.text;
   const recording = new Recording();
   const steps = step.commands;
@@ -108,6 +136,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       isStaticToken,
       status,
     } = step.commands[0].value;
+
     const result = await generateApiCode(
       {
         url,
@@ -132,6 +161,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
       step.keyword,
       stepsDefinitions
     );
+
     if (!step.isImplemented) {
       stepsDefinitions.addStep({
         name: step.text,
@@ -139,6 +169,7 @@ export async function saveRecording({ step, cucumberStep, codePage, projectDir,
         source: "recorder",
       });
     }
+
     cucumberStep.methodName = result.methodName;
     return result.codePage;
   } else {
@@ -345,3 +376,40 @@ export async function updateStepDefinitions({ scenario, featureName, projectDir
   }
   writeFileSync(utilsFilePath, utilsContent, "utf8");
 }
+
+export function saveRoutes({ step, folderPath }) {
+  const routeItems = step.routeItems;
+  if (!routeItems || routeItems.length === 0) {
+    return;
+  }
+  const cucumberStep = getCucumberStep({ step });
+  const template = cucumberStep.getTemplate();
+  const stepNameHash = createHash("sha256").update(template).digest("hex");
+  const routeItemsWithFilters = routeItems.map((routeItem) => {
+    const oldFilters = routeItem.filters;
+    const queryParamsObject = {};
+    oldFilters.queryParams.forEach((queryParam) => {
+      queryParamsObject[queryParam.key] = queryParam.value;
+    });
+    const newFilters = { path: oldFilters.path, method: oldFilters.method, queryParams: queryParamsObject };
+    return {
+      ...routeItem,
+      filters: newFilters,
+    };
+  });
+
+  const routesFilePath = path.join(folderPath, stepNameHash + ".json");
+  const routesData = {
+    template,
+    routes: routeItemsWithFilters,
+  };
+  if (!existsSync(folderPath)) {
+    mkdirSync(folderPath, { recursive: true });
+  }
+  try {
+    writeFileSync(routesFilePath, JSON.stringify(routesData, null, 2), "utf8");
+    console.log("Saved routes to", routesFilePath);
+  } catch (error) {
+    console.error("Failed to save routes to", routesFilePath, "Error:", error);
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dev-blinq/cucumber_client",
-  "version": "1.0.1311-dev",
+  "version": "1.0.1313-dev",
   "description": "",
   "main": "bin/index.js",
   "types": "bin/index.d.ts",
@@ -32,7 +32,7 @@
     "@cucumber/tag-expressions": "^6.1.1",
     "@dev-blinq/cucumber-js": "1.0.177-dev",
     "@faker-js/faker": "^8.1.0",
-    "automation_model": "1.0.772-dev",
+    "automation_model": "1.0.774-dev",
     "axios": "^1.7.4",
     "chokidar": "^3.6.0",
     "create-require": "^1.1.1",