gloomberb 0.7.2 → 0.7.4

package/src/plugins/builtin/chat.test.tsx

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, test } from "bun:test";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import { act, useCallback, useMemo, useRef, useState } from "react";
 import { PaneFooterBar, PaneFooterProvider } from "../../components/layout/pane-footer";
 import { testRender } from "../../renderers/opentui/test-utils";
@@ -8,7 +8,7 @@ import { colors } from "../../theme/colors";
 import { createDefaultConfig, findPaneInstance, type PaneInstanceConfig } from "../../types/config";
 import type { PersistedResourceValue } from "../../types/persistence";
 import type { PluginPersistence } from "../../types/plugin";
-import { Box } from "../../ui";
+import { Box, TextAttributes } from "../../ui";
 import { apiClient, type ChatChannel, type ChatMessage } from "../../utils/api-client";
 import { PluginRenderProvider, type PluginRuntimeAccess } from "../plugin-runtime";
 import { setSharedMarketDataForTests, setSharedRegistryForTests } from "../registry";
@@ -21,6 +21,8 @@ const TRANSCRIPT_SOURCE = "server";
 const TRANSCRIPT_SCHEMA_VERSION = 2;
 const originalConnectChannel = apiClient.connectChannel.bind(apiClient);
 const originalGetChannels = apiClient.getChannels.bind(apiClient);
+const originalGetChatPresence = apiClient.getChatPresence.bind(apiClient);
+const originalUpdateChatChannelState = apiClient.updateChatChannelState.bind(apiClient);
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 
@@ -150,6 +152,8 @@ function createController(options: {
   controller.attachPersistence(persistence);
   controller.refreshSession = async () => {};
   controller.refreshMessages = async () => {};
+  controller.refreshPresence = async () => {};
+  controller.refreshChatState = async () => {};
   return controller;
 }
 
@@ -248,11 +252,23 @@ function hexToRgbaInts(hex: string) {
   ].join(",");
 }
 
