@eyevinn/player-analytics-client-sdk-web 0.3.0 → 0.4.0

package/spec/Reporter.spec.ts

@@ -0,0 +1,825 @@
+import { Reporter, IReporterOptions } from "../src/utils/Reporter";
+import { TPlayerAnalyticsEvent } from "@eyevinn/player-analytics-specification";
+
+describe("Reporter", () => {
+  let mockFetch: jasmine.Spy;
+  let originalFetch: any;
+
+  beforeEach(() => {
+    // Save original fetch
+    originalFetch = globalThis.fetch;
+
+    // Mock fetch globally
+    mockFetch = jasmine.createSpy("fetch").and.returnValue(
+      Promise.resolve({
+        ok: true,
+        json: () => Promise.resolve({ sessionId: "server-generated-id" }),
+        statusText: "OK",
+      } as Response)
+    );
+    globalThis.fetch = mockFetch;
+  });
+
+  afterEach(() => {
+    // Restore original fetch
+    globalThis.fetch = originalFetch;
+  });
+
+  describe("sendBeacon()", () => {
+    let navigatorDescriptor: PropertyDescriptor | undefined;
+
+    function setNavigator(value: any) {
+      Object.defineProperty(globalThis, "navigator", {
+        value,
+        configurable: true,
+        writable: true,
+      });
+    }
+
+    beforeEach(() => {
+      navigatorDescriptor = Object.getOwnPropertyDescriptor(
+        globalThis,
+        "navigator"
+      );
+    });
+
+    afterEach(() => {
+      // Restore the original navigator descriptor
+      if (navigatorDescriptor) {
+        Object.defineProperty(globalThis, "navigator", navigatorDescriptor);
+      } else {
+        delete (globalThis as any).navigator;
+      }
+    });
+
+    const stoppedEvent: TPlayerAnalyticsEvent = {
+      event: "stopped",
+      sessionId: "test-session-id",
+      timestamp: 1234567890,
+      playhead: 42,
+      duration: 120,
+      payload: { reason: "aborted" },
+    } as TPlayerAnalyticsEvent;
+
+    async function readBlobJson(blob: Blob): Promise<any> {
+      return JSON.parse(await blob.text());
+    }
+
+    it("should send via navigator.sendBeacon with a text/plain JSON body (no fetch, no X-EPAS headers)", async () => {
+      const sendBeaconSpy = jasmine
+        .createSpy("sendBeacon")
+        .and.returnValue(true);
+      setNavigator({ sendBeacon: sendBeaconSpy });
+
+      const reporter = new Reporter({
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+        shardId: "shard-123",
+      });
+      await reporter.init("test-session-id");
+      mockFetch.calls.reset();
+
+      const result = reporter.sendBeacon(stoppedEvent);
+
+      expect(result).toBe(true);
+      expect(mockFetch).not.toHaveBeenCalled();
+      expect(sendBeaconSpy).toHaveBeenCalledTimes(1);
+
+      const [url, blob] = sendBeaconSpy.calls.argsFor(0);
+      expect(url).toBe("https://example.com/analytics");
+      expect(blob instanceof Blob).toBe(true);
+      expect((blob as Blob).type).toContain("text/plain");
+
+      const body = await readBlobJson(blob as Blob);
+      expect(body.event).toBe("stopped");
+      // Reporter stamps its authoritative session identifiers (the server
+      // init response's sessionId wins) onto the payload
+      expect(body.sessionId).toBe("server-generated-id");
+      expect(body.shardId).toBe("shard-123");
+      expect(body.payload.reason).toBe("aborted");
+    });
+
+    it("should fall back to keepalive fetch when sendBeacon is unavailable", async () => {
+      setNavigator({});
+
+      const reporter = new Reporter({
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+      });
+      await reporter.init("test-session-id");
+      mockFetch.calls.reset();
+
+      const result = reporter.sendBeacon(stoppedEvent);
+
+      expect(result).toBe(true);
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+      const [url, fetchOptions] = mockFetch.calls.argsFor(0);
+      expect(url).toBe("https://example.com/analytics");
+      expect(fetchOptions.method).toBe("POST");
+      expect(fetchOptions.keepalive).toBe(true);
+      expect(fetchOptions.headers["Content-Type"]).toContain("text/plain");
+      // No X-EPAS-* headers on the beacon path (avoids the dropped preflight)
+      expect(fetchOptions.headers["X-EPAS-Event"]).toBeUndefined();
+      const body = JSON.parse(fetchOptions.body);
+      expect(body.event).toBe("stopped");
+      expect(body.sessionId).toBe("server-generated-id");
+    });
+
+    it("should fall back to keepalive fetch when sendBeacon returns false", async () => {
+      const sendBeaconSpy = jasmine
+        .createSpy("sendBeacon")
+        .and.returnValue(false);
+      setNavigator({ sendBeacon: sendBeaconSpy });
+
+      const reporter = new Reporter({
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+      });
+      await reporter.init("test-session-id");
+      mockFetch.calls.reset();
+
+      const result = reporter.sendBeacon(stoppedEvent);
+
+      expect(result).toBe(true);
+      expect(sendBeaconSpy).toHaveBeenCalledTimes(1);
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+      expect(mockFetch.calls.argsFor(0)[1].keepalive).toBe(true);
+    });
+
+    it("should log instead of sending in debug mode", async () => {
+      const sendBeaconSpy = jasmine
+        .createSpy("sendBeacon")
+        .and.returnValue(true);
+      setNavigator({ sendBeacon: sendBeaconSpy });
+      spyOn(console, "log");
+
+      const reporter = new Reporter({
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "debug-session-id",
+        debug: true,
+      });
+      await reporter.init("debug-session-id");
+      mockFetch.calls.reset();
+
+      const result = reporter.sendBeacon(stoppedEvent);
+
+      expect(result).toBe(true);
+      expect(sendBeaconSpy).not.toHaveBeenCalled();
+      expect(mockFetch).not.toHaveBeenCalled();
+      expect(console.log).toHaveBeenCalled();
+    });
+
+    it("should return false and not send after destroy()", async () => {
+      const sendBeaconSpy = jasmine
+        .createSpy("sendBeacon")
+        .and.returnValue(true);
+      setNavigator({ sendBeacon: sendBeaconSpy });
+
+      const reporter = new Reporter({
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+      });
+      await reporter.init("test-session-id");
+      reporter.destroy();
+      mockFetch.calls.reset();
+
+      const result = reporter.sendBeacon(stoppedEvent);
+
+      expect(result).toBe(false);
+      expect(sendBeaconSpy).not.toHaveBeenCalled();
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("init()", () => {
+    it("should call fetch with correct URL and headers", async () => {
+      const options: IReporterOptions = {
+        eventsinkUrl: "https://example.com/analytics",
+        heartbeatInterval: 30000,
+      };
+      const reporter = new Reporter(options);
+
+      await reporter.init();
+
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+      const [url, fetchOptions] = mockFetch.calls.argsFor(0);
+      expect(url).toBe("https://example.com/analytics");
+      expect(fetchOptions.method).toBe("POST");
+      expect(fetchOptions.headers["Content-Type"]).toBe(
+        "application/json; charset=utf-8"
+      );
+      expect(fetchOptions.headers["X-EPAS-Event"]).toBe("init");
+      expect(fetchOptions.headers["X-EPAS-Version"]).toBeDefined();
+    });
+
+    it("should return sessionId from server response", async () => {
+      const options: IReporterOptions = {
+        eventsinkUrl: "https://example.com/analytics",
+      };
+      const reporter = new Reporter(options);
+
+      const result = await reporter.init();
+
+      expect(result.sessionId).toBe("server-generated-id");
+      expect(result.heartbeatInterval).toBeDefined();
+      expect(result.isInitiated).toBe(true);
+    });
+
+    it("should reuse provided sessionId when given", async () => {
+      const options: IReporterOptions = {
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "existing-session-id",
+      };
+      const reporter = new Reporter(options);
+
+      mockFetch.and.returnValue(
+        Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve({}),
+          statusText: "OK",
+        } as Response)
+      );
+
+      const result = await reporter.init("existing-session-id");
+
+      expect(result.sessionId).toBe("existing-session-id");
+
+      const bodyString = mockFetch.calls.argsFor(0)[1].body;
+      const body = JSON.parse(bodyString);
+      expect(body.sessionId).toBe("existing-session-id");
+    });
+
+    it("should handle fetch rejection gracefully", async () => {
+      const options: IReporterOptions = {
+        eventsinkUrl: "https://example.com/analytics",
+      };
+      const reporter = new Reporter(options);
+
+      mockFetch.and.returnValue(Promise.reject(new Error("Network error")));
+
+      await expectAsync(reporter.init()).toBeRejectedWithError("Network error");
+    });
+
+    it("should throw error when init response is not ok", async () => {
+      const options: IReporterOptions = {
+        eventsinkUrl: "https://example.com/analytics",
+      };
+      const reporter = new Reporter(options);
+
+      mockFetch.and.returnValue(
+        Promise.resolve({
+          ok: false,
+          statusText: "Internal Server Error",
+        } as Response)
+      );
+
+      await expectAsync(reporter.init()).toBeRejectedWithError(
+        "[AnalyticsReporter] init failed: Internal Server Error"
+      );
+    });
+
+    it("should throw error when no sessionId in response and none provided", async () => {
+      const options: IReporterOptions = {
+        eventsinkUrl: "https://example.com/analytics",
+      };
+      const reporter = new Reporter(options);
+
+      mockFetch.and.returnValue(
+        Promise.resolve({
+          ok: true,
+          json: () => Promise.resolve({}),
+          statusText: "OK",
+        } as Response)
+      );
+
+      await expectAsync(reporter.init()).toBeRejectedWithError(
+        "[AnalyticsReporter] init failed: no sessionId"
+      );
+    });
+
+    it("should not call fetch in debug mode", async () => {
+      const options: IReporterOptions = {
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "debug-session-id",
+        debug: true,
+      };
+      const reporter = new Reporter(options);
+
+      spyOn(console, "log");
+
+      const result = await reporter.init();
+
+      expect(mockFetch).not.toHaveBeenCalled();
+      expect(result.sessionId).toBe("debug-session-id");
+      expect(result.isInitiated).toBe(true);
+      expect(console.log).toHaveBeenCalled();
+    });
+  });
+
+  describe("send()", () => {
+    it("should call fetch with correct JSON body and EPAS headers", async () => {
+      const options: IReporterOptions = {
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+      };
+      const reporter = new Reporter(options);
+      await reporter.init();
+
+      mockFetch.calls.reset();
+
+      const eventData: TPlayerAnalyticsEvent = {
+        event: "playing",
+        sessionId: "test-session-id",
+        timestamp: 1234567890,
+        playhead: 10.5,
+        duration: 120,
+      };
+
+      reporter.send(eventData);
+
+      // Wait for async fetch to be called
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(mockFetch).toHaveBeenCalledTimes(1);
+      const [url, fetchOptions] = mockFetch.calls.argsFor(0);
+      expect(url).toBe("https://example.com/analytics");
+      expect(fetchOptions.method).toBe("POST");
+      expect(fetchOptions.headers["X-EPAS-Event"]).toBe("playing");
+
+      const body = JSON.parse(fetchOptions.body);
+      expect(body.event).toBe("playing");
+      // Reporter uses its authoritative sessionId (from server init response)
+      expect(body.sessionId).toBe("server-generated-id");
+      expect(body.playhead).toBe(10.5);
+    });
+
+    it("should include shardId in payload when provided", async () => {
+      const options: IReporterOptions = {
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+        shardId: "shard-123",
+      };
+      const reporter = new Reporter(options);
+      await reporter.init();
+
+      mockFetch.calls.reset();
+
+      const eventData: TPlayerAnalyticsEvent = {
+        event: "playing",
+        sessionId: "test-session-id",
+        timestamp: 1234567890,
+        playhead: 10.5,
+        duration: 120,
+      };
+
+      reporter.send(eventData);
+
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      const body = JSON.parse(mockFetch.calls.argsFor(0)[1].body);
+      expect(body.shardId).toBe("shard-123");
+    });
+
+    it("should log to console in debug mode instead of calling fetch", async () => {
+      const options: IReporterOptions = {
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "debug-session-id",
+        debug: true,
+      };
+      const reporter = new Reporter(options);
+
+      spyOn(console, "log");
+      await reporter.init();
+
+      mockFetch.calls.reset();
+
+      const eventData: TPlayerAnalyticsEvent = {
+        event: "playing",
+        sessionId: "debug-session-id",
+        timestamp: 1234567890,
+        playhead: 10.5,
+        duration: 120,
+      };
+
+      reporter.send(eventData);
+
+      expect(mockFetch).not.toHaveBeenCalled();
+      expect(console.log).toHaveBeenCalled();
+    });
+
+    it("should warn on network failure in non-debug mode", async () => {
+      const options: IReporterOptions = {
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+        debug: true,
+      };
+      const reporter = new Reporter(options);
+      await reporter.init();
+
+      // Switch to non-debug mode and make fetch fail
+      (reporter as any).debug = false;
+      mockFetch.calls.reset();
+      mockFetch.and.returnValue(Promise.reject(new Error("Network failure")));
+
+      spyOn(console, "warn");
+
+      const eventData: TPlayerAnalyticsEvent = {
+        event: "playing",
+        sessionId: "test-session-id",
+        timestamp: 1234567890,
+        playhead: 10.5,
+        duration: 120,
+      };
+
+      reporter.send(eventData);
+
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(mockFetch).toHaveBeenCalled();
+      expect(console.warn).toHaveBeenCalledWith(
+        "[AnalyticsReporter] Send failed:",
+        "Network failure"
+      );
+    });
+
+    it("should warn on HTTP error response (e.g. 404)", async () => {
+      const options: IReporterOptions = {
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+        debug: true,
+      };
+      const reporter = new Reporter(options);
+      await reporter.init();
+
+      (reporter as any).debug = false;
+      mockFetch.calls.reset();
+      mockFetch.and.returnValue(
+        Promise.resolve({
+          ok: false,
+          status: 404,
+          statusText: "Not Found",
+        })
+      );
+
+      spyOn(console, "warn");
+
+      reporter.send({
+        event: "heartbeat",
+        sessionId: "test-session-id",
+        timestamp: 1234567890,
+        playhead: 30,
+        duration: 120,
+      } as TPlayerAnalyticsEvent);
+
+      await new Promise((resolve) => setTimeout(resolve, 10));
+
+      expect(console.warn).toHaveBeenCalledWith(
+        "[AnalyticsReporter] Send failed: 404 Not Found"
+      );
+    });
+
+    it("should warn and not send when not initiated", async () => {
+      const options: IReporterOptions = {
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+      };
+      const reporter = new Reporter(options);
+      // Note: NOT calling init()
+
+      spyOn(console, "warn");
+
+      const eventData: TPlayerAnalyticsEvent = {
+        event: "playing",
+        sessionId: "test-session-id",
+        timestamp: 1234567890,
+        playhead: 10.5,
+        duration: 120,
+      };
+
+      reporter.send(eventData);
+
+      expect(console.warn).toHaveBeenCalledWith(
+        "[AnalyticsReporter] Cannot report before initiation:",
+        eventData
+      );
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("event queuing during init", () => {
+    // Helper: flush promise microtask queue
+    async function flushMicrotasks() {
+      for (let i = 0; i < 10; i++) await Promise.resolve();
+    }
+
+    it("should queue events sent while init is in flight", async () => {
+      let resolveInit!: (value: unknown) => void;
+      const pendingInit = new Promise((resolve) => {
+        resolveInit = resolve;
+      });
+      mockFetch.and.returnValue(pendingInit);
+
+      const reporter = new Reporter({
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+      });
+
+      const initPromise = reporter.init();
+      mockFetch.calls.reset();
+
+      const event1: TPlayerAnalyticsEvent = {
+        event: "playing",
+        sessionId: "test-session-id",
+        timestamp: 1000,
+        playhead: 0,
+        duration: 120,
+      };
+      const event2: TPlayerAnalyticsEvent = {
+        event: "heartbeat",
+        sessionId: "test-session-id",
+        timestamp: 2000,
+        playhead: 10,
+        duration: 120,
+      };
+
+      reporter.send(event1);
+      reporter.send(event2);
+
+      expect(mockFetch).not.toHaveBeenCalled();
+
+      resolveInit({
+        ok: true,
+        json: () => Promise.resolve({ sessionId: "server-session-id" }),
+        statusText: "OK",
+      });
+
+      await initPromise;
+      await flushMicrotasks();
+
+      expect(mockFetch.calls.count()).toBe(2);
+      const body1 = JSON.parse(mockFetch.calls.argsFor(0)[1].body);
+      expect(body1.event).toBe("playing");
+      const body2 = JSON.parse(mockFetch.calls.argsFor(1)[1].body);
+      expect(body2.event).toBe("heartbeat");
+    });
+
+    it("should patch queued events with server sessionId on flush", async () => {
+      let resolveInit!: (value: unknown) => void;
+      const pendingInit = new Promise((resolve) => {
+        resolveInit = resolve;
+      });
+      mockFetch.and.returnValue(pendingInit);
+
+      const reporter = new Reporter({
+        eventsinkUrl: "https://example.com/analytics",
+      });
+      const initPromise = reporter.init();
+      mockFetch.calls.reset();
+
+      reporter.send({
+        event: "loading",
+        sessionId: undefined,
+        timestamp: 1000,
+        playhead: -1,
+        duration: -1,
+      } as TPlayerAnalyticsEvent);
+
+      resolveInit({
+        ok: true,
+        json: () => Promise.resolve({ sessionId: "server-generated-id" }),
+        statusText: "OK",
+      });
+
+      await initPromise;
+      await flushMicrotasks();
+
+      expect(mockFetch.calls.count()).toBe(1);
+      const body = JSON.parse(mockFetch.calls.argsFor(0)[1].body);
+      expect(body.sessionId).toBe("server-generated-id");
+    });
+
+    it("should discard queued events if init fails", async () => {
+      mockFetch.and.returnValue(
+        Promise.resolve({
+          ok: false,
+          statusText: "Internal Server Error",
+        })
+      );
+
+      const reporter = new Reporter({
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+      });
+
+      const initPromise = reporter.init();
+
+      reporter.send({
+        event: "playing",
+        sessionId: "test-session-id",
+        timestamp: 1000,
+        playhead: 0,
+        duration: 120,
+      } as TPlayerAnalyticsEvent);
+
+      try {
+        await initPromise;
+      } catch (e) {
+        // Expected
+      }
+
+      mockFetch.calls.reset();
+      spyOn(console, "warn");
+
+      reporter.send({
+        event: "heartbeat",
+        sessionId: "test-session-id",
+        timestamp: 2000,
+        playhead: 10,
+        duration: 120,
+      } as TPlayerAnalyticsEvent);
+
+      expect(console.warn).toHaveBeenCalled();
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    it("should not allow double init", async () => {
+      const reporter = new Reporter({
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+        debug: true,
+      });
+
+      const result1 = await reporter.init();
+      const result2 = await reporter.init();
+
+      expect(result1.sessionId).toBe(result2.sessionId);
+    });
+
+    it("should preserve event order even when send() is called between flush completion and state=ready", async () => {
+      // This test verifies the ordering barrier: events sent during the flush
+      // window must not overtake the queued chain on the wire.
+      let resolveInit!: (value: unknown) => void;
+      const pendingInit = new Promise((resolve) => {
+        resolveInit = resolve;
+      });
+      mockFetch.and.returnValue(pendingInit);
+
+      const reporter = new Reporter({
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+      });
+
+      const initPromise = reporter.init();
+      mockFetch.calls.reset();
+
+      // Queue 2 events during init
+      reporter.send({
+        event: "loading",
+        sessionId: "test-session-id",
+        timestamp: 1,
+        playhead: 0,
+        duration: 0,
+      } as TPlayerAnalyticsEvent);
+      reporter.send({
+        event: "loaded",
+        sessionId: "test-session-id",
+        timestamp: 2,
+        playhead: 0,
+        duration: 0,
+      } as TPlayerAnalyticsEvent);
+
+      expect(mockFetch).not.toHaveBeenCalled();
+
+      // Resolve init — flush starts. Make dispatch slow so we have time to call send during flush.
+      let dispatchCallCount = 0;
+      mockFetch.and.callFake(() => {
+        dispatchCallCount++;
+        // Slow down the first dispatch — gives us a window to send a new event mid-flush
+        return new Promise((resolve) =>
+          setTimeout(
+            () =>
+              resolve({
+                ok: true,
+                status: 200,
+                statusText: "OK",
+              }),
+            dispatchCallCount === 1 ? 30 : 0
+          )
+        );
+      });
+
+      resolveInit({
+        ok: true,
+        json: () => Promise.resolve({ sessionId: "server-session-id" }),
+        statusText: "OK",
+      });
+
+      // Wait briefly so flush starts dispatching the first queued event
+      await new Promise((resolve) => setTimeout(resolve, 5));
+
+      // Send a third event while flush is still in progress — must NOT overtake queue
+      reporter.send({
+        event: "playing",
+        sessionId: "test-session-id",
+        timestamp: 3,
+        playhead: 0,
+        duration: 0,
+      } as TPlayerAnalyticsEvent);
+
+      await initPromise;
+      // Allow all serialized awaits to settle
+      await new Promise((resolve) => setTimeout(resolve, 50));
+
+      // All 3 events should have been sent in order: loading, loaded, playing
+      expect(mockFetch.calls.count()).toBe(3);
+      const events = mockFetch.calls
+        .allArgs()
+        .map((args) => JSON.parse(args[1].body).event);
+      expect(events).toEqual(["loading", "loaded", "playing"]);
+    });
+  });
+
+  describe("destroy()", () => {
+    async function flushMicrotasks() {
+      for (let i = 0; i < 10; i++) await Promise.resolve();
+    }
+
+    it("should drop queued events when destroy() is called during init", async () => {
+      let resolveInit!: (value: unknown) => void;
+      const pendingInit = new Promise((resolve) => {
+        resolveInit = resolve;
+      });
+      mockFetch.and.returnValue(pendingInit);
+
+      const reporter = new Reporter({
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+      });
+
+      const initPromise = reporter.init();
+      mockFetch.calls.reset();
+
+      // Queue events during init
+      reporter.send({
+        event: "loading",
+        sessionId: "test-session-id",
+        timestamp: 1,
+        playhead: 0,
+        duration: 0,
+      } as TPlayerAnalyticsEvent);
+      reporter.send({
+        event: "playing",
+        sessionId: "test-session-id",
+        timestamp: 2,
+        playhead: 0,
+        duration: 0,
+      } as TPlayerAnalyticsEvent);
+
+      // Destroy BEFORE init resolves
+      reporter.destroy();
+
+      // Now resolve the init fetch — but reporter should abort, not flush
+      resolveInit({
+        ok: true,
+        json: () => Promise.resolve({ sessionId: "server-session-id" }),
+        statusText: "OK",
+      });
+
+      try {
+        await initPromise;
+      } catch {
+        /* expected to reject */
+      }
+      await flushMicrotasks();
+
+      // No events should have been dispatched
+      expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    it("should silently drop send() calls after destroy()", async () => {
+      const reporter = new Reporter({
+        eventsinkUrl: "https://example.com/analytics",
+        sessionId: "test-session-id",
+        debug: true,
+      });
+
+      await reporter.init();
+      mockFetch.calls.reset();
+
+      reporter.destroy();
+      spyOn(console, "warn");
+
+      reporter.send({
+        event: "playing",
+        sessionId: "test-session-id",
+        timestamp: 1,
+        playhead: 0,
+        duration: 0,
+      } as TPlayerAnalyticsEvent);
+
+      expect(mockFetch).not.toHaveBeenCalled();
+      // Don't warn — it's expected after destroy
+      expect(console.warn).not.toHaveBeenCalled();
+    });
+  });
+});