@stanterprise/playwright-reporter 0.0.20 → 0.1.0

package/dist/client/grpcClient.d.ts

@@ -1,10 +1,16 @@
 import { StanterpriseReporterOptions } from "../types";
 import * as grpc from "@grpc/grpc-js";
+import { MessageQueue } from "./messageQueue";
 export default function getClient(options: StanterpriseReporterOptions): grpc.Client | null;
 /**
- * Helper: generic unary call using raw method path with retry support
+ * Helper: generic unary call using raw method path with retry support.
+ *
+ * When a `queue` is provided the call is enqueued and executed only after all
+ * previously enqueued calls have completed, guaranteeing sequential delivery to
+ * the server. Without a queue the call is executed immediately (legacy / test
+ * behaviour).
  */
-export declare function reportUnary(options: StanterpriseReporterOptions, grpcClient: grpc.Client, path: string, message: {
+export declare function reportUnary(options: StanterpriseReporterOptions, grpcClient: grpc.Client, grpcPath: string, message: {
     serialize?: (w?: any) => Uint8Array;
     serializeBinary?: () => Uint8Array;
-}, deadlineMs?: number): Promise<Buffer>;
+}, deadlineMs?: number, queue?: MessageQueue): Promise<Buffer>;

package/dist/client/grpcClient.js

@@ -146,13 +146,24 @@ async function attemptWithRetries(options, grpcClient, path, message, deadlineMs
     throw lastError || new Error("Retry loop exhausted without result");
 }
 /**
- * Helper: generic unary call using raw method path with retry support
+ * Helper: generic unary call using raw method path with retry support.
+ *
+ * When a `queue` is provided the call is enqueued and executed only after all
+ * previously enqueued calls have completed, guaranteeing sequential delivery to
+ * the server. Without a queue the call is executed immediately (legacy / test
+ * behaviour).
  */
-async function reportUnary(options, grpcClient, path, message, deadlineMs = 1000) {
+async function reportUnary(options, grpcClient, grpcPath, message, deadlineMs = 1000, queue) {
     if (!options.grpcEnabled || !grpcClient) {
         return Buffer.alloc(0);
     }
-    await (0, debugLogger_1.writeDebugEntry)(options, path, message);
-    const maxRetries = options.grpcMaxRetries ?? 3;
-    return attemptWithRetries(options, grpcClient, path, message, deadlineMs, maxRetries);
+    const execute = async () => {
+        await (0, debugLogger_1.writeDebugEntry)(options, grpcPath, message);
+        const maxRetries = options.grpcMaxRetries ?? 3;
+        return attemptWithRetries(options, grpcClient, grpcPath, message, deadlineMs, maxRetries);
+    };
+    if (queue) {
+        return queue.enqueue(execute);
+    }
+    return execute();
 }

package/dist/client/messageQueue.d.ts

@@ -0,0 +1,27 @@
+/**
+ * A sequential async message queue that processes enqueued tasks one at a time,
+ * guaranteeing that each task completes before the next one begins.
+ *
+ * This ensures that gRPC messages are delivered to the server in the exact order
+ * they were enqueued, regardless of how quickly each individual call completes.
+ * It also serializes debug file writes as a side effect, since those are performed
+ * inside each task.
+ */
+export declare class MessageQueue {
+    private tasks;
+    private processing;
+    private drainResolvers;
+    /**
+     * Adds a task to the queue and returns a Promise that resolves (or rejects)
+     * when the task has been executed. If the queue is idle the task starts
+     * immediately; otherwise it waits for all preceding tasks to finish first.
+     */
+    enqueue<T>(fn: () => Promise<T>): Promise<T>;
+    /**
+     * Returns a Promise that resolves once the queue has been fully drained
+     * (i.e. all currently enqueued tasks have finished). Resolves immediately
+     * if the queue is already empty.
+     */
+    drain(): Promise<void>;
+    private processNext;
+}

package/dist/client/messageQueue.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageQueue = void 0;
+/**
+ * A sequential async message queue that processes enqueued tasks one at a time,
+ * guaranteeing that each task completes before the next one begins.
+ *
+ * This ensures that gRPC messages are delivered to the server in the exact order
+ * they were enqueued, regardless of how quickly each individual call completes.
+ * It also serializes debug file writes as a side effect, since those are performed
+ * inside each task.
+ */
+class MessageQueue {
+    constructor() {
+        this.tasks = [];
+        this.processing = false;
+        this.drainResolvers = [];
+    }
+    /**
+     * Adds a task to the queue and returns a Promise that resolves (or rejects)
+     * when the task has been executed. If the queue is idle the task starts
+     * immediately; otherwise it waits for all preceding tasks to finish first.
+     */
+    enqueue(fn) {
+        return new Promise((resolve, reject) => {
+            this.tasks.push(async () => {
+                try {
+                    const result = await fn();
+                    resolve(result);
+                }
+                catch (e) {
+                    reject(e);
+                }
+            });
+            if (!this.processing) {
+                this.processNext();
+            }
+        });
+    }
+    /**
+     * Returns a Promise that resolves once the queue has been fully drained
+     * (i.e. all currently enqueued tasks have finished). Resolves immediately
+     * if the queue is already empty.
+     */
+    drain() {
+        if (!this.processing && this.tasks.length === 0) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve) => {
+            this.drainResolvers.push(resolve);
+        });
+    }
+    async processNext() {
+        this.processing = true;
+        while (this.tasks.length > 0) {
+            const task = this.tasks.shift();
+            try {
+                await task();
+            }
+            catch {
+                // Each task's promise already carries the error to its caller.
+                // Errors must not stop the queue from processing subsequent tasks.
+            }
+        }
+        this.processing = false;
+        const resolvers = this.drainResolvers;
+        this.drainResolvers = [];
+        resolvers.forEach((r) => r());
+    }
+}
+exports.MessageQueue = MessageQueue;

