@player-tools/devtools-messenger 0.8.0-next.0 → 0.8.0

package/src/__tests__/index.test.ts

@@ -1,13 +1,14 @@
-import { describe, afterEach, expect, test, vi } from "vitest";
+import { describe, beforeEach, expect, test, vi } from "vitest";
 import { Messenger } from "../index";
 import { createMockContext } from "./helpers";
+import { BaseEvent } from "@player-tools/devtools-types";
 
 vi.useFakeTimers();
 
 describe("Messenger", () => {
-  afterEach(() => {
+  beforeEach(() => {
     vi.clearAllMocks();
-    Messenger.resetEvents();
+    Messenger.reset();
   });
 
   test("beacons", () => {
@@ -19,15 +20,15 @@ describe("Messenger", () => {
       sendMessage: mockMessagingAPI.sendMessage.bind(mockMessagingAPI),
       addListener: mockMessagingAPI.addListener.bind(mockMessagingAPI),
       removeListener: mockMessagingAPI.removeListener.bind(mockMessagingAPI),
-      messageCallback: spies.web.messageCallback,
-      id: "test",
-      context: "player",
+      messageCallback: spies.web1.messageCallback,
+      context: "devtools",
+      id: "test1",
       logger: console,
     });
 
     vi.advanceTimersByTime(1000);
 
-    expect(spies.web.sendMessage).toHaveBeenCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenCalledWith(
       expect.objectContaining({ type: "MESSENGER_BEACON" })
     );
   });
@@ -39,13 +40,13 @@ describe("Messenger", () => {
       sendMessage: mockMessagingAPI.sendMessage.bind(mockMessagingAPI),
       addListener: mockMessagingAPI.addListener.bind(mockMessagingAPI),
       removeListener: mockMessagingAPI.removeListener.bind(mockMessagingAPI),
-      messageCallback: spies.web.messageCallback,
-      id: "test",
-      context: "player",
+      messageCallback: spies.web1.messageCallback,
+      context: "devtools",
+      id: "test2",
       logger: console,
     });
 
-    const events = [
+    const events: Array<BaseEvent<string, unknown>> = [
       { type: "TEST", payload: { count: 1 } },
       { type: "TEST", payload: { count: 2 } },
       { type: "TEST", payload: { count: 3 } },
@@ -70,37 +71,53 @@ describe("Messenger", () => {
       sender: "test-2",
     });
 
-    expect(spies.web.sendMessage).toHaveBeenCalledTimes(5);
+    expect(spies.web1.sendMessage).toHaveBeenCalledTimes(8);
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       1,
-      expect.objectContaining({ type: "MESSENGER_BEACON" })
+      expect.objectContaining({ ...events[0], sender: "test2" })
     );
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       2,
       expect.objectContaining({ type: "MESSENGER_BEACON" })
     );
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       3,
-      expect.objectContaining({ type: "MESSENGER_BEACON" })
+      expect.objectContaining({ ...events[1], sender: "test2" })
     );
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       4,
       expect.objectContaining({ type: "MESSENGER_BEACON" })
     );
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       5,
+      expect.objectContaining({ ...events[2], sender: "test2" })
+    );
+
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      6,
+      expect.objectContaining({ type: "MESSENGER_BEACON" })
+    );
+
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      7,
+      expect.objectContaining({ type: "MESSENGER_BEACON" })
+    );
+
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      8,
       expect.objectContaining({
         type: "MESSENGER_EVENT_BATCH",
+        target: "test-2",
         payload: {
           events: [
-            expect.objectContaining({ ...events[0], target: "test-2" }),
-            expect.objectContaining({ ...events[1], target: "test-2" }),
-            expect.objectContaining({ ...events[2], target: "test-2" }),
+            expect.objectContaining({ ...events[0] }),
+            expect.objectContaining({ ...events[1] }),
+            expect.objectContaining({ ...events[2] }),
           ],
         },
       })
