@testdino/playwright 1.0.1 → 1.0.3

package/dist/index.mjs

@@ -384,7 +384,7 @@ var EventBuffer = class {
   events = [];
   maxSize;
   onFlush;
-  isFlushing = false;
+  flushPromise = null;
   constructor(options) {
     this.maxSize = options.maxSize || 10;
     this.onFlush = options.onFlush || (async () => {
@@ -402,12 +402,30 @@ var EventBuffer = class {
   }
   /**
    * Flush all buffered events
+   * If a flush is already in progress, waits for it to complete then flushes any new events
    */
   async flush() {
-    if (this.isFlushing || this.events.length === 0) {
+    if (this.flushPromise) {
+      await this.flushPromise;
+      if (this.events.length > 0) {
+        return this.flush();
+      }
+      return;
+    }
+    if (this.events.length === 0) {
       return;
     }
-    this.isFlushing = true;
+    this.flushPromise = this.doFlush();
+    try {
+      await this.flushPromise;
+    } finally {
+      this.flushPromise = null;
+    }
+  }
+  /**
+   * Internal flush implementation
+   */
+  async doFlush() {
     try {
       const eventsToFlush = [...this.events];
       this.events = [];
@@ -415,8 +433,6 @@ var EventBuffer = class {
     } catch (error) {
       console.error("Failed to flush events:", error);
       throw error;
-    } finally {
-      this.isFlushing = false;
     }
   }
   /**
@@ -1734,6 +1750,8 @@ var TestdinoReporter = class {
   // Deferred initialization - resolves true on success, false on failure
   initPromise = null;
   initFailed = false;
+  // Promises for onTestEnd; must be awaited in onEnd to prevent data loss
+  pendingTestEndPromises = /* @__PURE__ */ new Set();
   constructor(config = {}) {
     const cliConfig = this.loadCliConfig();
     this.config = { ...config, ...cliConfig };
@@ -2018,49 +2036,72 @@ var TestdinoReporter = class {
     await this.buffer.add(event);
   }
   /**
-   * Called after each test completes
-   */
-  async onTestEnd(test, result) {
+   /**
+    * Called after each test.
+    * Playwright does not await onTestEnd promises—pending work is awaited in onEnd.
+    */
+  onTestEnd(test, result) {
     if (!this.initPromise || this.initFailed) return;
-    const attachmentsWithUrls = await this.uploadAttachments(result.attachments, test.id);
-    const event = {
-      type: "test:end",
-      runId: this.runId,
-      ...this.getEventMetadata(),
-      // Test Identification
-      testId: test.id,
-      // Status Information
-      status: result.status,
-      outcome: test.outcome(),
-      // Timing
-      duration: result.duration,
-      // Execution Context
-      retry: result.retry,
-      // Worker Information
-      workerIndex: result.workerIndex,
-      parallelIndex: result.parallelIndex,
-      // Test Metadata
-      annotations: test.annotations.map((a) => ({
-        type: a.type,
-        description: a.description
-      })),
-      // Error Information
-      errors: result.errors.map((e) => this.extractError(e)).filter((e) => e !== void 0),
-      // Step Summary
-      steps: this.extractTestStepsSummary(result),
-      // Attachments Metadata (with Azure URLs when uploaded)
-      attachments: attachmentsWithUrls,
-      // Console Output
-      stdout: result.stdout.length > 0 ? this.extractConsoleOutput(result.stdout) : void 0,
-      stderr: result.stderr.length > 0 ? this.extractConsoleOutput(result.stderr) : void 0
-    };
-    await this.buffer.add(event);
+    const workPromise = this.processTestEnd(test, result);
+    this.pendingTestEndPromises.add(workPromise);
+    workPromise.finally(() => {
+      this.pendingTestEndPromises.delete(workPromise);
+    });
+  }
+  /**
+   * Process test end event asynchronously
+   * Uploads attachments and adds test:end event to buffer
+   */
+  async processTestEnd(test, result) {
+    try {
+      const attachmentsWithUrls = await this.uploadAttachments(result.attachments, test.id);
+      const event = {
+        type: "test:end",
+        runId: this.runId,
+        ...this.getEventMetadata(),
+        // Test Identification
+        testId: test.id,
+        // Status Information
+        status: result.status,
+        outcome: test.outcome(),
+        // Timing
+        duration: result.duration,
+        // Execution Context
+        retry: result.retry,
+        // Worker Information
+        workerIndex: result.workerIndex,
+        parallelIndex: result.parallelIndex,
+        // Test Metadata
+        annotations: test.annotations.map((a) => ({
+          type: a.type,
+          description: a.description
+        })),
+        // Error Information
+        errors: result.errors.map((e) => this.extractError(e)).filter((e) => e !== void 0),
+        // Step Summary
+        steps: this.extractTestStepsSummary(result),
+        // Attachments Metadata (with Azure URLs when uploaded)
+        attachments: attachmentsWithUrls,
+        // Console Output
+        stdout: result.stdout.length > 0 ? this.extractConsoleOutput(result.stdout) : void 0,
+        stderr: result.stderr.length > 0 ? this.extractConsoleOutput(result.stderr) : void 0
+      };
+      await this.buffer.add(event);
+    } catch (error) {
+      console.error(
+        "\u274C TestDino: Failed to process test:end event:",
+        error instanceof Error ? error.message : String(error)
+      );
+    }
   }
   /**
    * Called after all tests complete
    */
   async onEnd(result) {
     if (this.quotaExceeded) {
+      if (this.pendingTestEndPromises.size > 0) {
+        await Promise.allSettled(Array.from(this.pendingTestEndPromises));
+      }
       console.log("\u2705 TestDino: Tests completed (quota limit reached; not streamed to TestDino)");
       this.wsClient?.close();
       this.removeSignalHandlers();
@@ -2070,10 +2111,17 @@ var TestdinoReporter = class {
     const success = await this.initPromise;
     if (!success) {
       this.buffer?.clear();
+      this.pendingTestEndPromises.clear();
       this.wsClient?.close();
       this.removeSignalHandlers();
       return;
     }
+    if (this.pendingTestEndPromises.size > 0) {
+      if (this.config.debug) {
+        console.log(`\u{1F50D} TestDino: Waiting for ${this.pendingTestEndPromises.size} pending test:end events...`);
+      }
+      await Promise.allSettled(Array.from(this.pendingTestEndPromises));
+    }
     const event = {
       type: "run:end",
       runId: this.runId,
@@ -2538,6 +2586,17 @@ var TestdinoReporter = class {
     if (!this.initPromise) {
       process.exit(exitCode);
     }
+    const waitForPending = async () => {
+      if (this.pendingTestEndPromises.size > 0) {
+        try {
+          await Promise.race([
+            Promise.allSettled(Array.from(this.pendingTestEndPromises)),
+            this.timeoutPromise(2e3, "Pending events timeout")
+          ]);
+        } catch {
+        }
+      }
+    };
     const event = {
       type: "run:end",
       runId: this.runId,
@@ -2557,6 +2616,7 @@ var TestdinoReporter = class {
     }, 3e3);
     const sendAndExit = async () => {
       try {
+        await waitForPending();
         await Promise.race([this.sendInterruptionEvent(event), this.timeoutPromise(2500, "Send timeout")]);
         console.log("\u2705 TestDino: Interruption event sent");
       } catch (error) {