gloomberb 0.7.1 → 0.7.3

package/src/plugins/builtin/portfolio-list.test.tsx

@@ -5,6 +5,7 @@ import { join } from "path";
 import { act, useReducer } from "react";
 import { testRender } from "../../renderers/opentui/test-utils";
 import { AppPersistence } from "../../data/app-persistence";
+import { TickerRepository } from "../../data/ticker-repository";
 import { AppContext, appReducer, createInitialState, PaneInstanceProvider, type AppAction } from "../../state/app-context";
 import { AssetDataRouter } from "../../sources/provider-router";
 import { cloneLayout, createDefaultConfig, type AppConfig, type BrokerInstanceConfig } from "../../types/config";
@@ -12,8 +13,10 @@ import type { DataProvider } from "../../types/data-provider";
 import type { Quote } from "../../types/financials";
 import type { TickerRecord } from "../../types/ticker";
 import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../../market-data/coordinator";
+import { instrumentFromTicker } from "../../market-data/request-types";
 import { createTestPluginRuntime } from "../../test-support/plugin-runtime";
 import { PluginRenderProvider, type PluginRuntimeAccess } from "../plugin-runtime";
+import { PluginRegistry, setSharedMarketDataForTests, setSharedRegistryForTests } from "../registry";
 import type { BrokerAdapter } from "../../types/broker";
 import { portfolioListPlugin } from "./portfolio-list";
 
@@ -24,6 +27,7 @@ let harnessDispatch: React.Dispatch<AppAction> | null = null;
 let sharedCoordinator: MarketDataCoordinator | null = null;
 let harnessState: ReturnType<typeof createInitialState> | null = null;
 const tempPaths: string[] = [];
