pw-automation-framework 2.0.1

package/src/core/TestExecutor.ts

@@ -0,0 +1,436 @@
+
+import {
+  RequestPayload, Script, Step,
+  ScriptResult, StepResult, StepStatus,
+  TestCaseConfig, ExecutionResult,
+} from "../types/types";
+import { TestData } from "./TestData";
+import { PlaywrightEngine } from "./PlaywrightEngine";
+import { sseManager } from "../utils/sseManager";
+import { Logger } from "../utils/logger";
+
+type ProgressCallback = (update: Partial<{
+  completed_scripts: number;
+  completed_steps:   number;
+  passed_steps:      number;
+  failed_steps:      number;
+  skipped_steps:     number;
+}>) => void;
+
+type CancelCheck = () => boolean;
+
+const log = Logger.create("TestExecutor");
+
+export class TestExecutor {
+
+  static async run(
+    payload:      RequestPayload,
+    executionId:  string,
+    onProgress?:  ProgressCallback,
+    isCancelled?: CancelCheck
+  ): Promise<ExecutionResult> {
+
+    const startTime     = Date.now();
+    const stopOnFailure = payload.stop_on_failure ?? true;
+    const runParallel   = payload.parallel        ?? false;
+    const maxParallel   = payload.max_parallel    ?? 5;
+    const checkCancel   = isCancelled ?? (() => false);
+
+    sseManager.emit(executionId, "execution_start", {
+      message:       "Execution started",
+      total_scripts: payload.scripts.length,
+      parallel:      runParallel,
+    });
+
+    let scriptResults: ScriptResult[];
+
+    if (runParallel) {
+      scriptResults = await TestExecutor.runParallel(
+        payload.scripts, executionId, stopOnFailure, maxParallel, onProgress, checkCancel
+      );
+    } else {
+      scriptResults = await TestExecutor.runSequential(
+        payload.scripts, executionId, stopOnFailure, onProgress, checkCancel
+      );
+    }
+
+    const wasCancelled   = checkCancel();
+    const overall_status = wasCancelled
+      ? "CANCELLED"
+      : scriptResults.every(s => s.overall_status === "PASS") ? "PASS" : "FAIL";
+
+    const duration_ms = Date.now() - startTime;
+
+    const result: ExecutionResult = {
+      executionId,
+      overall_status: overall_status as any,
+      total_scripts:  scriptResults.length,
+      passed:         scriptResults.filter(s => s.overall_status === "PASS").length,
+      failed:         scriptResults.filter(s => s.overall_status === "FAIL").length,
+      duration_ms,
+      results:        scriptResults,
+    };
+
+    sseManager.emit(executionId, "execution_complete", result);
+    log.info(`Execution ${executionId} → ${overall_status} (${duration_ms}ms)`);
+    return result;
+  }
+
+  // ─── Sequential ────────────────────────────────────────────────────────────
+
+  private static async runSequential(
+    scripts:       Script[],
+    executionId:   string,
+    stopOnFailure: boolean,
+    onProgress?:   ProgressCallback,
+    isCancelled?:  CancelCheck
+  ): Promise<ScriptResult[]> {
+    const results: ScriptResult[] = [];
+    let completed = 0;
+
+    for (const script of scripts) {
+      if (isCancelled?.()) break;
+      const result = await TestExecutor.runScript(script, executionId, stopOnFailure, onProgress, isCancelled);
+      results.push(result);
+      onProgress?.({ completed_scripts: ++completed });
+    }
+    return results;
+  }
+
+  // ─── Parallel ──────────────────────────────────────────────────────────────
+
+  private static async runParallel(
+    scripts:       Script[],
+    executionId:   string,
+    stopOnFailure: boolean,
+    maxParallel:   number,
+    onProgress?:   ProgressCallback,
+    isCancelled?:  CancelCheck
+  ): Promise<ScriptResult[]> {
+    const results:   ScriptResult[] = new Array(scripts.length);
+    let running  = 0, ptr = 0, completed = 0;
+
+    return new Promise((resolve) => {
+      const tryNext = () => {
+        while (running < maxParallel && ptr < scripts.length) {
+          if (isCancelled?.()) { resolve(results.filter(Boolean)); return; }
+          const script = scripts[ptr];
+          const idx    = ptr++;
+          running++;
+
+          TestExecutor.runScript(script, executionId, stopOnFailure, onProgress, isCancelled)
+            .then((result) => {
+              results[idx] = result;
+              running--;
+              completed++;
+              onProgress?.({ completed_scripts: completed });
+              tryNext();
+              if (completed === scripts.length) resolve(results);
+            })
+            .catch(() => {
+              running--;
+              completed++;
+              tryNext();
+              if (completed === scripts.length) resolve(results.filter(Boolean));
+            });
+        }
+      };
+      tryNext();
+    });
+  }
+
+  // ─── Single Script ─────────────────────────────────────────────────────────
+
+  private static async runScript(
+    script:        Script,
+    executionId:   string,
+    stopOnFailure: boolean,
+    onProgress?:   ProgressCallback,
+    isCancelled?:  CancelCheck
+  ): Promise<ScriptResult> {
+
+    const scriptName = script.test_case_name || script.test_script_uid;
+    const startTime  = Date.now();
+    const scriptStop = script.stop_on_failure ?? stopOnFailure;
+
+    const tConfig: TestCaseConfig = {
+      testData:        new TestData(),
+      screenshot_mode: script.screenshot_mode || "on_failure",
+      record_video:    script.record_video    || false,
+      headless:        script.headless        || false,
+      executionId,
+      timeout:         30000,
+    };
+
+    const engine = new PlaywrightEngine(tConfig);
+    const stepResults: StepResult[] = [];
+
+    sseManager.emit(executionId, "script_start", {
+      test_script_uid: script.test_script_uid,
+      test_case_name:  scriptName,
+      total_steps:     script.steps.length,
+      browser:         script.browser || "chromium",
+    });
+
+    log.info(`Script "${scriptName}" | ${script.steps.length} steps`);
+
+    let failureOccurred = false;
+    let failedStepName  = "";
+    let passed = 0, failed = 0, skipped = 0;
+
+    for (let i = 0; i < script.steps.length; i++) {
+      const step       = script.steps[i] as Step;
+      const stepNumber = i + 1;
+      const stepStart  = Date.now();
+
+      // ── Cancellation check ─────────────────────────────────────────────────
+      if (isCancelled?.()) {
+        // Mark remaining steps as SKIP with cancel reason
+        const remaining = script.steps.slice(i);
+        for (let j = 0; j < remaining.length; j++) {
+          const s = remaining[j];
+          const r: StepResult = {
+            uid:         s.uid,
+            step_name:   s.step_name,
+            step_script: s.step_script,
+            status:      "SKIP",
+            comments:    "Skipped — execution was cancelled",
+            skip_reason: "CANCELLED",
+            duration_ms: 0,
+            start_time:  new Date().toISOString(),
+            label: s.label,
+            value: s.value,
+
+          };
+          stepResults.push(r);
+          skipped++;
+          sseManager.emit(executionId, "step_complete", {
+            step_number: i + j + 1,
+            total_steps: script.steps.length,
+            step_name:   s.step_name,
+            status:      "SKIP",
+            comments:    r.comments,
+            skip_reason: r.skip_reason,
+            duration_ms: 0,
+            label: s.label,
+            value: s.value,
+          });
+        }
+        break;
+      }
+
+      // ── Failure skip ───────────────────────────────────────────────────────
+      if (failureOccurred && stopOnFailure) {
+        const r: StepResult = {
+          uid: step.uid,
+          step_name:   step.step_name,
+          step_script: step.step_script,
+          status:      "SKIP",
+          comments:    `Skipped — "${failedStepName}" failed`,
+          skip_reason: `Predecessor "${failedStepName}" failed`,
+          duration_ms: 0,
+          start_time:  new Date().toISOString(),
+          label: step.label,
+          value: step.value,
+        };
+        stepResults.push(r);
+        skipped++;
+        onProgress?.({ completed_steps: passed + failed + skipped, skipped_steps: skipped });
+
+        sseManager.emit(executionId, "step_complete", {
+          step_number: stepNumber,
+          total_steps: script.steps.length,
+          step_name:   step.step_name,
+          step_script: step.step_script,
+          label:       step.label,
+          status:      "SKIP",
+          comments:    r.comments,
+          skip_reason: r.skip_reason,
+          duration_ms: 0,
+        });
+
+        log.warn(`SKIP  #${stepNumber}: "${step.step_name}"`);
+        continue;
+      }
+
+      // ── Execute ────────────────────────────────────────────────────────────
+      sseManager.emit(executionId, "step_start", {
+        step_number: stepNumber,
+        step_name:   step.step_name,
+        step_script: step.step_script,
+        obj_uid:     step.obj_uid,
+        page_uid:    step.page_uid,
+      });
+
+      // let comments   = "";
+      // let screenshot = "";
+      // let status: StepStatus = "FAIL";
+      // let expectedResult: string | undefined = undefined;
+
+      // try {
+      //   const result = await engine.execute(step.step_script,step.label)
+      //   comments   = result?.comments   || "";
+      //   screenshot = result?.screenshot || "";
+      //   status     = result?.status === "Pass" ? "PASS" : "FAIL";
+      //   expectedResult = result?.data?.expected_result || undefined;
+      // } catch (error: any) {
+      //   comments = `Execution error: ${error instanceof Error ? error.message : String(error)}`;
+      //   status   = "FAIL";
+      //   log.error(`CRASH #${stepNumber}: ${error.message}`);
+      // }
+      let comments   = "";
+      let screenshot = "";
+      let status: StepStatus = "FAIL";
+      let expectedResult: string | undefined = undefined;
+      let result: any = undefined;
+
+      try {
+        result     = await engine.execute(step.step_script, step.label);
+        comments   = result?.comments   || "";
+        screenshot = result?.screenshot || "";
+        status     = result?.status === "Pass" ? "PASS" : "FAIL";
+        expectedResult = result?.data?.expected_result || undefined;
+      } catch (error: any) {
+        comments = `Execution error: ${error instanceof Error ? error.message : String(error)}`;
+        status   = "FAIL";
+        log.error(`CRASH #${stepNumber}: ${error.message}`);
+      }
+       console.log("🔴 status:", status, "| failure_type:", result?.data?.failure_type);  // ← ADD HERE
+
+      const duration_ms = Date.now() - stepStart;
+
+      if (status === "PASS") passed++;
+      else {
+        failed++;
+        if (!failureOccurred) { failureOccurred = true; failedStepName = step.step_name; }
+      }
+
+      onProgress?.({
+        completed_steps: passed + failed + skipped,
+        passed_steps:    passed,
+        failed_steps:    failed,
+        skipped_steps:   skipped,
+      });
+
+      const stepResult: StepResult = {
+        uid:            step.uid,
+        obj_uid:         step.obj_uid,
+        step_name:       step.step_name,
+        step_script:     step.step_script,
+        status,
+        page_uid:        step.page_uid,
+        comments,
+        screenshot,
+        duration_ms,
+        start_time:      new Date(Date.now() - duration_ms).toISOString(),
+        expected_result: expectedResult,
+      };
+
+      // ── ELEMENT_NOT_FOUND: capture page source + call comparison API ────────
+      if (status === "FAIL" && result?.data?.failure_type === "ELEMENT_NOT_FOUND") {
+         console.log("🔍 page_uid:", step.page_uid, "| obj_uid:", step.obj_uid, "| app_id:", script.app_id);
+        try {
+          const pageSource = await engine.getPageSource();
+          const subUrl     = await engine.getCurrentURL();
+
+          console.log(`🌐 Current URL: ${subUrl}`);
+
+          // if (pageSource) {
+          //   const fs     = require("fs");
+          //   const path   = require("path");
+          //   const folder = "captured_pagesource";
+          //   fs.mkdirSync(folder, { recursive: true });
+          //   const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+          //   const fileName  = path.join(folder, `pagesource_${step.uid}_${timestamp}.html`);
+          //   fs.writeFileSync(fileName, pageSource, "utf-8");
+          //   console.log(`✅ Page source saved: ${fileName}`);
+          // }
+
+          if (step.page_uid && pageSource) {
+            console.log(`🔍 Step failed at index: ${i} | uid: ${step.uid} | obj_uid: ${step.obj_uid}`);
+
+            const diffResp = await fetch("http://localhost:5005/api/ui/compare", {
+              method:  "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                app_id:            script.app_id,
+                uid:               step.page_uid,
+                obj_uid:           step.obj_uid,
+                new_pagesource:    pageSource,
+                sub_url:           subUrl,
+                mode:              "html",
+                failed_step_index: i,
+              }),
+              signal: AbortSignal.timeout(60000),
+            });
+            console.log("📡 comparison API status:", diffResp.status);
+            const comparisonResult = await diffResp.json();
+            console.log("📦 comparison result:", JSON.stringify(comparisonResult));
+            stepResult.comparison_code = comparisonResult;
+            console.log("✅ comparison_code set:", JSON.stringify(stepResult.comparison_code));
+
+            // stepResult.comparison_code = await diffResp.json();
+          }
+
+        } catch (err: any) {
+          stepResult.comparison_code = { success: false, error: err.message };
+          console.error(`❌ Page source capture failed: ${err.message}`);
+        }
+      }
+      // ────────────────────────────────────────────────────────────────────────
+      console.log("📦 stepResult before push:", JSON.stringify(stepResult));
+
+      stepResults.push(stepResult);
+
+      sseManager.emit(executionId, "step_complete", {
+        step_number: stepNumber,
+        total_steps: script.steps.length,
+        step_name:   step.step_name,
+        step_script: step.step_script,
+        status,
+        comments,
+        screenshot,
+        duration_ms,
+        obj_uid:     step.obj_uid,
+        comparison_code: stepResult.comparison_code,
+      });
+
+      log.info(`${status.padEnd(4)} #${stepNumber}: "${step.step_name}" (${duration_ms}ms)`);
+    }
+
+    await engine.forceClose();
+
+    const overall_status = isCancelled?.() ? "FAIL"
+      : failed > 0 ? "FAIL" : "PASS";
+    const duration_ms    = Date.now() - startTime;
+
+    const scriptResult: ScriptResult = {
+      test_script_uid: script.test_script_uid || "",
+      test_case_name:  scriptName,
+      step_results:    stepResults,
+      overall_status:  overall_status as any,
+      app_id:          script.app_id,
+      duration_ms,
+      start_time:      new Date(Date.now() - duration_ms).toISOString(),
+      browser:         script.browser,
+      passed_steps:    passed,
+      failed_steps:    failed,
+      skipped_steps:   skipped,
+      total_steps:     script.steps.length,
+    };
+
+    sseManager.emit(executionId, "script_complete", {
+      test_script_uid: script.test_script_uid,
+      test_case_name:  scriptName,
+      overall_status,
+      duration_ms,
+      passed_steps:    passed,
+      failed_steps:    failed,
+      skipped_steps:   skipped,
+      total_steps:     script.steps.length,
+    });
+
+    log.info(`Script "${scriptName}" → ${overall_status} | ✅${passed} ❌${failed} ⏭${skipped}`);
+    return scriptResult;
+  }
+}