+beforeEach(() => {
+  apiClient.getChatPresence = async () => ({ onlineCount: 0 });
+  apiClient.updateChatChannelState = async (channelId, body) => ({
+    channelId,
+    notificationsEnabled: body.notificationsEnabled ?? false,
+    lastReadMessageId: body.readThroughMessageId ?? null,
+    unreadCount: 0,
+  });
+});
+
 afterEach(async () => {
   setSharedRegistryForTests(undefined);
   setSharedMarketDataForTests(undefined);
   apiClient.connectChannel = originalConnectChannel;
   apiClient.getChannels = originalGetChannels;
+  apiClient.getChatPresence = originalGetChatPresence;
+  apiClient.updateChatChannelState = originalUpdateChatChannelState;
   apiClient.setSessionToken(null);
 
   if (testSetup) {
@@ -468,6 +484,136 @@ describe("ChatContent", () => {
     expect(testSetup.captureCharFrame()).toContain("#options");
   });
 
+  test("renders unread sidebar channels in bold and clears them when opened", async () => {
+    const controller = createController({ sessionToken: "token-123" });
+    installServerChannels(controller);
+    controller.refreshChannels = async () => {};
+    controller.refreshChannelMessages = async () => {};
+    const optionsState = (controller as any).ensureChannelState("options");
+    optionsState.unreadCount = 2;
+    const state = createInitialState(createDefaultConfig("/tmp/gloomberb-chat"));
+
+    function ChannelPane() {
+      const [channelId, setChannelId] = useState("equities");
+      return (
+        <AppContext value={{ state, dispatch: () => {} }}>
+          <PluginRenderProvider pluginId="gloomberb-cloud" runtime={createTestPluginRuntime()}>
+            <ChatContent
+              controller={controller}
+              width={90}
+              height={12}
+              focused
+              channelId={channelId}
+              onChannelChange={setChannelId}
+            />
+          </PluginRenderProvider>
+        </AppContext>
+      );
+    }
+
+    await act(async () => {
+      testSetup = await testRender(<ChannelPane />, {
+        width: 90,
+        height: 12,
+      });
+    });
+
+    await flushFrame();
+    const unreadLine = testSetup.captureSpans().lines.find((line) => lineText(line).includes("options"));
+    const unreadSpan = unreadLine?.spans.find((span) => span.text.includes("options"));
+    expect((unreadSpan?.attributes ?? 0) & TextAttributes.BOLD).toBe(TextAttributes.BOLD);
+
+    const lines = testSetup.captureCharFrame().split("\n");
+    const row = lines.findIndex((line) => line.includes("options"));
+    const col = lines[row]?.indexOf("options") ?? -1;
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(col + 1, row);
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    const readLine = testSetup.captureSpans().lines.find((line) => lineText(line).includes("#options"));
+    const readSpan = readLine?.spans.find((span) => span.text.includes("options"));
+    expect((readSpan?.attributes ?? 0) & TextAttributes.BOLD).toBe(0);
+  });
+
+  test("toggles sidebar channel notifications without selecting the channel", async () => {
+    const controller = createController({ sessionToken: "token-123" });
+    installServerChannels(controller);
+    controller.refreshChannels = async () => {};
+    controller.refreshChannelMessages = async () => {};
+    const toggles: Array<{ channelId: string; enabled: boolean }> = [];
+    controller.setChannelNotificationsEnabled = (channelId: string, enabled: boolean) => {
+      toggles.push({ channelId, enabled });
+    };
+    const state = createInitialState(createDefaultConfig("/tmp/gloomberb-chat"));
+
+    function ChannelPane() {
+      const [channelId, setChannelId] = useState("equities");
+      return (
+        <AppContext value={{ state, dispatch: () => {} }}>
+          <PluginRenderProvider pluginId="gloomberb-cloud" runtime={createTestPluginRuntime()}>
+            <ChatContent
+              controller={controller}
+              width={90}
+              height={12}
+              focused
+              channelId={channelId}
+              onChannelChange={setChannelId}
+            />
+          </PluginRenderProvider>
+        </AppContext>
+      );
+    }
+
+    await act(async () => {
+      testSetup = await testRender(<ChannelPane />, {
+        width: 90,
+        height: 12,
+      });
+    });
+
+    await flushFrame();
+    const frame = testSetup.captureCharFrame();
+    const lines = frame.split("\n");
+    const row = lines.findIndex((line) => line.includes("options"));
+    const col = lines[row]?.lastIndexOf("·") ?? -1;
+    expect(row).toBeGreaterThanOrEqual(0);
+    expect(col).toBeGreaterThanOrEqual(0);
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(col, row);
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    expect(toggles).toEqual([{ channelId: "options", enabled: true }]);
+    expect(testSetup.captureCharFrame()).toContain("#equities");
+    expect(testSetup.captureCharFrame()).not.toContain("#options");
+  });
+
+  test("shows the sidebar online count footer", async () => {
+    const controller = createController({ sessionToken: "token-123" });
+    installServerChannels(controller);
+    controller.refreshChannels = async () => {};
+    controller.refreshChannelMessages = async () => {};
+    (controller as any).onlineCount = 6;
+
+    await act(async () => {
+      testSetup = await testRender(createHarness(controller, { width: 90, height: 12 }), {
+        width: 90,
+        height: 12,
+      });
+    });
+
+    await flushFrame();
+
+    expect(testSetup.captureCharFrame()).toContain("● 6 online");
+  });
+
   test("uses arrows to move between channel sidebar and chat content", async () => {
     const controller = createController({ sessionToken: "token-123" });
     installServerChannels(controller);
@@ -818,6 +964,34 @@ describe("ChatContent", () => {
     expect(frame).toContain("Reply to @user2...");
   });
 
+  test("modified k does not move message selection", async () => {
+    const controller = createController({
+      messages: [makeMessage(1), makeMessage(2)],
+    });
+
+    await act(async () => {
+      testSetup = await testRender(createHarness(controller, {
+        width: 72,
+        height: 12,
+      }), {
+        width: 72,
+        height: 12,
+      });
+    });
+
+    await flushFrame();
+
+    await emitKeypress({ name: "up", sequence: "\u001b[A" });
+    await emitKeypress({ name: "k", sequence: "k", meta: true });
+    await emitKeypress({ name: "return", sequence: "\r" });
+    await flushFrame();
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("replying to @user2");
+    expect(frame).toContain("Reply to @user2...");
+    expect(frame).not.toContain("replying to @user1");
+  });
+
   test("shows the reply action next to the selected message timestamp", async () => {
     const controller = createController({
       messages: [makeMessage(1), makeMessage(2)],
@@ -1291,6 +1465,61 @@ describe("ChatContent", () => {
     expect(sentMessages).toEqual(["first line\nsecond line"]);
   });
 
+  test("clears the composer locally after an accepted send", async () => {
+    const controller = createController({ sessionToken: "token-123" });
+    const sentMessages: string[] = [];
+    (controller as any).send = (content: string) => {
+      sentMessages.push(content);
+      return true;
+    };
+    (controller as any).setDraft = () => {};
+
+    await act(async () => {
+      testSetup = await testRender(createHarness(controller), {
+        width: 60,
+        height: 12,
+      });
+    });
+
+    await flushFrame();
+
+    const frameBeforeClick = testSetup.captureCharFrame().split("\n");
+    const inputRow = frameBeforeClick.findIndex((line) => line.includes("Type a message..."));
+    const inputCol = frameBeforeClick[inputRow]?.indexOf("Type a message...") ?? -1;
+
+    expect(inputRow).toBeGreaterThanOrEqual(0);
+    expect(inputCol).toBeGreaterThanOrEqual(0);
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(inputCol + 1, inputRow);
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    await act(async () => {
+      await testSetup!.mockInput.typeText("hello");
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    await act(async () => {
+      testSetup!.mockInput.pressEnter();
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    expect(sentMessages).toEqual(["hello"]);
+    expect(testSetup.captureCharFrame()).not.toContain("> hello");
+
+    await act(async () => {
+      testSetup!.mockInput.pressEnter();
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+
+    expect(sentMessages).toEqual(["hello"]);
+  });
+
   test("keeps typed shortcut letters in the composer instead of moving message selection", async () => {
     const controller = createController({
       messages: Array.from({ length: 18 }, (_, index) => makeMessage(index + 1)),
@@ -1448,7 +1677,7 @@ describe("ChatContent", () => {
     expect(frame).not.toContain("message 1");
   });
 
-  test("repins the transcript to the latest message when a following chat pane regains focus", async () => {
+  test("preserves a manually scrolled transcript across focus and snapshot refreshes", async () => {
     const controller = createController({
       messages: [
         makeMessage(1),
@@ -1506,13 +1735,90 @@ describe("ChatContent", () => {
 
     await act(async () => {
       setFocused?.(true);
+      (controller as any).emit("everyone");
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    const refreshedFrame = testSetup.captureCharFrame();
+    expect(refreshedFrame).toContain("message 2");
+    expect(refreshedFrame).not.toContain("message 8");
+  });
+
+  test("opens a newly selected channel at the latest message", async () => {
+    const controller = createController({
+      messages: Array.from({ length: 8 }, (_, index) => makeMessage(index + 1)),
+    });
+    installServerChannels(controller, TEST_CHAT_CHANNELS.slice(0, 2));
+    controller.refreshChannels = async () => {};
+    controller.refreshChannelMessages = async () => {};
+
+    const equitiesMessages = Array.from({ length: 8 }, (_, index) => ({
+      ...makeMessage(index + 1),
+      id: `o${index + 1}`,
+      channelId: "equities",
+      content: `equities message ${index + 1}`,
+    }));
+    const equitiesState = (controller as any).ensureChannelState("equities");
+    equitiesState.messages = equitiesMessages;
+    equitiesState.lastCursor = "o8";
+
+    const state = createInitialState(createDefaultConfig("/tmp/gloomberb-chat-channel-scroll"));
+
+    function ChannelPane() {
+      const [channelId, setChannelId] = useState("everyone");
+      return (
+        <AppContext value={{ state, dispatch: () => {} }}>
+          <PluginRenderProvider pluginId="gloomberb-cloud" runtime={createTestPluginRuntime()}>
+            <ChatContent
+              controller={controller}
+              width={90}
+              height={13}
+              focused
+              channelId={channelId}
+              onChannelChange={setChannelId}
+            />
+          </PluginRenderProvider>
+        </AppContext>
+      );
+    }
+
+    await act(async () => {
+      testSetup = await testRender(<ChannelPane />, {
+        width: 90,
+        height: 13,
+      });
+    });
+
+    await flushFrame();
+    expect(testSetup.captureCharFrame()).toContain("message 8");
+
+    await act(async () => {
+      await testSetup!.mockMouse.scroll(24, 4, "up");
+      await testSetup!.mockMouse.scroll(24, 4, "up");
+      await testSetup!.mockMouse.scroll(24, 4, "up");
+      await testSetup!.renderOnce();
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+    expect(testSetup.captureCharFrame()).toContain("message 2");
+
+    const lines = testSetup.captureCharFrame().split("\n");
+    const row = lines.findIndex((line) => line.includes("equities"));
+    const col = lines[row]?.indexOf("equities") ?? -1;
+    expect(row).toBeGreaterThanOrEqual(0);
+    expect(col).toBeGreaterThanOrEqual(0);
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(col + 1, row);
+      await testSetup!.renderOnce();
       await testSetup!.renderOnce();
     });
     await flushFrame();
 
-    const refocusedFrame = testSetup.captureCharFrame();
-    expect(refocusedFrame).toContain("message 8");
-    expect(refocusedFrame).not.toContain("message 2");
+    const channelFrame = testSetup.captureCharFrame();
+    expect(channelFrame).toContain("equities message 8");
+    expect(channelFrame).not.toContain("equities message 1");
   });
 
   test("keeps the bottom reachable after narrowing the chat pane", async () => {