add tests

Author: clarasb

chartlets.js/packages/lib/src/plugins/vega/hooks/useSignalListeners.test.ts

@@ -4,11 +4,12 @@
  * https://opensource.org/licenses/MIT.
  */
 
-import { describe, it, expect } from "vitest";
+import { describe, it, expect, vi } from "vitest";
 import { renderHook, act } from "@testing-library/react";
 import type { TopLevelSpec } from "vega-lite";
 import { useSignalListeners } from "./useSignalListeners";
 import { createChangeHandler } from "@/plugins/mui/common.test";
+import type { Result as VegaEmbedResult } from "vega-embed";
 
 const chart: TopLevelSpec = {
   $schema: "https://vega.github.io/schema/vega-lite/v6.json",
@@ -72,7 +73,7 @@ describe("useSignalListeners", () => {
     expect(signalHandlers["sel_interval"]).toBeTypeOf("function");
     expect(signalHandlers["sel_point_a"]).toBeTypeOf("function");
     // "wheel" not supported
-    expect(signalHandlers["sel_point_b"]).toBeUndefined();
+    expect(signalHandlers["sel_interval_b"]).toBeUndefined();
   });
 
   it("should call onChange", () => {
@@ -95,4 +96,99 @@ describe("useSignalListeners", () => {
       value: [1, 2, 3],
     });
   });
+
+  it("should register signal listeners on embed", () => {
+    const { result } = renderHook(() =>
+      useSignalListeners(chartWithSelect, "VegaChart", "my_chart", () => {}),
+    );
+
+    const view = createMockView();
+
+    act(() => {
+      result.current.onEmbed({ view } as unknown as VegaEmbedResult);
+    });
+
+    // Supported signals: sel_point, sel_interval, sel_point_a
+    expect(view.addSignalListener).toHaveBeenCalledTimes(3);
+
+    const names = view.addSignalListener.mock.calls.map(([name]) => name);
+    expect(names).toEqual(
+      expect.arrayContaining(["sel_point", "sel_interval", "sel_point_a"]),
+    );
+
+    // Unsupported "wheel" should not be registered
+    expect(names).not.toContain("sel_interval_b");
+  });
+
+  it("should remove old listeners when embedding again", () => {
+    const { result } = renderHook(() =>
+      useSignalListeners(chartWithSelect, "VegaChart", "my_chart", () => {}),
+    );
+
+    const view1 = createMockView();
+    const view2 = createMockView();
+
+    act(() => {
+      result.current.onEmbed({ view: view1 } as unknown as VegaEmbedResult);
+    });
+
+    const attachedToView1 = view1.addSignalListener.mock.calls.map(
+      ([name, fn]) => ({ name, fn }),
+    );
+
+    act(() => {
+      result.current.onEmbed({ view: view2 } as unknown as VegaEmbedResult);
+    });
+
+    expect(view1.removeSignalListener).toHaveBeenCalledTimes(
+      attachedToView1.length,
+    );
+
+    for (const { name, fn } of attachedToView1) {
+      expect(view1.removeSignalListener).toHaveBeenCalledWith(name, fn);
+    }
+
+    expect(view2.addSignalListener).toHaveBeenCalledTimes(3);
+  });
+
+  it("should cleanup listeners on unmount", () => {
+    const { result, unmount } = renderHook(() =>
+      useSignalListeners(chartWithSelect, "VegaChart", "my_chart", () => {}),
+    );
+
+    const view = createMockView();
+
+    act(() => {
+      result.current.onEmbed({ view } as unknown as VegaEmbedResult);
+    });
+
+    const attached = view.addSignalListener.mock.calls.map(([name, fn]) => ({
+      name,
+      fn,
+    }));
+
+    unmount();
+
+    expect(view.removeSignalListener).toHaveBeenCalledTimes(attached.length);
+    for (const { name, fn } of attached) {
+      expect(view.removeSignalListener).toHaveBeenCalledWith(name, fn);
+    }
+  });
+
+  it("should do nothing if embed result has no view", () => {
+    const { result } = renderHook(() =>
+      useSignalListeners(chartWithSelect, "VegaChart", "my_chart", () => {}),
+    );
+
+    act(() => {
+      result.current.onEmbed({} as unknown as VegaEmbedResult);
+    });
+  });
 });
+
+function createMockView() {
+  return {
+    addSignalListener: vi.fn(),
+    removeSignalListener: vi.fn(),
+  };
+}