+const tempPersistences: AppPersistence[] = [];
 
 const PortfolioPane = portfolioListPlugin.panes![0]!.component as (props: {
   paneId: string;
@@ -154,6 +158,75 @@ function createPortfolioConfigWithColumns(
   }
   return config;
 }
+
+function createManualCollectionConfig(collectionId: string): AppConfig {
+  const config = createDefaultConfig("/tmp/gloomberb-portfolio-list");
+  const layout = {
+    dockRoot: { kind: "pane" as const, instanceId: TEST_PANE_ID },
+    instances: [{
+      instanceId: TEST_PANE_ID,
+      paneId: "portfolio-list",
+      binding: { kind: "none" as const },
+      params: { collectionId },
+    }],
+    floating: [],
+  };
+
+  return {
+    ...config,
+    layout,
+    layouts: [{ name: "Default", layout: cloneLayout(layout) }],
+  };
+}
+
+function installQuickAddRegistry(provider: DataProvider): PluginRegistry {
+  const persistence = new AppPersistence(createTempDbPath("quick-add"));
+  tempPersistences.push(persistence);
+  const registry = new PluginRegistry(provider, new TickerRepository(persistence.tickers), persistence);
+  registry.getConfigFn = () => harnessState?.config ?? createDefaultConfig("/tmp/gloomberb-portfolio-list");
+  return registry;
+}
+
+function createQuickAddProvider(match = true): DataProvider {
+  return {
+    id: "quick-add-test",
+    name: "Quick Add Test",
+    async getTickerFinancials() {
+      return {
+        annualStatements: [],
+        quarterlyStatements: [],
+        priceHistory: [],
+        quote: makeQuote({ symbol: "MSFT", price: 420, change: 5.2, changePercent: 1.25, name: "Microsoft" }),
+      };
+    },
+    async getQuote(symbol) {
+      if (match && symbol === "MSFT") {
+        return makeQuote({ symbol: "MSFT", price: 420, change: 5.2, changePercent: 1.25, name: "Microsoft" });
+      }
+      throw new Error(`No quote for ${symbol}`);
+    },
+    async getExchangeRate() {
+      return 1;
+    },
+    async search(query) {
+      if (!match || query !== "MSFT") return [];
+      return [{
+        symbol: "MSFT",
+        name: "Microsoft",
+        exchange: "NASDAQ",
+        currency: "USD",
+        type: "STK",
+      }];
+    },
+    async getArticleSummary() {
+      return null;
+    },
+    async getPriceHistory() {
+      return [];
+    },
+  };
+}
+
 function createPortfolioState(
   config: AppConfig,
   collectionId: string,
@@ -193,6 +266,7 @@ function PortfolioHarness({
   exchangeRates,
   stateMutator,
   runtime = createTestPluginRuntime(),
+  paneHeight = 24,
 }: {
   config: AppConfig;
   collectionId: string;
@@ -203,6 +277,7 @@ function PortfolioHarness({
   exchangeRates?: Map<string, number>;
   stateMutator?: (state: ReturnType<typeof createInitialState>) => void;
   runtime?: PluginRuntimeAccess;
+  paneHeight?: number;
 }) {
   const initialState = createPortfolioState(config, collectionId, expanded, {
     ticker,
@@ -224,7 +299,7 @@ function PortfolioHarness({
             paneType="portfolio-list"
             focused
             width={100}
-            height={24}
+            height={paneHeight}
           />
         </PluginRenderProvider>
       </PaneInstanceProvider>
@@ -249,7 +324,12 @@ afterEach(async () => {
   harnessDispatch = null;
   sharedCoordinator = null;
   setSharedMarketDataCoordinator(null);
+  setSharedMarketDataForTests(undefined);
+  setSharedRegistryForTests(undefined);
   harnessState = null;
+  for (const persistence of tempPersistences.splice(0)) {
+    persistence.close();
+  }
   for (const path of tempPaths.splice(0)) {
     if (existsSync(path)) rmSync(path, { force: true });
   }
@@ -291,6 +371,151 @@ describe("PortfolioListPane cash and margin UI", () => {
     expect(pinned).toEqual([{ symbol: "AAPL", options: { floating: true, paneType: "ticker-detail" } }]);
   });
 
+  test("quick-add validates and adds an exact watchlist ticker", async () => {
+    const config = createManualCollectionConfig("watchlist");
+    const notifications: Array<{ type?: string; body: string }> = [];
+    installQuickAddRegistry(createQuickAddProvider(true));
+
+    testSetup = await testRender(
+      <PortfolioHarness
+        config={config}
+        collectionId="watchlist"
+        ticker={makeTicker({ portfolios: [], watchlists: [], positions: [] })}
+        runtime={createTestPluginRuntime({
+          notify: (notification) => notifications.push(notification),
+        })}
+        paneHeight={12}
+      />,
+      { width: 100, height: 12 },
+    );
+
+    await flushFrame();
+    await act(async () => {
+      testSetup!.mockInput.pressKey("a");
+      await testSetup!.renderOnce();
+    });
+    await act(async () => {
+      await testSetup!.mockInput.typeText("MSFT");
+      await testSetup!.renderOnce();
+    });
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 360));
+    });
+    await flushFrame();
+
+    const previewFrame = testSetup.captureCharFrame();
+    expect(previewFrame).toContain("420");
+    expect(previewFrame).not.toMatch(/MSFT\s+420/);
+    expect(previewFrame).toContain("+1.25%");
+
+    await act(async () => {
+      testSetup!.mockInput.pressEnter();
+      await Promise.resolve();
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    expect(harnessState?.tickers.get("MSFT")?.metadata.watchlists).toEqual(["watchlist"]);
+    expect(notifications.at(-1)).toMatchObject({
+      type: "success",
+      body: "Added MSFT to Watchlist.",
+    });
+  });
+
+  test("quick-add adds an exact ticker to a manual portfolio", async () => {
+    const config = createManualCollectionConfig("main");
+    const notifications: Array<{ type?: string; body: string }> = [];
+    installQuickAddRegistry(createQuickAddProvider(true));
+
+    testSetup = await testRender(
+      <PortfolioHarness
+        config={config}
+        collectionId="main"
+        ticker={makeTicker({ portfolios: [], watchlists: [], positions: [] })}
+        runtime={createTestPluginRuntime({
+          notify: (notification) => notifications.push(notification),
+        })}
+        paneHeight={12}
+      />,
+      { width: 100, height: 12 },
+    );
+
+    await flushFrame();
+    await act(async () => {
+      testSetup!.mockInput.pressKey("n");
+      await testSetup!.renderOnce();
+    });
+    await act(async () => {
+      await testSetup!.mockInput.typeText("MSFT");
+      await testSetup!.renderOnce();
+    });
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 360));
+    });
+    await flushFrame();
+
+    await act(async () => {
+      testSetup!.mockInput.pressEnter();
+      await Promise.resolve();
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    expect(harnessState?.tickers.get("MSFT")?.metadata.portfolios).toEqual(["main"]);
+    expect(notifications.at(-1)).toMatchObject({
+      type: "success",
+      body: "Added MSFT to Main Portfolio.",
+    });
+  });
+
+  test("quick-add rejects unresolved ticker input", async () => {
+    const config = createManualCollectionConfig("watchlist");
+    const notifications: Array<{ type?: string; body: string }> = [];
+    installQuickAddRegistry(createQuickAddProvider(false));
+
+    testSetup = await testRender(
+      <PortfolioHarness
+        config={config}
+        collectionId="watchlist"
+        ticker={makeTicker({ portfolios: [], watchlists: [], positions: [] })}
+        runtime={createTestPluginRuntime({
+          notify: (notification) => notifications.push(notification),
+        })}
+        paneHeight={12}
+      />,
+      { width: 100, height: 12 },
+    );
+
+    await flushFrame();
+    await act(async () => {
+      testSetup!.mockInput.pressKey("n");
+      await testSetup!.renderOnce();
+    });
+    await act(async () => {
+      await testSetup!.mockInput.typeText("NOPE");
+      await testSetup!.renderOnce();
+    });
+    await act(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 360));
+    });
+    await flushFrame();
+
+    expect(testSetup.captureCharFrame()).toContain("No exact ticker match");
+
+    await act(async () => {
+      testSetup!.mockInput.pressEnter();
+      await Promise.resolve();
+      await testSetup!.renderOnce();
+    });
+    await flushFrame();
+
+    expect(harnessState?.tickers.has("NOPE")).toBe(false);
+    expect(notifications.at(-1)).toMatchObject({
+      type: "error",
+      body: "No exact ticker match",
+    });
+  });
+
   test("keeps non-broker portfolios unchanged", async () => {
     const config = createDefaultConfig("/tmp/gloomberb-portfolio-list");
     const layout = {
@@ -317,6 +542,43 @@ describe("PortfolioListPane cash and margin UI", () => {
     expect(frame).not.toContain("Cash & Margin");
   });
 
+  test("renders one-month sparkline column when price history is loaded", async () => {
+    const config = createPortfolioConfigWithColumns(
+      "broker:ibkr-flex:DU12345",
+      ["ticker", "price", "sparkline"],
+      [createBrokerInstance("flex")],
+    );
+
+    testSetup = await testRender(
+      <PortfolioHarness
+        config={config}
+        collectionId="broker:ibkr-flex:DU12345"
+        stateMutator={(state) => {
+          state.financials = new Map([[
+            "AAPL",
+            {
+              annualStatements: [],
+              quarterlyStatements: [],
+              quote: makeQuote(),
+              priceHistory: [118, 121, 119, 124, 127, 126, 130].map((close, index) => ({
+                date: `2026-03-${20 + index}T00:00:00Z` as unknown as Date,
+                close,
+              })),
+            },
+          ]]);
+        }}
+      />,
+      { width: 100, height: 12 },
+    );
+
+    await flushFrame();
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("1M");
+    const row = frame.split("\n").find((line) => line.includes("AAPL")) ?? "";
+    expect(row).toMatch(/[\u2800-\u28ff]/);
+  });
+
   test("keeps native price and avg cost while converting market value and pnl to base currency", async () => {
     const portfolioId = "broker:ibkr-flex:DU12345";
     const config = createPortfolioConfigWithColumns(
@@ -738,6 +1000,8 @@ describe("PortfolioListPane cash and margin UI", () => {
       ["ticker", "market_cap", "pe", "forward_pe"],
       [createBrokerInstance("flex")],
     );
+    const seededTicker = makeTicker();
+    const seededQuote = makeQuote();
     let calls = 0;
     let resolveFinancials!: (value: {
       annualStatements: [];
@@ -782,10 +1046,26 @@ describe("PortfolioListPane cash and margin UI", () => {
       },
     };
     sharedCoordinator = new MarketDataCoordinator(provider);
+    const instrument = instrumentFromTicker(seededTicker, seededTicker.metadata.ticker);
+    if (!instrument) throw new Error("expected ticker instrument");
+    sharedCoordinator.primeCachedFinancials([{
+      instrument,
+      financials: {
+        annualStatements: [],
+        quarterlyStatements: [],
+        priceHistory: [],
+        quote: seededQuote,
+      },
+    }]);
     setSharedMarketDataCoordinator(sharedCoordinator);
 
     testSetup = await testRender(
-      <PortfolioHarness config={config} collectionId="broker:ibkr-flex:DU12345" />,
+      <PortfolioHarness
+        config={config}
+        collectionId="broker:ibkr-flex:DU12345"
+        ticker={seededTicker}
+        quote={seededQuote}
+      />,
       { width: 100, height: 12 },
     );
 

package/src/plugins/builtin/quote-monitor.test.tsx

@@ -1,10 +1,13 @@
 import { afterEach, describe, expect, test } from "bun:test";
+import { act } from "react";
 import { testRender } from "../../renderers/opentui/test-utils";
 import type { TickerFinancials } from "../../types/financials";
 import type { TickerRecord } from "../../types/ticker";
 import { createDefaultConfig } from "../../types/config";
 import { AppContext, createInitialState, PaneInstanceProvider } from "../../state/app-context";
 import { QuoteMonitorPane } from "./ticker-detail";
+import { PluginRenderProvider, type PluginRuntimeAccess } from "../plugin-runtime";
+import type { PinTickerOptions } from "../../types/plugin";
 
 let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 
@@ -15,27 +18,57 @@ afterEach(() => {
   }
 });
 
-function createQuoteMonitorHarness() {
-  const config = createDefaultConfig("/tmp/gloomberb-test");
-  (config.layout as typeof config.layout & { docked: Array<{ instanceId: string; columnIndex: number; order: number }> }).docked = [
-    { instanceId: "ticker-detail:main", columnIndex: 0, order: 0 },
-    { instanceId: "quote-monitor:test", columnIndex: 1, order: 0 },
-  ];
-  config.layout.instances.push({
-    instanceId: "quote-monitor:test",
-    paneId: "quote-monitor",
-    title: "MSFT",
-    binding: { kind: "fixed", symbol: "MSFT" },
-  });
+interface PinTickerCall {
+  symbol: string;
+  options?: PinTickerOptions;
+}
 
-  const state = createInitialState(config);
+function makeRuntime(options: {
+  pinCalls?: PinTickerCall[];
+  settingsCalls?: Array<string | undefined>;
+} = {}): PluginRuntimeAccess {
+  return {
+    getMarketData: () => null,
+    getCapability: () => null,
+    getBrokerAdapter: () => null,
+    connectBrokerInstance: async () => {},
+    updateBrokerInstance: async () => {},
+    syncBrokerInstance: async () => {},
+    removeBrokerInstance: async () => {},
+    pinTicker: (symbol, pinOptions) => {
+      options.pinCalls?.push({ symbol, options: pinOptions });
+    },
+    navigateTicker: () => {},
+    selectTicker: () => {},
+    switchTab: () => {},
+    switchPanel: () => {},
+    openCommandBar: () => {},
+    showPane: () => {},
+    hidePane: () => {},
+    openPaneSettings: (paneId) => {
+      options.settingsCalls?.push(paneId);
+    },
+    openPluginCommandWorkflow: () => {},
+    notify: () => {},
+    subscribeResumeState: () => () => {},
+    getResumeState: () => null,
+    setResumeState: () => {},
+    deleteResumeState: () => {},
+    getConfigState: () => null,
+    setConfigState: async () => {},
+    setConfigStates: async () => {},
+    deleteConfigState: async () => {},
+    getConfigStateKeys: () => [],
+  };
+}
 
-  const ticker: TickerRecord = {
+function makeTicker(symbol: string, name: string): TickerRecord {
+  return {
     metadata: {
-      ticker: "MSFT",
+      ticker: symbol,
       exchange: "NASDAQ",
       currency: "USD",
-      name: "Microsoft",
+      name,
       portfolios: [],
       watchlists: [],
       positions: [],
@@ -43,28 +76,71 @@ function createQuoteMonitorHarness() {
       tags: [],
     },
   };
+}
 
-  const financials: TickerFinancials = {
+function makeFinancials(symbol: string, price: number, change: number, changePercent: number): TickerFinancials {
+  return {
     quote: {
-      symbol: "MSFT",
-      price: 356.15,
+      symbol,
+      price,
       currency: "USD",
-      change: -9.82,
-      changePercent: -2.68,
+      change,
+      changePercent,
       lastUpdated: Date.now(),
     },
     annualStatements: [],
     quarterlyStatements: [],
-    priceHistory: [],
+    priceHistory: Array.from({ length: 12 }, (_, index) => ({
+      date: new Date(Date.UTC(2026, 0, index + 1)),
+      close: price - 6 + index,
+    })),
   };
+}
+
+function createQuoteMonitorHarness(options: {
+  symbols?: string[];
+  pinCalls?: PinTickerCall[];
+  settingsCalls?: Array<string | undefined>;
+} = {}) {
+  const symbols = options.symbols ?? ["MSFT"];
+  const config = createDefaultConfig("/tmp/gloomberb-test");
+  (config.layout as typeof config.layout & { docked: Array<{ instanceId: string; columnIndex: number; order: number }> }).docked = [
+    { instanceId: "ticker-detail:main", columnIndex: 0, order: 0 },
+    { instanceId: "quote-monitor:test", columnIndex: 1, order: 0 },
+  ];
+  config.layout.instances.push({
+    instanceId: "quote-monitor:test",
+    paneId: "quote-monitor",
+    title: symbols.join(" · "),
+    binding: { kind: "fixed", symbol: symbols[0]! },
+    settings: {
+      symbol: symbols[0]!,
+      symbols,
+      symbolsText: symbols.join(", "),
+    },
+  });
+
+  const state = createInitialState(config);
 
-  state.tickers = new Map([["MSFT", ticker]]);
-  state.financials = new Map([["MSFT", financials]]);
+  const tickers = [
+    makeTicker("MSFT", "Microsoft"),
+    makeTicker("AAPL", "Apple"),
+  ];
+  state.tickers = new Map(tickers.map((ticker) => [ticker.metadata.ticker, ticker]));
+  state.financials = new Map([
+    ["MSFT", makeFinancials("MSFT", 356.15, -9.82, -2.68)],
+    ["AAPL", makeFinancials("AAPL", 202.12, 3.05, 1.53)],
+  ]);
 
   return (
     <AppContext value={{ state, dispatch: () => {} }}>
       <PaneInstanceProvider paneId="quote-monitor:test">
-        <QuoteMonitorPane paneId="quote-monitor:test" paneType="quote-monitor" focused width={72} height={7} />
+        <PluginRenderProvider pluginId="ticker-detail" runtime={makeRuntime({
+          pinCalls: options.pinCalls,
+          settingsCalls: options.settingsCalls,
+        })}>
+          <QuoteMonitorPane paneId="quote-monitor:test" paneType="quote-monitor" focused width={72} height={7} />
+        </PluginRenderProvider>
       </PaneInstanceProvider>
     </AppContext>
   );
@@ -84,6 +160,63 @@ describe("QuoteMonitorPane", () => {
     expect(frame).toContain("$356.15");
     expect(frame).toContain("-2.68%");
     expect(frame).toContain("-9.82");
+    expect(frame).toMatch(/[⠁-⣿]/);
   });
 
+  test("renders multiple configured tickers", async () => {
+    testSetup = await testRender(createQuoteMonitorHarness({ symbols: ["MSFT", "AAPL"] }), {
+      width: 72,
+      height: 8,
+    });
+
+    await testSetup.renderOnce();
+
+    const frame = testSetup.captureCharFrame();
+    expect(frame).toContain("MSFT");
+    expect(frame).toContain("AAPL");
+    expect(frame).toContain("$356.15");
+    expect(frame).toContain("$202.12");
+  });
+
+  test("opens a ticker detail pane on the second card click", async () => {
+    const pinCalls: PinTickerCall[] = [];
+    testSetup = await testRender(createQuoteMonitorHarness({ pinCalls }), {
+      width: 72,
+      height: 7,
+    });
+
+    await testSetup.renderOnce();
+    const frame = testSetup.captureCharFrame();
+    const row = frame.split("\n").findIndex((line) => line.includes("MSFT"));
+    expect(row).toBeGreaterThanOrEqual(0);
+
+    await act(async () => {
+      await testSetup!.mockMouse.click(3, row);
+      await testSetup!.renderOnce();
+      await testSetup!.mockMouse.click(3, row);
+      await testSetup!.renderOnce();
+    });
+
+    expect(pinCalls).toEqual([{
+      symbol: "MSFT",
+      options: { paneType: "ticker-detail", floating: true },
+    }]);
+  });
+
+  test("opens pane settings when t is pressed", async () => {
+    const settingsCalls: Array<string | undefined> = [];
+    testSetup = await testRender(createQuoteMonitorHarness({ settingsCalls }), {
+      width: 72,
+      height: 7,
+    });
+
+    await testSetup.renderOnce();
+
+    await act(async () => {
+      testSetup!.mockInput.pressKey("t");
+      await testSetup!.renderOnce();
+    });
+
+    expect(settingsCalls).toEqual(["quote-monitor:test"]);
+  });
 });