@zapier/zapier-sdk 0.32.5 → 0.33.1

package/dist/plugins/eventEmission/index.test.js

@@ -1,704 +0,0 @@
-/**
- * Tests for Event Emission Plugin
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-import { eventEmissionPlugin, cleanupEventListeners } from "./index";
-import { createTransport } from "./transport";
-import { clearTokenCache } from "../../auth";
-const { mockTransport, mockGetToken } = vi.hoisted(() => ({
-    mockTransport: {
-        emit: vi.fn().mockResolvedValue(undefined),
-        close: vi.fn().mockResolvedValue(undefined),
-    },
-    mockGetToken: vi.fn().mockResolvedValue(undefined),
-}));
-vi.mock("./transport", () => ({
-    createTransport: vi.fn(() => mockTransport),
-}));
-// Mock both CLI login import paths (SDK tries @zapier/zapier-sdk-cli/login
-// first, then falls back to @zapier/zapier-sdk-cli-login)
-vi.mock("@zapier/zapier-sdk-cli/login", () => ({
-    getToken: mockGetToken,
-}));
-vi.mock("@zapier/zapier-sdk-cli-login", () => ({
-    getToken: mockGetToken,
-}));
-describe("eventEmissionPlugin", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        clearTokenCache();
-        // Reset to default behavior - no token available
-        mockGetToken.mockResolvedValue(undefined);
-    });
-    it("should create plugin with default configuration", () => {
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {},
-            },
-        });
-        expect(plugin.context.eventEmission).toBeDefined();
-        expect(plugin.context.eventEmission.emit).toBeDefined();
-        expect(plugin.context.eventEmission.transport).toBeDefined();
-        expect(plugin.context.eventEmission.config).toBeDefined();
-    });
-    it("should create noop implementations when disabled", () => {
-        const config = { enabled: false };
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: { eventEmission: config },
-            },
-        });
-        // Should not emit any events when disabled
-        plugin.context.eventEmission.emit("platform.sdk.TestEvent", {
-            test_event: "data",
-        });
-        expect(mockTransport.emit).not.toHaveBeenCalled();
-    });
-    it("should emit events using generic emit method", async () => {
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        await plugin.context.eventEmission.flush();
-        // Clear startup event calls so we only assert on our test event
-        mockTransport.emit.mockClear();
-        const testEvent = {
-            test_data: "example",
-            value: 123,
-        };
-        const testSubject = "test.event.TestEvent";
-        plugin.context.eventEmission.emit(testSubject, testEvent);
-        await plugin.context.eventEmission.flush();
-        // The event will be enriched with user context (null values)
-        expect(mockTransport.emit).toHaveBeenCalledWith(testSubject, {
-            ...testEvent,
-            customuser_id: null,
-            account_id: null,
-        });
-    });
-    it("should handle transport creation failures silently", () => {
-        // Mock createTransport to throw an error
-        vi.mocked(createTransport).mockImplementationOnce(() => {
-            throw new Error("Transport creation failed");
-        });
-        expect(() => {
-            eventEmissionPlugin({
-                sdk: {},
-                context: {
-                    meta: {},
-                    options: {
-                        eventEmission: {
-                            enabled: true,
-                            transport: { type: "http", endpoint: "invalid-url" },
-                        },
-                    },
-                },
-            });
-        }).not.toThrow();
-    });
-    it("should handle event emission failures silently", async () => {
-        // Mock transport to throw error
-        const failingTransport = {
-            emit: vi.fn().mockRejectedValue(new Error("Network error")),
-            close: vi.fn().mockResolvedValue(undefined),
-        };
-        vi.mocked(createTransport).mockReturnValueOnce(failingTransport);
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: {
-                            type: "http",
-                            endpoint: "https://example.com",
-                        },
-                    },
-                },
-            },
-        });
-        await plugin.context.eventEmission.flush();
-        // Should not throw even if transport fails
-        expect(() => {
-            plugin.context.eventEmission.emit("test.event.TestEvent", {
-                test_event: "data",
-            });
-        }).not.toThrow();
-        await plugin.context.eventEmission.flush();
-        expect(failingTransport.emit).toHaveBeenCalled();
-    });
-    it("should merge options with defaults", () => {
-        // Override env var to ensure proper transport is used
-        vi.stubEnv("ZAPIER_SDK_TELEMETRY_TRANSPORT", undefined);
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        transport: {
-                            type: "http",
-                            endpoint: "https://example.com",
-                        },
-                    },
-                },
-            },
-        });
-        expect(plugin.context.eventEmission.config.enabled).toBe(true);
-        expect(plugin.context.eventEmission.config.transport).toEqual({
-            type: "http",
-            endpoint: "https://example.com",
-        });
-        vi.unstubAllEnvs();
-    });
-    it("should extract user IDs from JWT token and include in events", async () => {
-        // Create a test JWT token with user data
-        // JWT format: header.payload.signature
-        const header = { alg: "HS256", typ: "JWT" };
-        const payload = {
-            "zap:acc": "12345",
-            sub: "67890",
-            sub_type: "customuser",
-            "zap:uname": "test@example.com",
-        };
-        const encodedHeader = Buffer.from(JSON.stringify(header)).toString("base64url");
-        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
-        const testJwt = `${encodedHeader}.${encodedPayload}.fake-signature`;
-        // Mock getToken to return the JWT
-        mockGetToken.mockResolvedValue(testJwt);
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        // Test that createBaseEvent includes the extracted user IDs
-        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
-        expect(baseEvent.customuser_id).toBe(67890);
-        expect(baseEvent.account_id).toBe(12345);
-    });
-    it("should handle service tokens with nested JWT", async () => {
-        // Create a nested JWT for service token testing
-        const nestedHeader = { alg: "HS256", typ: "JWT" };
-        const nestedPayload = {
-            "zap:acc": "99999",
-            sub: "88888",
-            sub_type: "customuser",
-        };
-        const nestedEncodedHeader = Buffer.from(JSON.stringify(nestedHeader)).toString("base64url");
-        const nestedEncodedPayload = Buffer.from(JSON.stringify(nestedPayload)).toString("base64url");
-        const nestedJwt = `${nestedEncodedHeader}.${nestedEncodedPayload}.nested-signature`;
-        // Create the service token that wraps the nested JWT
-        const serviceHeader = { alg: "HS256", typ: "JWT" };
-        const servicePayload = {
-            "zap:acc": "11111",
-            sub: "22222",
-            sub_type: "service",
-            njwt: nestedJwt,
-        };
-        const serviceEncodedHeader = Buffer.from(JSON.stringify(serviceHeader)).toString("base64url");
-        const serviceEncodedPayload = Buffer.from(JSON.stringify(servicePayload)).toString("base64url");
-        const serviceJwt = `${serviceEncodedHeader}.${serviceEncodedPayload}.service-signature`;
-        // Mock getToken to return the service JWT
-        mockGetToken.mockResolvedValue(serviceJwt);
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
-        // Should extract from nested JWT, not the service token
-        expect(baseEvent.customuser_id).toBe(88888);
-        expect(baseEvent.account_id).toBe(99999);
-    });
-    it("should handle invalid JWT tokens gracefully", async () => {
-        // Mock getToken to return an invalid JWT
-        mockGetToken.mockResolvedValue("not-a-valid-jwt-token");
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
-        // Should default to null when JWT is invalid
-        expect(baseEvent.customuser_id).toBe(null);
-        expect(baseEvent.account_id).toBe(null);
-    });
-    it("should handle missing token gracefully", async () => {
-        // mockGetToken defaults to returning undefined (no token)
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
-        // Should default to null when no token is provided
-        expect(baseEvent.customuser_id).toBe(null);
-        expect(baseEvent.account_id).toBe(null);
-    });
-    it("should extract user IDs when getToken returns valid JWT", async () => {
-        // Create a test JWT token
-        const header = { alg: "HS256", typ: "JWT" };
-        const payload = {
-            "zap:acc": "98765",
-            sub: "54321",
-            sub_type: "customuser",
-        };
-        const encodedHeader = Buffer.from(JSON.stringify(header)).toString("base64url");
-        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
-        const testJwt = `${encodedHeader}.${encodedPayload}.test-signature`;
-        // Mock getToken to return the JWT
-        mockGetToken.mockResolvedValue(testJwt);
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        // Test that createBaseEvent includes the extracted user IDs
-        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
-        expect(baseEvent.customuser_id).toBe(54321);
-        expect(baseEvent.account_id).toBe(98765);
-    });
-    it("should handle getToken failures gracefully", async () => {
-        // Mock getToken to reject/throw
-        mockGetToken.mockRejectedValue(new Error("Token fetch failed"));
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
-        // Should gracefully fall back to null context
-        expect(baseEvent.customuser_id).toBe(null);
-        expect(baseEvent.account_id).toBe(null);
-    });
-    it("should extract user IDs from static token in SDK options", async () => {
-        // Create a test JWT token
-        const header = { alg: "HS256", typ: "JWT" };
-        const payload = {
-            "zap:acc": "11111",
-            sub: "22222",
-            sub_type: "customuser",
-        };
-        const encodedHeader = Buffer.from(JSON.stringify(header)).toString("base64url");
-        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
-        const testJwt = `${encodedHeader}.${encodedPayload}.static-signature`;
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    token: testJwt,
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
-        // Should extract from static token in options
-        expect(baseEvent.customuser_id).toBe(22222);
-        expect(baseEvent.account_id).toBe(11111);
-        // CLI login package should not be called when token is in options
-        expect(mockGetToken).not.toHaveBeenCalled();
-    });
-    it("should extract user IDs from credentials function in SDK options", async () => {
-        // Create a test JWT token
-        const header = { alg: "HS256", typ: "JWT" };
-        const payload = {
-            "zap:acc": "33333",
-            sub: "44444",
-            sub_type: "customuser",
-        };
-        const encodedHeader = Buffer.from(JSON.stringify(header)).toString("base64url");
-        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
-        const testJwt = `${encodedHeader}.${encodedPayload}.custom-signature`;
-        const credentialsFn = vi.fn().mockResolvedValue(testJwt);
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    credentials: credentialsFn,
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
-        // Should extract from custom credentials function
-        expect(baseEvent.customuser_id).toBe(44444);
-        expect(baseEvent.account_id).toBe(33333);
-        expect(credentialsFn).toHaveBeenCalled();
-        // CLI login package should not be called when credentials is in options
-        expect(mockGetToken).not.toHaveBeenCalled();
-    });
-    it("should prioritize string credentials over credentials function", async () => {
-        // Create test JWT tokens
-        const staticHeader = { alg: "HS256", typ: "JWT" };
-        const staticPayload = {
-            "zap:acc": "55555",
-            sub: "66666",
-            sub_type: "customuser",
-        };
-        const staticEncodedHeader = Buffer.from(JSON.stringify(staticHeader)).toString("base64url");
-        const staticEncodedPayload = Buffer.from(JSON.stringify(staticPayload)).toString("base64url");
-        const staticJwt = `${staticEncodedHeader}.${staticEncodedPayload}.static-sig`;
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    credentials: staticJwt,
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
-        // Should use string credentials
-        expect(baseEvent.customuser_id).toBe(66666);
-        expect(baseEvent.account_id).toBe(55555);
-        expect(mockGetToken).not.toHaveBeenCalled();
-    });
-    it("should fall back to CLI login when SDK options have no token", async () => {
-        // Create a test JWT token for CLI login
-        const header = { alg: "HS256", typ: "JWT" };
-        const payload = {
-            "zap:acc": "77777",
-            sub: "88888",
-            sub_type: "customuser",
-        };
-        const encodedHeader = Buffer.from(JSON.stringify(header)).toString("base64url");
-        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
-        const testJwt = `${encodedHeader}.${encodedPayload}.cli-signature`;
-        mockGetToken.mockResolvedValue(testJwt);
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    // No token or getToken in options
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
-        // Should fall back to CLI login package
-        expect(baseEvent.customuser_id).toBe(88888);
-        expect(baseEvent.account_id).toBe(77777);
-        expect(mockGetToken).toHaveBeenCalled();
-    });
-    it("should handle credentials function returning undefined and fall back to CLI login", async () => {
-        const credentialsFn = vi.fn().mockResolvedValue(undefined);
-        // Also mock CLI login to return a token
-        const header = { alg: "HS256", typ: "JWT" };
-        const payload = {
-            "zap:acc": "99999",
-            sub: "10101",
-            sub_type: "customuser",
-        };
-        const encodedHeader = Buffer.from(JSON.stringify(header)).toString("base64url");
-        const encodedPayload = Buffer.from(JSON.stringify(payload)).toString("base64url");
-        const testJwt = `${encodedHeader}.${encodedPayload}.fallback-signature`;
-        mockGetToken.mockResolvedValue(testJwt);
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    credentials: credentialsFn,
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        const baseEvent = await plugin.context.eventEmission.createBaseEvent();
-        // Since credentials function returns undefined, SDK falls back to CLI login
-        expect(baseEvent.customuser_id).toBe(10101);
-        expect(baseEvent.account_id).toBe(99999);
-        expect(credentialsFn).toHaveBeenCalled();
-        expect(mockGetToken).toHaveBeenCalled();
-    });
-});
-describe("emitMethodCalled call_context", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        mockGetToken.mockResolvedValue(undefined);
-    });
-    it("should default call_context to 'sdk' when callContext is not configured", async () => {
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        plugin.context.eventEmission.emitMethodCalled({
-            method_name: "listApps",
-            execution_duration_ms: 50,
-            success_flag: true,
-            argument_count: 0,
-        });
-        await plugin.context.eventEmission.flush();
-        expect(mockTransport.emit).toHaveBeenCalledWith("platform.sdk.MethodCalledEvent", expect.objectContaining({ call_context: "sdk" }));
-    });
-    it("should set call_context to 'cli' when callContext is 'cli'", async () => {
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                        callContext: "cli",
-                    },
-                },
-            },
-        });
-        plugin.context.eventEmission.emitMethodCalled({
-            method_name: "listApps",
-            execution_duration_ms: 50,
-            success_flag: true,
-            argument_count: 0,
-        });
-        await plugin.context.eventEmission.flush();
-        expect(mockTransport.emit).toHaveBeenCalledWith("platform.sdk.MethodCalledEvent", expect.objectContaining({ call_context: "cli" }));
-    });
-    it("should set call_context to 'mcp' when callContext is 'mcp'", async () => {
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                        callContext: "mcp",
-                    },
-                },
-            },
-        });
-        plugin.context.eventEmission.emitMethodCalled({
-            method_name: "listApps",
-            execution_duration_ms: 50,
-            success_flag: true,
-            argument_count: 0,
-        });
-        await plugin.context.eventEmission.flush();
-        expect(mockTransport.emit).toHaveBeenCalledWith("platform.sdk.MethodCalledEvent", expect.objectContaining({ call_context: "mcp" }));
-    });
-});
-describe("close()", () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        cleanupEventListeners();
-        mockGetToken.mockResolvedValue(undefined);
-    });
-    afterEach(() => {
-        cleanupEventListeners();
-    });
-    it("should emit exit lifecycle event", async () => {
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        await plugin.context.eventEmission.close(0);
-        expect(mockTransport.emit).toHaveBeenCalledWith("platform.sdk.ApplicationLifecycleEvent", expect.objectContaining({
-            lifecycle_event_type: "exit",
-            exit_code: 0,
-            is_graceful_shutdown: true,
-        }));
-    });
-    it("should be idempotent — second call is a no-op", async () => {
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        await plugin.context.eventEmission.close(0);
-        const callCountAfterFirst = mockTransport.emit.mock.calls.filter((call) => call[0] === "platform.sdk.ApplicationLifecycleEvent" &&
-            call[1]?.lifecycle_event_type === "exit").length;
-        await plugin.context.eventEmission.close(0);
-        const callCountAfterSecond = mockTransport.emit.mock.calls.filter((call) => call[0] === "platform.sdk.ApplicationLifecycleEvent" &&
-            call[1]?.lifecycle_event_type === "exit").length;
-        expect(callCountAfterSecond).toBe(callCountAfterFirst);
-    });
-    it("should remove process listeners after close", async () => {
-        const initialExitCount = process.listenerCount("exit");
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: { type: "console" },
-                    },
-                },
-            },
-        });
-        expect(process.listenerCount("exit")).toBe(initialExitCount + 1);
-        await plugin.context.eventEmission.close(0);
-        expect(process.listenerCount("exit")).toBe(initialExitCount);
-    });
-    it("should handle transport failures silently", async () => {
-        const failingTransport = {
-            emit: vi.fn().mockRejectedValue(new Error("Network error")),
-            close: vi.fn().mockResolvedValue(undefined),
-        };
-        vi.mocked(createTransport).mockReturnValueOnce(failingTransport);
-        const plugin = eventEmissionPlugin({
-            sdk: {},
-            context: {
-                meta: {},
-                options: {
-                    eventEmission: {
-                        enabled: true,
-                        transport: {
-                            type: "http",
-                            endpoint: "https://example.com",
-                        },
-                    },
-                },
-            },
-        });
-        await expect(plugin.context.eventEmission.close(1)).resolves.toBeUndefined();
-    });
-});
-describe("Process Listener Cleanup", () => {
-    beforeEach(() => {
-        // Clean up any listeners from previous tests
-        cleanupEventListeners();
-    });
-    afterEach(() => {
-        cleanupEventListeners();
-    });
-    it("should not accumulate process listeners when creating multiple SDK instances", () => {
-        const initialExitListenerCount = process.listenerCount("exit");
-        // Create multiple SDK instances
-        for (let i = 0; i < 5; i++) {
-            eventEmissionPlugin({
-                sdk: {},
-                context: { meta: {}, options: {} },
-            });
-        }
-        // Should only have added 1 listener, not 5
-        expect(process.listenerCount("exit")).toBe(initialExitListenerCount + 1);
-    });
-    it("should remove existing listeners before registering new ones", () => {
-        const removeListenerSpy = vi.spyOn(process, "removeListener");
-        // Create first plugin instance
-        eventEmissionPlugin({
-            sdk: {},
-            context: { meta: {}, options: {} },
-        });
-        // Create second plugin instance (should remove listeners from first)
-        eventEmissionPlugin({
-            sdk: {},
-            context: { meta: {}, options: {} },
-        });
-        // Verify cleanup happened for all event types
-        expect(removeListenerSpy).toHaveBeenCalledWith("exit", expect.any(Function));
-        expect(removeListenerSpy).toHaveBeenCalledWith("uncaughtException", expect.any(Function));
-        expect(removeListenerSpy).toHaveBeenCalledWith("unhandledRejection", expect.any(Function));
-        expect(removeListenerSpy).toHaveBeenCalledWith("SIGINT", expect.any(Function));
-        expect(removeListenerSpy).toHaveBeenCalledWith("SIGTERM", expect.any(Function));
-        removeListenerSpy.mockRestore();
-    });
-    it("should allow explicit cleanup via cleanupEventListeners", () => {
-        const initialExitListenerCount = process.listenerCount("exit");
-        eventEmissionPlugin({
-            sdk: {},
-            context: { meta: {}, options: {} },
-        });
-        expect(process.listenerCount("exit")).toBe(initialExitListenerCount + 1);
-        cleanupEventListeners();
-        expect(process.listenerCount("exit")).toBe(initialExitListenerCount);
-    });
-});