@@ -110,12 +127,12 @@ describe("Messenger", () => {
   test("messeges sent between two Messenger instances", () => {
     const { spies, mockMessagingAPI } = createMockContext();
 
-    const eventsWeb = [
+    const eventsweb1: Array<BaseEvent<string, unknown>> = [
       { type: "TEST", payload: { count: 1 } },
       { type: "TEST", payload: { count: 2 } },
     ];
 
-    const eventsDevtools = [
+    const eventsDevtools: Array<BaseEvent<string, unknown>> = [
       { type: "TEST", payload: { count: 3 } },
       { type: "TEST", payload: { count: 4 } },
     ];
@@ -124,23 +141,23 @@ describe("Messenger", () => {
       sendMessage: mockMessagingAPI.sendMessage.bind(mockMessagingAPI),
       addListener: mockMessagingAPI.addListener.bind(mockMessagingAPI),
       removeListener: mockMessagingAPI.removeListener.bind(mockMessagingAPI),
-      messageCallback: spies.web.messageCallback,
-      id: "web",
+      messageCallback: spies.web1.messageCallback,
       context: "player",
+      id: "web1",
       logger: console,
     });
 
     vi.advanceTimersByTime(1000);
 
-    messenger1.sendMessage(eventsWeb[0]);
+    messenger1.sendMessage(eventsweb1[0]);
 
     const messenger2 = new Messenger({
       sendMessage: mockMessagingAPI.sendMessage.bind(mockMessagingAPI),
       addListener: mockMessagingAPI.addListener.bind(mockMessagingAPI),
       removeListener: mockMessagingAPI.removeListener.bind(mockMessagingAPI),
       messageCallback: spies.devtools.messageCallback,
-      id: "devtools",
       context: "devtools",
+      id: "devtools1",
       logger: console,
     });
 
@@ -150,73 +167,204 @@ describe("Messenger", () => {
 
     vi.advanceTimersByTime(1000);
 
-    messenger1.sendMessage(eventsWeb[1]);
+    messenger1.sendMessage(eventsweb1[1]);
 
     messenger2.sendMessage(eventsDevtools[1]);
 
     vi.advanceTimersByTime(1000);
 
-    expect(spies.web.sendMessage).toHaveBeenCalledTimes(11);
+    expect(spies.web1.sendMessage).toHaveBeenCalledTimes(12);
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       1,
       expect.objectContaining({ type: "MESSENGER_BEACON" })
     );
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       2,
-      expect.objectContaining({ type: "MESSENGER_BEACON" })
+      expect.objectContaining({ ...eventsweb1[0], sender: "web1" })
     );
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       3,
       expect.objectContaining({ type: "MESSENGER_BEACON" })
     );
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       4,
+      expect.objectContaining({ type: "MESSENGER_BEACON" })
+    );
+
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      5,
       expect.objectContaining({
         type: "MESSENGER_EVENT_BATCH",
+        target: "devtools1",
         payload: {
-          events: [
-            expect.objectContaining({ ...eventsWeb[0], target: "devtools" }),
-          ],
+          events: [expect.objectContaining({ ...eventsweb1[0] })],
         },
       })
     );
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
-      5,
-      expect.objectContaining({ ...eventsDevtools[0], sender: "devtools" })
-    );
-
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       6,
-      expect.objectContaining({ type: "MESSENGER_BEACON" })
+      expect.objectContaining({ ...eventsDevtools[0], sender: "devtools1" })
     );
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       7,
       expect.objectContaining({ type: "MESSENGER_BEACON" })
     );
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       8,
-      expect.objectContaining({ ...eventsWeb[1], sender: "web" })
+      expect.objectContaining({ type: "MESSENGER_BEACON" })
     );
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       9,
-      expect.objectContaining({ ...eventsDevtools[1], sender: "devtools" })
+      expect.objectContaining({ ...eventsweb1[1], sender: "web1" })
     );
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       10,
+      expect.objectContaining({ ...eventsDevtools[1], sender: "devtools1" })
+    );
+
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      11,
       expect.objectContaining({ type: "MESSENGER_BEACON" })
     );
 
