test(pusher-web): add unit tests for Pusher, getChannelName, fetchPusherConfig

Cover the previously untested upper layers: widget subscription building
logic in Pusher.tsx, channel name derivation, and config fetch error paths.

Author: r0b1n

packages/pluggableWidgets/pusher-web/src/__tests__/Pusher.spec.tsx

@@ -1,10 +1,70 @@
+import { render } from "@testing-library/react";
+import { ActionValue, DynamicValue, ObjectItem } from "mendix";
+import { createElement } from "react";
+import * as usePusherSubscribeModule from "../hooks/usePusherSubscribe";
+import Pusher from "../Pusher";
+import * as getChannelNameModule from "../utils/getChannelName";
+
+jest.mock("../utils/getChannelName");
+jest.mock("../hooks/usePusherSubscribe", () => ({
+    usePusherSubscribe: jest.fn()
+}));
+
+const mockGetChannelName = getChannelNameModule.getChannelName as jest.MockedFunction<
+    typeof getChannelNameModule.getChannelName
+>;
+const mockUsePusherSubscribe = usePusherSubscribeModule.usePusherSubscribe as jest.Mock;
+
+function makeAction(canExecute = true): ActionValue {
+    return { canExecute, execute: jest.fn(), isExecuting: false } as unknown as ActionValue;
+}
+
+function makeProps(channelName: string | undefined, handlers: Array<{ actionName: string; action: ActionValue }>) {
+    mockGetChannelName.mockReturnValue(channelName);
+    return {
+        name: "pusher",
+        class: "",
+        objectSource: {} as DynamicValue<ObjectItem>,
+        eventHandlers: handlers
+    } as any;
+}
+
 describe("Pusher", () => {
-    it("placeholder – tests to be implemented", () => {
-        // TODO: Add comprehensive unit tests for:
-        // - PusherListener class (connection, subscription, cleanup)
-        // - usePusherConfig hook (fetching config)
-        // - usePusherListener hook (React lifecycle integration)
-        // - Event handling and action execution
-        expect(true).toBe(true);
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+
+    it("passes undefined subscription when channelName is undefined", () => {
+        render(createElement(Pusher, makeProps(undefined, [{ actionName: "update", action: makeAction() }])));
+
+        expect(mockUsePusherSubscribe).toHaveBeenCalledWith(undefined);
+    });
+
+    it("passes undefined subscription when eventHandlers is empty", () => {
+        render(createElement(Pusher, makeProps("private-Entity.123", [])));
+
+        expect(mockUsePusherSubscribe).toHaveBeenCalledWith(undefined);
+    });
+
+    it("passes subscription with correct channelName and eventBindings", () => {
+        const action = makeAction();
+        render(createElement(Pusher, makeProps("private-Entity.123", [{ actionName: "update", action }])));
+
+        expect(mockUsePusherSubscribe).toHaveBeenCalledWith(
+            expect.objectContaining({
+                channelName: "private-Entity.123",
+                eventBindings: [expect.objectContaining({ eventName: "update" })]
+            })
+        );
+    });
+
+    it("calls executeAction when onEvent fires", () => {
+        const action = makeAction();
+        render(createElement(Pusher, makeProps("private-Entity.123", [{ actionName: "update", action }])));
+
+        const { eventBindings } = mockUsePusherSubscribe.mock.calls[0][0];
+        eventBindings[0].onEvent();
+
+        expect(action.execute).toHaveBeenCalledTimes(1);
     });
 });

packages/pluggableWidgets/pusher-web/src/__tests__/PusherListener.spec.ts

@@ -0,0 +1,77 @@
+import { PusherListener } from "../utils/PusherListener";
+
+const mockChannel = {
+    bind_global: jest.fn(),
+    unbind_all: jest.fn(),
+    bind: jest.fn()
+};
+
+const mockPusherInstance = {
+    subscribe: jest.fn().mockReturnValue(mockChannel),
+    unsubscribe: jest.fn(),
+    disconnect: jest.fn(),
+    connection: { bind: jest.fn(), unbind: jest.fn() }
+};
+
+jest.mock("pusher-js", () => jest.fn().mockImplementation(() => mockPusherInstance));
+
+const stubConfig = { key: "key", cluster: "eu", authEndpoint: "/auth", csrfToken: "tok" };
+const stubSubscription = {
+    channelName: "private-Entity.123",
+    eventBindings: [{ eventName: "update", onEvent: jest.fn() }]
+};
+
+describe("PusherListener", () => {
+    let listener: PusherListener;
+
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockPusherInstance.subscribe.mockReturnValue(mockChannel);
+        listener = new PusherListener(stubConfig);
+    });
+
+    it("subscribes to channel and binds global handler", () => {
+        listener.subscribe(stubSubscription);
+
+        expect(mockPusherInstance.subscribe).toHaveBeenCalledWith(stubSubscription.channelName);
+        expect(mockChannel.bind_global).toHaveBeenCalledTimes(1);
+    });
+
+    it("skips Pusher resubscription on same channel name", () => {
+        listener.subscribe(stubSubscription);
+        listener.subscribe({ ...stubSubscription, eventBindings: [{ eventName: "other", onEvent: jest.fn() }] });
+
+        expect(mockPusherInstance.subscribe).toHaveBeenCalledTimes(1);
+    });
+
+    it("resubscribes when channel name changes", () => {
+        listener.subscribe(stubSubscription);
+        listener.subscribe({ ...stubSubscription, channelName: "private-Entity.456" });
+
+        expect(mockPusherInstance.unsubscribe).toHaveBeenCalledWith(stubSubscription.channelName);
+        expect(mockPusherInstance.subscribe).toHaveBeenCalledWith("private-Entity.456");
+    });
+
+    it("updates handler map so new handler fires without resubscribing", () => {
+        const firstHandler = jest.fn();
+        const secondHandler = jest.fn();
+
+        listener.subscribe({ ...stubSubscription, eventBindings: [{ eventName: "update", onEvent: firstHandler }] });
+        listener.subscribe({ ...stubSubscription, eventBindings: [{ eventName: "update", onEvent: secondHandler }] });
+
+        const globalCb = mockChannel.bind_global.mock.calls[0][0] as (name: string, data: unknown) => void;
+        globalCb("update", {});
+
+        expect(mockPusherInstance.subscribe).toHaveBeenCalledTimes(1);
+        expect(firstHandler).not.toHaveBeenCalled();
+        expect(secondHandler).toHaveBeenCalledTimes(1);
+    });
+
+    it("destroy disconnects and is idempotent", () => {
+        listener.subscribe(stubSubscription);
+        listener.destroy();
+        listener.destroy();
+
+        expect(mockPusherInstance.disconnect).toHaveBeenCalledTimes(1);
+    });
+});

