@stanterprise/playwright-reporter 0.0.0-debug-flag-2

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025 Stanterprise Team
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,472 @@
+# stanterprise-playwright-reporter
+
+Custom Playwright test reporter that sends test results to Stanterprise via gRPC.
+
+## Features
+
+- 📊 **Comprehensive Test Reporting**: Reports test lifecycle events including begin, end, and failures
+- 🔄 **Step Tracking**: Tracks and reports individual test steps with timing and status
+- 📎 **Attachment Support**: Handles screenshots, videos, and other test attachments
+- 🔌 **gRPC Integration**: Communicates with Stanterprise backend via gRPC protocol
+- ⚙️ **Configurable**: Supports environment variables and configuration options
+- 🛡️ **Error Resilient**: Graceful error handling that doesn't interrupt test execution
+
+## Installation
+
+```bash
+npm install stanterprise-playwright-reporter --save-dev
+```
+
+## Configuration
+
+### Basic Setup
+
+Add the reporter to your `playwright.config.ts`:
+
+```typescript
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  reporter: [["stanterprise-playwright-reporter"]],
+  // ... other config
+});
+```
+
+### Advanced Configuration
+
+```typescript
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  reporter: [
+    [
+      "stanterprise-playwright-reporter",
+      {
+        grpcAddress: "localhost:50051", // gRPC server address
+        grpcEnabled: true, // Enable/disable gRPC reporting
+        grpcTimeout: 1000, // Timeout for gRPC calls in milliseconds
+        grpcMaxMessageSize: 104857600, // Max message size (100MB default)
+        maxAttachmentSize: 10485760, // Max attachment size (10MB default)
+        verbose: false, // Enable verbose logging
+      },
+    ],
+  ],
+  // ... other config
+});
+```
+
+### Environment Variables
+
+You can also configure the reporter using environment variables:
+
+- `STANTERPRISE_GRPC_ADDRESS`: gRPC server address (default: `localhost:50051`)
+- `STANTERPRISE_GRPC_ENABLED`: Enable/disable gRPC reporting (default: `true`)
+- `STANTERPRISE_META_*`: Custom metadata fields for test runs (prefix will be stripped)
+
+#### Custom Metadata
+
+Any environment variable with the `STANTERPRISE_META_` prefix will be automatically included in the test run metadata. The prefix is stripped from the key name.
+
+For example:
+
+- `STANTERPRISE_META_BUILD_ID=12345` becomes `BUILD_ID: 12345` in metadata
+- `STANTERPRISE_META_BRANCH=main` becomes `BRANCH: main` in metadata
+- `STANTERPRISE_META_COMMIT_SHA=abc123` becomes `COMMIT_SHA: abc123` in metadata
+
+Example:
+
+```bash
+STANTERPRISE_GRPC_ADDRESS=myserver.com:50051 \
+STANTERPRISE_META_BUILD_ID=12345 \
+STANTERPRISE_META_BRANCH=main \
+npx playwright test
+```
+
+## Configuration Options
+
+| Option               | Type    | Default           | Description                                         |
+| -------------------- | ------- | ----------------- | --------------------------------------------------- |
+| `grpcAddress`        | string  | `localhost:50051` | gRPC server address                                 |
+| `grpcEnabled`        | boolean | `true`            | Enable/disable gRPC reporting                       |
+| `grpcTimeout`        | number  | `1000`            | Timeout for gRPC calls in milliseconds              |
+| `grpcMaxMessageSize` | number  | `104857600`       | Max message size in bytes (100MB default)           |
+| `maxAttachmentSize`  | number  | `10485760`        | Max attachment content size in bytes (10MB default) |
+| `verbose`            | boolean | `false`           | Enable verbose logging                              |
+| `grpcMaxRetries`     | number  | `3`               | Maximum number of retry attempts for failed gRPC calls  |
+| `grpcRetryDelay`     | number  | `100`             | Initial delay for retries in ms (uses exponential backoff) |
+
+### Retry Configuration
+
+The reporter automatically retries failed gRPC calls for transient errors using exponential backoff:
+
+- **Retryable errors**: `UNAVAILABLE`, `DEADLINE_EXCEEDED`, `INTERNAL`, `UNKNOWN`
+- **Non-retryable errors**: `INVALID_ARGUMENT`, `NOT_FOUND`, `PERMISSION_DENIED`, `UNAUTHENTICATED`, `ALREADY_EXISTS`
+
+**Exponential backoff formula**: `grpcRetryDelay * (2 ^ attemptNumber)`
+
+Example with default settings (`grpcRetryDelay: 100`, `grpcMaxRetries: 3`):
+- Initial attempt: Immediate
+- Retry 1: Wait 100ms (100 * 2^0)
+- Retry 2: Wait 200ms (100 * 2^1)
+- Retry 3: Wait 400ms (100 * 2^2)
+
+```typescript
+export default defineConfig({
+  reporter: [
+    [
+      "stanterprise-playwright-reporter",
+      {
+        grpcMaxRetries: 5,        // Try up to 5 times
+        grpcRetryDelay: 200,      // Start with 200ms delay
+        verbose: true,            // Log retry attempts
+      },
+    ],
+  ],
+});
+```
+
+To disable retries:
+
+```typescript
+{
+  grpcMaxRetries: 0  // No retries, fail fast
+}
+```
+
+## Sharding Support
+
+The reporter automatically detects and reports when tests are running in sharded mode. When sharding is configured, the reporter includes the following metadata in test run events:
+
+- `shard.current`: The current shard number (1-based)
+- `shard.total`: The total number of shards
+
+### Configuring Sharding
+
+In your `playwright.config.ts`:
+
+```typescript
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  shard: { total: 5, current: 1 },
+  reporter: [["stanterprise-playwright-reporter"]],
+});
+```
+
+Or via CLI:
+
+```bash
+npx playwright test --shard=1/5
+npx playwright test --shard=2/5
+# ... etc
+```
+
+### Aggregating Results Across Shards
+
+**Important:** To have a complete set of tests accumulated in the observability server, you must specify the same `STANTERPRISE_RUN_ID` environment variable for all shards. This ensures that results from all shards are associated with the same test run.
+
+```bash
+# Set the same run ID for all shards
+export STANTERPRISE_RUN_ID="my-test-run-123"
+
+# Run all shards with the same run ID
+npx playwright test --shard=1/5
+npx playwright test --shard=2/5
+npx playwright test --shard=3/5
+npx playwright test --shard=4/5
+npx playwright test --shard=5/5
+```
+
+In CI/CD environments, you can use a unique identifier from your CI system:
+
+```bash
+# GitHub Actions example
+STANTERPRISE_RUN_ID="${GITHUB_RUN_ID}" npx playwright test --shard=1/5
+
+# GitLab CI example
+STANTERPRISE_RUN_ID="${CI_PIPELINE_ID}" npx playwright test --shard=1/5
+
+# Jenkins example
+STANTERPRISE_RUN_ID="${BUILD_ID}" npx playwright test --shard=1/5
+```
+
+Without a shared `STANTERPRISE_RUN_ID`, each shard will generate its own unique run ID, and the results will be reported as separate test runs rather than a single aggregated run.
+
+The shard information is automatically included in the metadata sent to the server, allowing you to:
+
+- Track which tests ran on which shard
+- Aggregate results from multiple shards
+- Debug shard-specific issues
+
+When verbose logging is enabled, you'll see shard information in the console output:
+
+```
+Stanterprise Reporter: Test run started with ID: 123e4567-e89b-12d3-a456-426614174000
+Number of tests: 42
+Run started at: 2026-01-25T10:30:00.000Z
+Shard: 1 of 5
+```
+
+## What Gets Reported
+
+### Test Events
+
+- **Test Begin**: When a test starts
+- **Test End**: When a test completes with status (passed/failed/skipped/timedOut)
+- **Test Failure**: Detailed failure information including error messages and stack traces
+
+### Step Events
+
+- **Step Begin**: When a test step starts
+- **Step End**: When a test step completes with duration and status
+
+### Attachments
+
+The reporter automatically processes and sends:
+
+- Screenshots
+- Videos
+- Trace files
+- Any other attachments captured during test execution
+
+## Usage Example
+
+```typescript
+// playwright.config.ts
+import { defineConfig } from "@playwright/test";
+
+export default defineConfig({
+  use: {
+    screenshot: "only-on-failure",
+    video: "retain-on-failure",
+  },
+  reporter: [
+    ["list"], // Also show in console
+    [
+      "stanterprise-playwright-reporter",
+      {
+        grpcAddress: process.env.STANTERPRISE_GRPC_ADDRESS || "localhost:50051",
+        verbose: process.env.CI === "true",
+      },
+    ],
+  ],
+});
+```
+
+## API
+
+### StanterpriseReporter
+
+Main reporter class implementing Playwright's `Reporter` interface.
+
+```typescript
+import { StanterpriseReporter } from "stanterprise-playwright-reporter";
+
+const reporter = new StanterpriseReporter({
+  grpcAddress: "localhost:50051",
+  grpcEnabled: true,
+  grpcTimeout: 1000,
+  grpcMaxMessageSize: 104857600, // 100MB
+  maxAttachmentSize: 10485760, // 10MB
+  verbose: false,
+});
+```
+
+### Types
+
+```typescript
+import type {
+  StanterpriseReporterOptions,
+  TestExecutionContext,
+  StepExecutionContext,
+} from "stanterprise-playwright-reporter";
+```
+
+## Development
+
+### Building
+
+```bash
+npm run build
+```
+
+### Testing
+
+```bash
+npm test
+```
+
+### Cleaning
+
+```bash
+npm run clean
+```
+
+## How It Works
+
+1. **Test Run Initialization**: When tests start, the reporter generates a unique run ID and establishes a gRPC connection
+2. **Event Reporting**: As tests execute, the reporter sends events to the Stanterprise backend via gRPC
+3. **Fire-and-Forget**: Events are sent asynchronously to avoid slowing down test execution
+4. **Error Handling**: Connection errors are logged once and further attempts are disabled for that run
+5. **Cleanup**: When tests complete, the gRPC connection is properly closed
+
+## Architecture
+
+The reporter is organized into several modules:
+
+- **reporter.ts**: Main reporter implementation
+- **types.ts**: TypeScript type definitions and interfaces
+- **utils/statusMapper.ts**: Maps Playwright statuses to protobuf enums
+- **utils/attachmentProcessor.ts**: Processes test attachments
+- **utils/timeHelpers.ts**: Handles timestamp and duration conversions
+
+## Troubleshooting
+
+### gRPC Error 13 INTERNAL: failed to publish event
+
+This error typically occurs due to one of two issues:
+
+**1. Metadata Serialization (Most Common)**
+
+If you see this error with the stack trace mentioning "metadata is not iterable" or serialization issues, it was a bug in v0.0.13 and earlier versions. **Solution: Upgrade to v0.0.14 or later.**
+
+**2. Large Attachments**
+
+This error can also occur when test event payloads exceed the gRPC message size limit. Common causes:
+
+1. **Large attachments**: Tests with large screenshots, videos, or trace files
+2. **Default size limits**: gRPC has a default 4MB message size limit
+
+**Solutions:**
+
+1. **Increase message size limits** (recommended):
+
+   ```typescript
+   reporter: [
+     [
+       "stanterprise-playwright-reporter",
+       {
+         grpcMaxMessageSize: 104857600, // 100MB (default)
+         maxAttachmentSize: 10485760,   // 10MB (default)
+       },
+     ],
+   ],
+   ```
+
+2. **Reduce attachment sizes**:
+   - Configure Playwright to save attachments to disk instead of embedding them
+   - The reporter automatically uses file paths when available instead of content
+
+   ```typescript
+   use: {
+     screenshot: "only-on-failure",
+     video: "retain-on-failure",
+     trace: "retain-on-failure",
+   },
+   ```
+
+3. **Monitor payload sizes**: Enable verbose logging to see actual payload sizes:
+   ```typescript
+   reporter: [
+     ["stanterprise-playwright-reporter", { verbose: true }],
+   ],
+   ```
+
+The reporter will log warnings when attachments exceed the size limit and automatically skip their content while preserving metadata.
+
+### Connection Issues
+
+If you see gRPC connection errors:
+
+1. Verify the gRPC server is running and accessible
+2. Check the `grpcAddress` configuration
+3. Ensure firewall rules allow the connection
+4. Enable verbose logging to see detailed error messages
+
+### Reporter Not Working
+
+1. Verify the reporter is properly configured in `playwright.config.ts`
+2. Check that `grpcEnabled` is not set to `false`
+3. Look for error messages in the test output
+4. Try with `verbose: true` to see detailed logs
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## For Maintainers
+
+### Publishing to NPM
+
+#### Automated Publishing (Recommended)
+
+The repository uses GitHub Actions to automatically publish to NPM when a version tag is pushed:
+
+1. Update the version following [semantic versioning](https://semver.org/):
+
+   ```bash
+   npm version patch  # for bug fixes (1.0.0 → 1.0.1)
+   npm version minor  # for new features (1.0.0 → 1.1.0)
+   npm version major  # for breaking changes (1.0.0 → 2.0.0)
+   ```
+
+2. Push the version tag to GitHub:
+
+   ```bash
+   git push --follow-tags
+   ```
+
+3. The GitHub Actions workflow will automatically:
+   - Run tests
+   - Build the package
+   - Publish to NPM with provenance
+
+**Note**: Requires `NPM_TOKEN` secret to be configured in GitHub repository settings with a valid NPM access token.
+
+#### Manual Publishing
+
+Alternatively, you can publish manually:
+
+1. Ensure all tests pass:
+
+   ```bash
+   npm test
+   ```
+
+2. Update the version:
+
+   ```bash
+   npm version patch|minor|major
+   ```
+
+3. Publish to NPM (prepublishOnly script will build automatically):
+
+   ```bash
+   npm publish
+   ```
+
+4. Push the tag to GitHub:
+   ```bash
+   git push --follow-tags
+   ```
+
+### What Gets Published
+
+The package includes:
+
+- `dist/` - Compiled JavaScript and TypeScript declarations
+- `README.md` - Documentation
+
+The following are excluded via `.npmignore`:
+
+- Source files (`src/`, `tests/`, `examples/`)
+- Development configuration files
+- Build artifacts and logs
+
+## License
+
+ISC - See [LICENSE](LICENSE) file for details
+
+## Support
+
+For issues and questions, please visit the [GitHub repository](https://github.com/stanterprise/stanterprise-playwright-reporter).

package/dist/client/grpcClient.d.ts

@@ -0,0 +1,10 @@
+import { StanterpriseReporterOptions } from "../types";
+import * as grpc from "@grpc/grpc-js";
+export default function getClient(options: StanterpriseReporterOptions): grpc.Client | null;
+/**
+ * Helper: generic unary call using raw method path with retry support
+ */
+export declare function reportUnary(options: StanterpriseReporterOptions, grpcClient: grpc.Client, path: string, message: {
+    serialize?: (w?: any) => Uint8Array;
+    serializeBinary?: () => Uint8Array;
+}, deadlineMs?: number): Promise<Buffer>;

package/dist/client/grpcClient.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = getClient;
+exports.reportUnary = reportUnary;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const debugLogger_1 = require("../utils/debugLogger");
+function getClient(options) {
+    try {
+        const maxMessageSize = options.grpcMaxMessageSize || 104857600; // 100MB default
+        return new grpc.Client(options.grpcAddress, grpc.credentials.createInsecure(), {
+            "grpc.max_send_message_length": maxMessageSize,
+            "grpc.max_receive_message_length": maxMessageSize,
+        });
+    }
+    catch (e) {
+        console.error("Failed to create gRPC client", e);
+    }
+    return null;
+}
+/**
+ * Determines if a gRPC error code represents a transient failure worth retrying
+ */
+function shouldAttemptRetryForCode(errorCode) {
+    const transientCodes = new Set([
+        grpc.status.UNAVAILABLE,
+        grpc.status.DEADLINE_EXCEEDED,
+        grpc.status.INTERNAL,
+        grpc.status.UNKNOWN,
+    ]);
+    return transientCodes.has(errorCode);
+}
+/**
+ * Calculates wait time using power-of-two exponential backoff
+ */
+function calculateWaitDuration(baseDelayMs, attemptsSoFar) {
+    return baseDelayMs * Math.pow(2, attemptsSoFar);
+}
+/**
+ * Performs a single gRPC unary request attempt
+ */
+function executeSingleAttempt(grpcClient, path, message, deadlineMs) {
+    const reqSerialize = (arg) => {
+        const m = arg;
+        const bytes = m?.serializeBinary
+            ? m.serializeBinary()
+            : m?.serialize
+                ? m.serialize()
+                : new Uint8Array(0);
+        return Buffer.from(bytes);
+    };
+    const resDeserialize = (bytes) => bytes;
+    const metadata = new grpc.Metadata();
+    const callOptions = {
+        deadline: new Date(Date.now() + deadlineMs),
+    };
+    return new Promise((resolve, reject) => {
+        try {
+            grpcClient.makeUnaryRequest(path, reqSerialize, resDeserialize, message, metadata, callOptions, (err, response) => {
+                if (err)
+                    return reject(err);
+                resolve(response);
+            });
+        }
+        catch (e) {
+            reject(e);
+        }
+    });
+}
+/**
+ * Pauses execution for specified milliseconds with unref'd timer to avoid blocking shutdown
+ */
+function pauseExecution(durationMs) {
+    return new Promise((resolve) => {
+        const timer = setTimeout(resolve, durationMs);
+        // Unref the timer so it doesn't keep the process alive
+        timer.unref();
+    });
+}
+/**
+ * Attempts gRPC call with exponential backoff retry logic using iterative approach
+ */
+async function attemptWithRetries(options, grpcClient, path, message, deadlineMs, maxRetries) {
+    let attemptNumber = 0;
+    let lastError = null;
+    // Try initial attempt + retries
+    for (let retriesRemaining = maxRetries; retriesRemaining >= 0; retriesRemaining--) {
+        try {
+            return await executeSingleAttempt(grpcClient, path, message, deadlineMs);
+        }
+        catch (err) {
+            lastError = err;
+            const grpcErr = err;
+            const statusCode = grpcErr?.code ?? grpc.status.UNKNOWN;
+            // Check if we should retry this error
+            const isRetryable = shouldAttemptRetryForCode(statusCode);
+            const hasRetriesLeft = retriesRemaining > 0;
+            if (!isRetryable || !hasRetriesLeft) {
+                throw err;
+            }
+            // Log retry attempt if verbose
+            if (options.verbose) {
+                console.log(`gRPC call failed (code: ${statusCode}), retrying... ` +
+                    `(attempt ${attemptNumber + 1}, ${retriesRemaining} retries left)`);
+            }
+            // Calculate and wait for backoff duration
+            const baseDelay = options.grpcRetryDelay ?? 100;
+            const waitTime = calculateWaitDuration(baseDelay, attemptNumber);
+            await pauseExecution(waitTime);
+            attemptNumber++;
+        }
+    }
+    // This should never be reached due to the throw in the loop, but TypeScript needs it
+    throw lastError || new Error("Retry loop exhausted without result");
+}
+/**
+ * Helper: generic unary call using raw method path with retry support
+ */
+async function reportUnary(options, grpcClient, path, message, deadlineMs = 1000) {
+    (0, debugLogger_1.writeDebugEntry)(options, path, message);
+    if (!options.grpcEnabled || !grpcClient) {
+        return Buffer.alloc(0);
+    }
+    const maxRetries = options.grpcMaxRetries ?? 3;
+    return attemptWithRetries(options, grpcClient, path, message, deadlineMs, maxRetries);
+}

package/dist/handlers/index.d.ts

@@ -0,0 +1,9 @@
+import { handleOnBeginEvent } from "./onBeginHandler";
+import { handleOnEndEvent } from "./onEndHandler";
+import { handleOnStepBeginEvent } from "./onStepBeginHandler";
+import { handleOnStepEndEvent } from "./onStepEndHandler";
+import { handleOnTestBeginEvent } from "./onTestBeginHandler";
+import { handleOnTestEndEvent } from "./onTestEndHandler";
+import { handleOnTestFailEvent } from "./onTestFailHandler";
+import { handleOnErrorEvent } from "./onErrorHandler";
+export { handleOnBeginEvent, handleOnEndEvent, handleOnStepBeginEvent, handleOnStepEndEvent, handleOnTestBeginEvent, handleOnTestEndEvent, handleOnTestFailEvent, handleOnErrorEvent, };

package/dist/handlers/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleOnErrorEvent = exports.handleOnTestFailEvent = exports.handleOnTestEndEvent = exports.handleOnTestBeginEvent = exports.handleOnStepEndEvent = exports.handleOnStepBeginEvent = exports.handleOnEndEvent = exports.handleOnBeginEvent = void 0;
+const onBeginHandler_1 = require("./onBeginHandler");
+Object.defineProperty(exports, "handleOnBeginEvent", { enumerable: true, get: function () { return onBeginHandler_1.handleOnBeginEvent; } });
+const onEndHandler_1 = require("./onEndHandler");
+Object.defineProperty(exports, "handleOnEndEvent", { enumerable: true, get: function () { return onEndHandler_1.handleOnEndEvent; } });
+const onStepBeginHandler_1 = require("./onStepBeginHandler");
+Object.defineProperty(exports, "handleOnStepBeginEvent", { enumerable: true, get: function () { return onStepBeginHandler_1.handleOnStepBeginEvent; } });
+const onStepEndHandler_1 = require("./onStepEndHandler");
+Object.defineProperty(exports, "handleOnStepEndEvent", { enumerable: true, get: function () { return onStepEndHandler_1.handleOnStepEndEvent; } });
+const onTestBeginHandler_1 = require("./onTestBeginHandler");
+Object.defineProperty(exports, "handleOnTestBeginEvent", { enumerable: true, get: function () { return onTestBeginHandler_1.handleOnTestBeginEvent; } });
+const onTestEndHandler_1 = require("./onTestEndHandler");
+Object.defineProperty(exports, "handleOnTestEndEvent", { enumerable: true, get: function () { return onTestEndHandler_1.handleOnTestEndEvent; } });
+const onTestFailHandler_1 = require("./onTestFailHandler");
+Object.defineProperty(exports, "handleOnTestFailEvent", { enumerable: true, get: function () { return onTestFailHandler_1.handleOnTestFailEvent; } });
+const onErrorHandler_1 = require("./onErrorHandler");
+Object.defineProperty(exports, "handleOnErrorEvent", { enumerable: true, get: function () { return onErrorHandler_1.handleOnErrorEvent; } });

package/dist/handlers/onBeginHandler.d.ts

@@ -0,0 +1,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;