package/dist/handlers/onBeginHandler.d.ts

@@ -2,4 +2,5 @@ import { FullConfig } from "@playwright/test";
 import { Suite } from "@playwright/test/reporter";
 import { StanterpriseReporterOptions } from "../types";
 import * as grpc from "@grpc/grpc-js";
-export declare function handleOnBeginEvent(config: FullConfig, suite: Suite, name: string, runId: string, client: grpc.Client, options: StanterpriseReporterOptions): void;
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnBeginEvent(config: FullConfig, suite: Suite, name: string, runId: string, client: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue): void;

package/dist/handlers/onBeginHandler.js

@@ -6,7 +6,7 @@ const grpcClient_1 = require("../client/grpcClient");
 const entities_1 = require("@stanterprise/protobuf/testsystem/v1/entities");
 const utils_1 = require("../utils");
 const common_1 = require("@stanterprise/protobuf/testsystem/v1/common");
-function handleOnBeginEvent(config, suite, name, runId, client, options) {
+function handleOnBeginEvent(config, suite, name, runId, client, options, queue) {
     // Report root suite and all child suites recursively
     // Convert all metadata values to strings for protobuf compatibility
     // Use plain object instead of Map - protobuf expects object literals
@@ -31,7 +31,7 @@ function handleOnBeginEvent(config, suite, name, runId, client, options) {
         total_tests: suite.allTests().length,
         metadata: (0, utils_1.toMetadataMap)(metadata),
     });
-    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportRunStart", request, options.grpcTimeout).catch((e) => {
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportRunStart", request, options.grpcTimeout, queue).catch((e) => {
         const details = e instanceof Error ? `${e.message}` : String(e);
         console.warn(`onBegin. gRPC disabled for the remainder of the run. Address=${options.grpcAddress}. Details: ${details}`);
     });

package/dist/handlers/onEndHandler.d.ts

@@ -1,4 +1,5 @@
 import { FullResult } from "@playwright/test/reporter";
 import { StanterpriseReporterOptions } from "../types";
 import * as grpc from "@grpc/grpc-js";
-export declare function handleOnEndEvent(result: FullResult, runId: string, client: grpc.Client, options: StanterpriseReporterOptions): void;
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnEndEvent(result: FullResult, runId: string, client: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue, metadata?: Record<string, string>): void;

package/dist/handlers/onEndHandler.js

@@ -19,7 +19,7 @@ function mapTestStatus(status) {
             return common_1.TestStatus.UNKNOWN;
     }
 }