packages/pluggableWidgets/pusher-web/src/__tests__/fetchPusherConfig.spec.ts

@@ -0,0 +1,70 @@
+import { fetchPusherConfig } from "../utils/fetchPusherConfig";
+
+function mockFetch(status: number, body: unknown): void {
+    global.fetch = jest.fn().mockResolvedValue({
+        status,
+        json: () => Promise.resolve(body)
+    });
+}
+
+beforeEach(() => {
+    (window as any).mx = {
+        remoteUrl: "https://app.example.com/",
+        sessionData: { csrftoken: "test-csrf" }
+    };
+});
+
+afterEach(() => {
+    delete (window as any).mx;
+    jest.resetAllMocks();
+});
+
+describe("fetchPusherConfig", () => {
+    it("returns config on successful response", async () => {
+        mockFetch(200, { key: "app-key", cluster: "eu" });
+
+        const result = await fetchPusherConfig(new AbortController().signal);
+
+        expect(result).toEqual({
+            key: "app-key",
+            cluster: "eu",
+            authEndpoint: "https://app.example.com/rest/pusher/auth",
+            csrfToken: "test-csrf"
+        });
+    });
+
+    it("returns null on non-200 response", async () => {
+        mockFetch(403, {});
+
+        const result = await fetchPusherConfig(new AbortController().signal);
+
+        expect(result).toBeNull();
+    });
+
+    it("returns null on network error", async () => {
+        global.fetch = jest.fn().mockRejectedValue(new Error("Network failure"));
+
+        const result = await fetchPusherConfig(new AbortController().signal);
+
+        expect(result).toBeNull();
+    });
+
+    it("returns null when signal is already aborted", async () => {
+        const controller = new AbortController();
+        const abortError = new DOMException("Aborted", "AbortError");
+        global.fetch = jest.fn().mockRejectedValue(abortError);
+        controller.abort();
+
+        const result = await fetchPusherConfig(controller.signal);
+
+        expect(result).toBeNull();
+    });
+
+    it("returns null when response is missing required fields", async () => {
+        mockFetch(200, { key: "app-key" }); // missing cluster
+
+        const result = await fetchPusherConfig(new AbortController().signal);
+
+        expect(result).toBeNull();
+    });
+});

