qagentic-reporter 0.1.14 → 0.1.16

package/dist/cypress/index.mjs

@@ -428,18 +428,28 @@ var APIReporter = class {
     if (!this.config.api.enabled) return;
     await this.flushBatch();
     try {
-      await axios.patch(
+      console.log("[APIReporter] Finalizing run with test counts:", {
+        total: run.total,
+        passed: run.passed,
+        failed: run.failed,
+        broken: run.broken,
+        skipped: run.skipped
+      });
+      const patchData = {
+        end_time: run.endTime?.toISOString(),
+        duration_ms: run.durationMs,
+        total: run.total,
+        passed: run.passed,
+        failed: run.failed,
+        broken: run.broken,
+        skipped: run.skipped,
+        status: "completed"
+      };
+      console.log("[APIReporter] PATCH to:", `${this.config.api.url}/api/v1/runs/${run.id}`);
+      console.log("[APIReporter] PATCH data:", patchData);
+      const response = await axios.patch(
         `${this.config.api.url}/api/v1/runs/${run.id}`,
-        {
-          end_time: run.endTime?.toISOString(),
-          duration_ms: run.durationMs,
-          total: run.total,
-          passed: run.passed,
-          failed: run.failed,
-          broken: run.broken,
-          skipped: run.skipped,
-          status: "completed"
-        },
+        patchData,
         {
           headers: {
             "Content-Type": "application/json",
@@ -448,8 +458,12 @@ var APIReporter = class {
           timeout: this.config.api.timeout
         }
       );
+      console.log("[APIReporter] Run finalized successfully:", response.status);
     } catch (error) {
-      console.warn("Warning: Failed to finalize run with API:", error);
+      console.warn("[APIReporter] Failed to finalize run with API:");
+      console.warn("  Error:", error.message);
+      console.warn("  Status:", error.response?.status);
+      console.warn("  Data:", error.response?.data);
     }
   }
   async reportTest(test) {
@@ -851,94 +865,103 @@ function attachJson(data, name = "JSON Data") {
 function attachText(text, name = "Text") {
   return attach(text, name, "text/plain", "txt");
 }
-function setupQAgentic(on, config) {
-  const projectName = process.env.QAGENTIC_PROJECT_NAME || config.projectId || "Cypress E2E Tests";
-  const environment = process.env.QAGENTIC_ENVIRONMENT || process.env.NODE_ENV || "e2e";
-  const apiUrl = process.env.QAGENTIC_API_URL || "http://localhost:8080";
-  console.log("[QAagentic] Initializing with config:", { projectName, environment, apiUrl });
-  configure({
-    projectName,
-    environment,
-    apiUrl,
-    outputDir: "./qagentic-results"
-  });
-  const reporter = QAgenticReporter.getInstance();
-  let currentRun = null;
-  console.log("[QAagentic] Reporter initialized, setting up hooks");
-  (async () => {
+var QAgenticCypressReporter = class {
+  constructor(config) {
+    this.currentRun = null;
+    this.stats = {
+      suites: 0,
+      tests: 0,
+      passes: 0,
+      pending: 0,
+      failures: 0,
+      start: /* @__PURE__ */ new Date(),
+      end: /* @__PURE__ */ new Date(),
+      duration: 0
+    };
+    this.projectName = process.env.QAGENTIC_PROJECT_NAME || config.projectId || "Cypress E2E Tests";
+    this.environment = process.env.QAGENTIC_ENVIRONMENT || process.env.NODE_ENV || "e2e";
+    const apiUrl = process.env.QAGENTIC_API_URL || "http://localhost:8080";
+    configure({
+      projectName: this.projectName,
+      environment: this.environment,
+      apiUrl,
+      outputDir: "./qagentic-results"
+    });
+    this.reporter = QAgenticReporter.getInstance();
+    this.stats.start = /* @__PURE__ */ new Date();
+  }
+  async onRunBegin() {
     try {
-      console.log("[QAagentic] Starting test run immediately");
-      currentRun = await reporter.startRun({
-        name: `cypress_${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "")}`,
-        projectName,
-        environment
+      this.currentRun = await this.reporter.startRun({
+        name: this.projectName,
+        projectName: this.projectName,
+        environment: this.environment,
+        startTime: this.stats.start
       });
-      console.log("[QAagentic] Test run started successfully:", currentRun?.id);
     } catch (error) {
       console.warn("[QAagentic] Failed to start run:", error);
     }
-  })();
-  on("after:spec", async (_spec, results) => {
+  }
+  async onTestEnd(test) {
+    if (!this.currentRun) return;
     try {
-      console.log("[QAagentic] after:spec hook started for:", results.spec.relative);
-      if (!results?.tests) {
-        console.log("[QAagentic] No tests found in spec results");
-        return;
-      }
-      for (const test of results.tests) {
-        try {
-          const testResult = {
-            id: v4(),
-            name: test.title[test.title.length - 1],
-            fullName: test.title.join(" > "),
-            status: parseStatus(test.state),
-            durationMs: test.duration,
-            startTime: new Date(Date.now() - test.duration),
-            endTime: /* @__PURE__ */ new Date(),
-            labels: {
-              suite: test.title.slice(0, -1).join(" > "),
-              feature: test.title[0]
-            },
-            links: [],
-            parameters: {},
-            steps: [],
-            attachments: [],
-            filePath: results.spec.relative,
-            retryCount: 0,
-            isRetry: false,
-            isFlaky: false
-          };
-          if (test.err) {
-            testResult.errorMessage = test.err.message;
-            testResult.stackTrace = test.err.stack;
-            testResult.errorType = "AssertionError";
-          }
-          console.log("[QAagentic] Reporting test:", testResult.name, "-", testResult.status);
-          await reporter.reportTest(testResult);
-        } catch (error) {
-          console.warn("[QAagentic] Failed to report test:", error);
-        }
+      const testResult = {
+        id: v4(),
+        name: test.title[test.title.length - 1],
+        fullName: test.title.join(" > "),
+        status: parseStatus(test.state),
+        durationMs: test.duration,
+        startTime: new Date(Date.now() - test.duration),
+        endTime: /* @__PURE__ */ new Date(),
+        labels: {
+          suite: test.title.slice(0, -1).join(" > "),
+          feature: test.title[0]
+        },
+        links: [],
+        parameters: {},
+        steps: [],
+        attachments: [],
+        filePath: test.invocationDetails?.relativeFile || "",
+        retryCount: 0,
+        isRetry: false,
+        isFlaky: false
+      };
+      if (test.err) {
+        testResult.errorMessage = test.err.message;
+        testResult.stackTrace = test.err.stack;
+        testResult.errorType = "AssertionError";
       }
-      console.log("[QAagentic] after:spec hook completed");
+      this.stats.tests++;
+      if (test.state === "passed") this.stats.passes++;
+      if (test.state === "failed") this.stats.failures++;
+      if (test.state === "pending") this.stats.pending++;
+      await this.reporter.reportTest(testResult);
     } catch (error) {
-      console.warn("[QAagentic] Error in after:spec hook:", error);
+      console.warn("[QAagentic] Failed to report test:", error);
     }
-  });
-  on("task", {
-    qagentic_endRun: async () => {
-      try {
-        console.log("[QAagentic] Ending test run and flushing batch");
-        await reporter.endRun();
-        console.log("[QAagentic] Test run completed and results sent");
-        await new Promise((resolve) => setTimeout(resolve, 2e3));
-        console.log("[QAagentic] All operations completed");
-        return null;
-      } catch (error) {
-        console.warn("[QAagentic] Failed to end run:", error);
-        return null;
-      }
+  }
+  async onRunEnd() {
+    if (!this.currentRun) return;
+    try {
+      this.stats.end = /* @__PURE__ */ new Date();
+      this.stats.duration = this.stats.end.getTime() - this.stats.start.getTime();
+      this.currentRun.endTime = this.stats.end;
+      this.currentRun.durationMs = this.stats.duration;
+      this.currentRun.total = this.stats.tests;
+      this.currentRun.passed = this.stats.passes;
+      this.currentRun.failed = this.stats.failures;
+      this.currentRun.skipped = this.stats.pending;
+      await this.reporter.endRun();
+    } catch (error) {
+      console.warn("[QAagentic] Failed to end run:", error);
     }
-  });
+  }
+};
+function setupQAgentic(on, config) {
+  const reporter = new QAgenticCypressReporter(config);
+  on("before:run", () => reporter.onRunBegin());
+  on("test:after:run", (test) => reporter.onTestEnd(test));
+  on("after:run", () => reporter.onRunEnd());
 }
 
 // src/cypress/index.ts