-    expect(spies.web.sendMessage).toHaveBeenNthCalledWith(
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      12,
+      expect.objectContaining({ type: "MESSENGER_BEACON" })
+    );
+  });
+
+  test("messages sent between two web Messenger instances and one devtools instance", () => {
+    const { spies, mockMessagingAPI } = createMockContext();
+
+    const eventsWeb1: Array<BaseEvent<string, unknown>> = [
+      { type: "TEST", target: "web2", payload: { count: 1 } },
+      { type: "TEST", target: "devtools", payload: { count: 2 } },
+    ];
+
+    const eventsWeb2: Array<BaseEvent<string, unknown>> = [
+      { type: "TEST", target: "web1", payload: { count: 3 } },
+      { type: "TEST", target: "devtools", payload: { count: 4 } },
+    ];
+
+    const eventsDevtools: Array<BaseEvent<string, unknown>> = [
+      { type: "TEST", target: "web1", payload: { count: 5 } },
+      { type: "TEST", target: "web2", payload: { count: 6 } },
+    ];
+
+    const messengerWeb1 = new Messenger({
+      sendMessage: mockMessagingAPI.sendMessage.bind(mockMessagingAPI),
+      addListener: mockMessagingAPI.addListener.bind(mockMessagingAPI),
+      removeListener: mockMessagingAPI.removeListener.bind(mockMessagingAPI),
+      messageCallback: spies.web1.messageCallback,
+      id: "web2",
+      context: "player",
+      logger: console,
+    });
+
+    const messengerWeb2 = new Messenger({
+      sendMessage: mockMessagingAPI.sendMessage.bind(mockMessagingAPI),
+      addListener: mockMessagingAPI.addListener.bind(mockMessagingAPI),
+      removeListener: mockMessagingAPI.removeListener.bind(mockMessagingAPI),
+      messageCallback: spies.web2.messageCallback,
+      id: "web3",
+      context: "player",
+      logger: console,
+    });
+
+    const messengerDevtools = new Messenger({
+      sendMessage: mockMessagingAPI.sendMessage.bind(mockMessagingAPI),
+      addListener: mockMessagingAPI.addListener.bind(mockMessagingAPI),
+      removeListener: mockMessagingAPI.removeListener.bind(mockMessagingAPI),
+      messageCallback: spies.devtools.messageCallback,
+      id: "devtools2",
+      context: "devtools",
+      logger: console,
+    });
+
+    vi.advanceTimersByTime(1000);
+
+    messengerWeb1.sendMessage(eventsWeb1[0]);
+    messengerWeb2.sendMessage(eventsWeb2[0]);
+    messengerDevtools.sendMessage(eventsDevtools[0]);
+
+    vi.advanceTimersByTime(1000);
+
+    messengerWeb1.sendMessage(eventsWeb1[1]);
+    messengerWeb2.sendMessage(eventsWeb2[1]);
+    messengerDevtools.sendMessage(eventsDevtools[1]);
+
+    vi.advanceTimersByTime(1000);
+
+    expect(spies.web1.sendMessage).toHaveBeenCalledTimes(15);
+    expect(spies.web2.sendMessage).toHaveBeenCalledTimes(15);
+    expect(spies.devtools.sendMessage).toHaveBeenCalledTimes(15);
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      1,
+      expect.objectContaining({ type: "MESSENGER_BEACON" })
+    );
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ type: "MESSENGER_BEACON" })
+    );
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({ type: "MESSENGER_BEACON" })
+    );
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      4,
+      expect.objectContaining({ ...eventsWeb1[0], target: "web2" })
+    );
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      5,
+      expect.objectContaining({ ...eventsWeb2[0], target: "web1" })
+    );
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      6,
+      expect.objectContaining({ ...eventsDevtools[0], target: "web1" })
+    );
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      7,
+      expect.objectContaining({ type: "MESSENGER_BEACON" })
+    );
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      8,
+      expect.objectContaining({ type: "MESSENGER_BEACON" })
+    );
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      9,
+      expect.objectContaining({ type: "MESSENGER_BEACON" })
+    );
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      10,
+      expect.objectContaining({ ...eventsWeb1[1], target: "devtools" })
+    );
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
       11,
+      expect.objectContaining({ ...eventsWeb2[1], target: "devtools" })
+    );
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      12,
+      expect.objectContaining({ ...eventsDevtools[1], target: "web2" })
+    );
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      13,
+      expect.objectContaining({ type: "MESSENGER_BEACON" })
+    );
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      14,
+      expect.objectContaining({ type: "MESSENGER_BEACON" })
+    );
+    expect(spies.web1.sendMessage).toHaveBeenNthCalledWith(
+      15,
       expect.objectContaining({ type: "MESSENGER_BEACON" })
     );
   });