-function handleOnEndEvent(result, runId, client, options) {
+function handleOnEndEvent(result, runId, client, options, queue, metadata) {
     // Validate and sanitize inputs to prevent serialization failures
     const startTimeMs = result.startTime?.getTime();
     const duration = result.duration;
@@ -35,8 +35,9 @@ function handleOnEndEvent(result, runId, client, options) {
         final_status: mapTestStatus(result.status),
         start_time: (0, utils_1.createTimestampFromMs)(validStartTimeMs),
         duration: (0, utils_1.createDuration)(validDuration),
+        metadata: (0, utils_1.toMetadataMap)(metadata || {}),
     });
-    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportRunEnd", request, options.grpcTimeout).catch((error) => {
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportRunEnd", request, options.grpcTimeout, queue).catch((error) => {
         if (error instanceof Error) {
             console.error(`Failed to report end event: ${error.message}`, {
                 stack: error.stack,

package/dist/handlers/onErrorHandler.d.ts

@@ -1,4 +1,5 @@
 import { TestError } from "@playwright/test/reporter";
 import { StanterpriseReporterOptions } from "../types";
 import * as grpc from "@grpc/grpc-js";
-export declare function handleOnErrorEvent(error: TestError, runId: string, grpcClient: grpc.Client, options: StanterpriseReporterOptions): void;
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnErrorEvent(error: TestError, runId: string, grpcClient: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue): void;

package/dist/handlers/onErrorHandler.js

@@ -4,12 +4,12 @@ exports.handleOnErrorEvent = handleOnErrorEvent;
 const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
 const timeHelpers_1 = require("../utils/timeHelpers");
 const grpcClient_1 = require("../client/grpcClient");
-function handleOnErrorEvent(error, runId, grpcClient, options) {
+function handleOnErrorEvent(error, runId, grpcClient, options, queue) {
     const request = new events_1.StdErrorEventRequest({
         run_id: runId,
         message: error.message,
         timestamp: (0, timeHelpers_1.createTimestampFromMs)(Date.now()),
     });
     // Fire-and-forget to avoid slowing tests
-    (0, grpcClient_1.reportUnary)(options, grpcClient, "/testsystem.v1.observer.TestEventCollector/ReportStdError", request, options.grpcTimeout).catch((e) => console.error("Failed to report standard error", e));
+    (0, grpcClient_1.reportUnary)(options, grpcClient, "/testsystem.v1.observer.TestEventCollector/ReportStdError", request, options.grpcTimeout, queue).catch((e) => console.error("Failed to report standard error", e));
 }

package/dist/handlers/onStepBeginHandler.d.ts

@@ -1,4 +1,5 @@
 import { TestCase, TestResult, TestStep } from "@playwright/test/reporter";
 import { StanterpriseReporterOptions } from "../types";
 import * as grpc from "@grpc/grpc-js";
-export declare function handleOnStepBeginEvent(test: TestCase, result: TestResult, step: TestStep, runId: string, client: grpc.Client, options: StanterpriseReporterOptions): void;
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnStepBeginEvent(test: TestCase, result: TestResult, step: TestStep, runId: string, client: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue): void;

package/dist/handlers/onStepBeginHandler.js

@@ -7,7 +7,7 @@ const utils_1 = require("../utils");
 const grpcClient_1 = require("../client/grpcClient");
 const utils_2 = require("../utils");
 const common_1 = require("@stanterprise/protobuf/testsystem/v1/common");
-function handleOnStepBeginEvent(test, result, step, runId, client, options) {
+function handleOnStepBeginEvent(test, result, step, runId, client, options, queue) {
     // Build metadata from step annotations
     const metadata = (0, utils_1.buildStepMetadata)(step);
     // Get parent step ID if this step has a parent
@@ -34,5 +34,5 @@ function handleOnStepBeginEvent(test, result, step, runId, client, options) {
         }),
     });
     // Fire-and-forget to avoid slowing tests
-    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportStepBegin", request, options.grpcTimeout).catch((e) => console.error("Failed to report step begin", e));
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportStepBegin", request, options.grpcTimeout, queue).catch((e) => console.error("Failed to report step begin", e));
 }

package/dist/handlers/onStepEndHandler.d.ts

@@ -1,4 +1,5 @@
 import { TestCase, TestResult, TestStep } from "@playwright/test/reporter";
 import { StanterpriseReporterOptions } from "../types";
 import * as grpc from "@grpc/grpc-js";
-export declare function handleOnStepEndEvent(test: TestCase, result: TestResult, step: TestStep, runId: string, client: grpc.Client, options: StanterpriseReporterOptions): void;
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnStepEndEvent(test: TestCase, result: TestResult, step: TestStep, runId: string, client: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue): void;

package/dist/handlers/onStepEndHandler.js

@@ -6,7 +6,7 @@ const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
 const utils_1 = require("../utils");
 const grpcClient_1 = require("../client/grpcClient");
 const utils_2 = require("../utils");
-function handleOnStepEndEvent(test, result, step, runId, client, options) {
+function handleOnStepEndEvent(test, result, step, runId, client, options, queue) {
     // Map step error to status
     const stepStatus = (0, utils_1.mapStepStatus)(!!step.error);
     // Build metadata from step annotations
@@ -55,5 +55,5 @@ function handleOnStepEndEvent(test, result, step, runId, client, options) {
         }),
     });
     // Fire-and-forget to avoid slowing tests
-    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportStepEnd", request, options.grpcTimeout).catch((e) => console.error("Failed to report step end", e));
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportStepEnd", request, options.grpcTimeout, queue).catch((e) => console.error("Failed to report step end", e));
 }

package/dist/handlers/onTestBeginHandler.d.ts

@@ -1,4 +1,5 @@
 import { TestCase, TestResult } from "@playwright/test/reporter";
 import { StanterpriseReporterOptions } from "../types";
 import * as grpc from "@grpc/grpc-js";
-export declare function handleOnTestBeginEvent(test: TestCase, result: TestResult, runId: string, client: grpc.Client, options: StanterpriseReporterOptions): void;
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnTestBeginEvent(test: TestCase, result: TestResult, runId: string, client: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue): void;

package/dist/handlers/onTestBeginHandler.js

@@ -6,7 +6,7 @@ const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
 const utils_1 = require("../utils");
 const grpcClient_1 = require("../client/grpcClient");
 const common_1 = require("@stanterprise/protobuf/testsystem/v1/common");
-function handleOnTestBeginEvent(test, result, runId, client, options) {
+function handleOnTestBeginEvent(test, result, runId, client, options, queue) {
     // Build and send the TestBegin event via generic unary call.
     const request = new events_1.TestBeginEventRequest({
         test_case: new entities_1.TestCaseRun({
@@ -25,7 +25,7 @@ function handleOnTestBeginEvent(test, result, runId, client, options) {
         }),
     });
     // Fire-and-forget to avoid slowing tests; log errors once.
-    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportTestBegin", request, options.grpcTimeout).catch((e) => {
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportTestBegin", request, options.grpcTimeout, queue).catch((e) => {
         const details = e instanceof Error ? `${e.message}` : String(e);
         console.warn(`Failed to report test begin. Details: ${details}`);
     });

package/dist/handlers/onTestEndHandler.d.ts

@@ -1,4 +1,5 @@
 import { TestCase, TestResult } from "@playwright/test/reporter";
 import { StanterpriseReporterOptions } from "../types";
 import * as grpc from "@grpc/grpc-js";
-export declare function handleOnTestEndEvent(test: TestCase, result: TestResult, runId: string, client: grpc.Client, options: StanterpriseReporterOptions): void;
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnTestEndEvent(test: TestCase, result: TestResult, runId: string, client: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue): void;

package/dist/handlers/onTestEndHandler.js

@@ -10,7 +10,7 @@ const utils_2 = require("../utils");
  * Constant for converting bytes to megabytes
  */
 const BYTES_PER_MB = 1048576;
-function handleOnTestEndEvent(test, result, runId, client, options) {
+function handleOnTestEndEvent(test, result, runId, client, options, queue) {
     // Map Playwright test status to protobuf TestStatus
     const testStatus = (0, utils_1.mapTestStatus)(result.status);
     // Process attachments (screenshots, videos, etc.)
@@ -51,7 +51,7 @@ function handleOnTestEndEvent(test, result, runId, client, options) {
             `Error length: ${errorMessage.length + stackTrace.length} bytes`);
     }
     // Fire-and-forget to avoid slowing tests
-    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportTestEnd", request, options.grpcTimeout).catch((e) => {
+    (0, grpcClient_1.reportUnary)(options, client, "/testsystem.v1.observer.TestEventCollector/ReportTestEnd", request, options.grpcTimeout, queue).catch((e) => {
         console.error(`Failed to report test end for "${test.title}" (payload size: ${(payloadSize / BYTES_PER_MB).toFixed(2)}MB)`, e);
     });
 }

package/dist/handlers/onTestFailHandler.d.ts

@@ -1,4 +1,5 @@
 import { TestCase, TestResult } from "@playwright/test/reporter";
 import { StanterpriseReporterOptions } from "../types";
 import * as grpc from "@grpc/grpc-js";
-export declare function handleOnTestFailEvent(test: TestCase, result: TestResult, runId: string, grpcClient: grpc.Client, options: StanterpriseReporterOptions): void;
+import { MessageQueue } from "../client/messageQueue";
+export declare function handleOnTestFailEvent(test: TestCase, result: TestResult, runId: string, grpcClient: grpc.Client, options: StanterpriseReporterOptions, queue?: MessageQueue): void;

package/dist/handlers/onTestFailHandler.js

@@ -4,7 +4,7 @@ exports.handleOnTestFailEvent = handleOnTestFailEvent;
 const utils_1 = require("../utils");
 const events_1 = require("@stanterprise/protobuf/testsystem/v1/events");
 const grpcClient_1 = require("../client/grpcClient");
-function handleOnTestFailEvent(test, result, runId, grpcClient, options) {
+function handleOnTestFailEvent(test, result, runId, grpcClient, options, queue) {
     // Extract failure details
     const { errorMessage: failureMessage, stackTrace } = (0, utils_1.extractErrorInfo)(result);
     // Process attachments for failed tests
@@ -20,5 +20,5 @@ function handleOnTestFailEvent(test, result, runId, grpcClient, options) {
         retry_index: result.retry,
     });
     // Fire-and-forget to avoid slowing tests
-    (0, grpcClient_1.reportUnary)(options, grpcClient, "/testsystem.v1.observer.TestEventCollector/ReportTestFailure", request, options.grpcTimeout).catch((e) => console.error("Failed to report test failure", e));
+    (0, grpcClient_1.reportUnary)(options, grpcClient, "/testsystem.v1.observer.TestEventCollector/ReportTestFailure", request, options.grpcTimeout, queue).catch((e) => console.error("Failed to report test failure", e));
 }

package/dist/reporter.d.ts

@@ -5,6 +5,8 @@ export default class StanterpriseReporter implements Reporter {
     private options;
     private runId;
     private runStartTime;
+    private messageQueue;
+    private metadata;
     constructor(options?: StanterpriseReporterOptions);
     onBegin(config: FullConfig, suite: Suite): void;
     onExit(): Promise<void>;

package/dist/reporter.js

@@ -7,6 +7,7 @@ const crypto_1 = require("crypto");
 const optionsMapper_1 = __importDefault(require("./utils/optionsMapper"));
 const debugLogger_1 = require("./utils/debugLogger");
 const grpcClient_1 = __importDefault(require("./client/grpcClient"));
+const messageQueue_1 = require("./client/messageQueue");
 const handlers_1 = require("./handlers");
 class StanterpriseReporter {
     constructor(options = {}) {
@@ -16,6 +17,9 @@ class StanterpriseReporter {
         // Generate a unique run ID for this test run
         this.runId = "";
         this.runStartTime = new Date();
+        // Sequential message queue – guarantees ordered delivery to the server
+        this.messageQueue = new messageQueue_1.MessageQueue();
+        this.metadata = {};
         this.options = (0, optionsMapper_1.default)(options);
         if (this.options.verbose) {
             console.log("Stanterprise Reporter: Initialized with options:", {
@@ -31,6 +35,10 @@ class StanterpriseReporter {
         (0, debugLogger_1.initDebugFile)(this.options);
     }
     onBegin(config, suite) {
+        if (config.shard) {
+            this.metadata["shard.current"] = String(config.shard.current);
+            this.metadata["shard.total"] = String(config.shard.total);
+        }
         // Lazily create the client if enabled.
         if (this.options.grpcEnabled) {
             this.grpcClient = (0, grpcClient_1.default)(this.options);
@@ -53,10 +61,12 @@ class StanterpriseReporter {
             }
         }
         if (this.options.grpcEnabled) {
-            (0, handlers_1.handleOnBeginEvent)(config, suite, process.env.STANTERPRISE_TEST_RUN_NAME || "Playwright Test Run", this.runId, this.grpcClient, this.options);
+            (0, handlers_1.handleOnBeginEvent)(config, suite, process.env.STANTERPRISE_TEST_RUN_NAME || "Playwright Test Run", this.runId, this.grpcClient, this.options, this.messageQueue);
         }
     }
     async onExit() {
+        // Wait for all enqueued messages to be sent before closing the connection.
+        await this.messageQueue.drain();
         console.log(`Stanterprise Reporter: Test run completed - Run ID: ${this.runId}`);
         // Cleanup gRPC client
         try {
@@ -76,7 +86,7 @@ class StanterpriseReporter {
             console.log(`Playwright start time: ${result.startTime.toISOString()}`);
         }
         if (this.options.grpcEnabled) {
-            (0, handlers_1.handleOnEndEvent)(result, this.runId, this.grpcClient, this.options);
+            (0, handlers_1.handleOnEndEvent)(result, this.runId, this.grpcClient, this.options, this.messageQueue, this.metadata);
         }
         return Promise.resolve();
     }
@@ -88,7 +98,7 @@ class StanterpriseReporter {
             console.log(`  Test ID: ${test.id}`);
         }
         if (this.options.grpcEnabled) {
-            (0, handlers_1.handleOnTestBeginEvent)(test, result, this.runId, this.grpcClient, this.options);
+            (0, handlers_1.handleOnTestBeginEvent)(test, result, this.runId, this.grpcClient, this.options, this.messageQueue);
         }
     }
     async onStepBegin(test, result, step) {
@@ -97,7 +107,7 @@ class StanterpriseReporter {
             console.log(`  Category: ${step.category}`);
         }
         if (this.options.grpcEnabled) {
-            (0, handlers_1.handleOnStepBeginEvent)(test, result, step, this.runId, this.grpcClient, this.options);
+            (0, handlers_1.handleOnStepBeginEvent)(test, result, step, this.runId, this.grpcClient, this.options, this.messageQueue);
         }
     }
     onStepEnd(test, result, step) {
@@ -106,7 +116,7 @@ class StanterpriseReporter {
             console.log(`  Duration: ${step.duration}ms`);
         }
         if (this.options.grpcEnabled) {
-            (0, handlers_1.handleOnStepEndEvent)(test, result, step, this.runId, this.grpcClient, this.options);
+            (0, handlers_1.handleOnStepEndEvent)(test, result, step, this.runId, this.grpcClient, this.options, this.messageQueue);
         }
     }
     onTestEnd(test, result) {
@@ -116,7 +126,7 @@ class StanterpriseReporter {
             console.log(`  Duration: ${result.duration}ms`);
         }
         if (this.options.grpcEnabled) {
-            (0, handlers_1.handleOnTestEndEvent)(test, result, this.runId, this.grpcClient, this.options);
+            (0, handlers_1.handleOnTestEndEvent)(test, result, this.runId, this.grpcClient, this.options, this.messageQueue);
         }
     }
     onTestFail(test, result) {
@@ -124,7 +134,7 @@ class StanterpriseReporter {
             console.log(`Stanterprise Reporter: Test failed - ${test.title}`);
         }
         if (this.options.grpcEnabled) {
-            (0, handlers_1.handleOnTestFailEvent)(test, result, this.runId, this.grpcClient, this.options);
+            (0, handlers_1.handleOnTestFailEvent)(test, result, this.runId, this.grpcClient, this.options, this.messageQueue);
         }
     }
     onError(error) {
@@ -134,7 +144,7 @@ class StanterpriseReporter {
             console.error(`Stack trace: ${error.stack}`);
         }
         if (this.options.grpcEnabled) {
-            (0, handlers_1.handleOnErrorEvent)(error, this.runId, this.grpcClient, this.options);
+            (0, handlers_1.handleOnErrorEvent)(error, this.runId, this.grpcClient, this.options, this.messageQueue);
         }
     }
     onStdErr(chunk, test, result) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stanterprise/playwright-reporter",
-  "version": "0.0.20",
+  "version": "0.1.0",
   "description": "Custom Playwright test reporter that sends test results to Stanterprise via gRPC",
   "homepage": "https://github.com/stanterprise/stanterprise-playwright-reporter#readme",
   "bugs": {
@@ -53,6 +53,6 @@
     "@grpc/grpc-js": "^1.14.1",
     "@protobuf-ts/grpc-transport": "^2.11.1",
     "@protobuf-ts/grpcweb-transport": "^2.11.1",
-    "@stanterprise/protobuf": "^0.0.21"
+    "@stanterprise/protobuf": "^0.1.1"
   }
 }