packages/pluggableWidgets/pusher-web/src/__tests__/getChannelName.spec.ts

@@ -0,0 +1,36 @@
+import { DynamicValue, ObjectItem } from "mendix";
+import { getChannelName } from "../utils/getChannelName";
+
+function makeObjectSource(value?: ObjectItem): DynamicValue<ObjectItem> {
+    return { value } as DynamicValue<ObjectItem>;
+}
+
+function makeObjectItem(entityName: string, guid: string): ObjectItem {
+    const mxObject = { getEntity: () => entityName };
+    const sym = Symbol("mxObject");
+    const item = { id: guid, [sym]: mxObject } as unknown as ObjectItem;
+    Object.defineProperty(item, sym, { value: mxObject, enumerable: false });
+    // Place symbol as first own symbol so extractEntityName finds it
+    return item;
+}
+
+describe("getChannelName", () => {
+    it("returns undefined when objectSource has no value", () => {
+        expect(getChannelName(makeObjectSource(undefined))).toBeUndefined();
+    });
+
+    it("returns private channel name for valid object", () => {
+        const item = makeObjectItem("MyModule.MyEntity", "guid-123");
+        expect(getChannelName(makeObjectSource(item))).toBe("private-MyModule.MyEntity.guid-123");
+    });
+
+    it("throws when mxObject symbol is absent", () => {
+        const item = { id: "guid-123" } as unknown as ObjectItem;
+        expect(() => getChannelName(makeObjectSource(item))).toThrow("Unable to extract entity name");
+    });
+
+    it("returns undefined when guid is empty", () => {
+        const item = makeObjectItem("MyModule.MyEntity", "");
+        expect(getChannelName(makeObjectSource(item))).toBeUndefined();
+    });
+});

packages/pluggableWidgets/pusher-web/src/__tests__/usePusherSubscribe.spec.ts

@@ -0,0 +1,57 @@
+import { act, renderHook } from "@testing-library/react";
+import { usePusherSubscribe } from "../hooks/usePusherSubscribe";
+import { createPusherListener } from "../utils/createPusherListener";
+
+jest.mock("../utils/createPusherListener");
+
+const mockListener = {
+    subscribe: jest.fn(),
+    unsubscribe: jest.fn(),
+    destroy: jest.fn()
+};
+
+const mockCreatePusherListener = createPusherListener as jest.MockedFunction<typeof createPusherListener>;
+
+const stubSubscription = {
+    channelName: "private-Entity.123",
+    eventBindings: [{ eventName: "update", onEvent: jest.fn() }]
+};
+
+describe("usePusherSubscribe", () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockCreatePusherListener.mockResolvedValue(mockListener as never);
+    });
+
+    it("calls subscribe when listener and subscription are ready", async () => {
+        renderHook(() => usePusherSubscribe(stubSubscription));
+
+        await act(async () => {});
+
+        expect(mockListener.subscribe).toHaveBeenCalledWith(stubSubscription);
+    });
+
+    it("calls unsubscribe when subscription is undefined", async () => {
+        renderHook(() => usePusherSubscribe(undefined));
+
+        await act(async () => {});
+
+        expect(mockListener.unsubscribe).toHaveBeenCalledTimes(1);
+        expect(mockListener.subscribe).not.toHaveBeenCalled();
+    });
+
+    it("calls destroy on unmount, not unsubscribe directly", async () => {
+        const { unmount } = renderHook(() => usePusherSubscribe(stubSubscription));
+
+        await act(async () => {});
+
+        const unsubscribeCallsBefore = mockListener.unsubscribe.mock.calls.length;
+
+        act(() => {
+            unmount();
+        });
+
+        expect(mockListener.destroy).toHaveBeenCalledTimes(1);
+        expect(mockListener.unsubscribe.mock.calls.length).toBe(unsubscribeCallsBefore);
+    });
+});