gloomberb 0.13.3 → 0.14.0

package/src/plugins/builtin/options/view.test.tsx

@@ -1,19 +1,20 @@
 import { afterEach, expect, test } from "bun:test";
 import { act, useState } from "react";
+import { Box } from "../../../ui";
+import { PaneFooterBar, PaneFooterProvider } from "../../../components/layout/pane/footer";
 import type { ScrollBoxRenderable } from "@opentui/core";
 import { takeSavedTextFile, testRender } from "../../../renderers/opentui/test-utils";
 import { exportPaneTable, hasPaneTableExporter } from "../../../state/pane-table-export-registry";
 import { MarketDataCoordinator, setSharedMarketDataCoordinator } from "../../../market-data/coordinator";
-import { AppContext, PaneInstanceProvider, createInitialState } from "../../../state/app/context";
+import { createInitialState } from "../../../state/app/context";
 import { createTestDataProvider } from "../../../test-support/data-provider";
-import { cloneLayout, createDefaultConfig } from "../../../types/config";
 import type { QuoteSubscriptionTarget } from "../../../types/data-provider";
 import type { OptionContract, OptionsChain, Quote, TickerFinancials } from "../../../types/financials";
 import type { TickerRecord } from "../../../types/ticker";
 import { formatExpDate } from "../../../utils/options";
 import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
-import { PluginRenderProvider } from "../../runtime";
 import { OptionsView } from "./view";
+import { TestPaneProvider, createTestTicker, createTestPaneConfig } from "../../../test-support/pane";
 
 const TEST_PANE_ID = "ticker-detail:options-test";
 
@@ -21,20 +22,9 @@ let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
 let setOptionsQuotePrice: ((price: number) => void) | null = null;
 
 function makeTicker(symbol: string): TickerRecord {
-  return {
-    metadata: {
-      ticker: symbol,
-      exchange: "NASDAQ",
-      currency: "USD",
-      name: symbol,
-      assetCategory: "STK",
-      portfolios: [],
-      watchlists: [],
-      positions: [],
-      custom: {},
-      tags: [],
-    },
-  };
+  return createTestTicker(symbol, symbol, {
+    assetCategory: "STK"
+  });
 }
 
 function makeContract(strike: number, side: "C" | "P", atmStrike = 101): OptionContract {
@@ -88,49 +78,52 @@ function makeFinancials(price: number): TickerFinancials {
 function OptionsHarness({
   ticker,
   quotePrice,
+  quoteStale,
+  history,
+  showFooter = false,
   width = 122,
-  onCapture = () => {},
+  height = 14,
+  onCapture = () => { },
 }: {
   ticker: TickerRecord;
   quotePrice?: number;
+  quoteStale?: boolean;
+  history?: TickerFinancials["priceHistory"];
+  showFooter?: boolean;
   width?: number;
+  height?: number;
   onCapture?: (capturing: boolean) => void;
 }) {
-  const config = createDefaultConfig("/tmp/gloomberb-options-test");
-  config.layout = {
-    dockRoot: { kind: "pane", instanceId: TEST_PANE_ID },
-    instances: [{
-      instanceId: TEST_PANE_ID,
-      paneId: "ticker-detail",
-      binding: { kind: "fixed", symbol: ticker.metadata.ticker },
-    }],
-    floating: [],
-    detached: [],
-  };
-  config.layouts = [{ name: "Default", layout: cloneLayout(config.layout) }];
+  const config = createTestPaneConfig("/tmp/gloomberb-options-test", {
+    instanceId: TEST_PANE_ID,
+    paneId: "ticker-detail",
+    binding: { kind: "fixed", symbol: ticker.metadata.ticker },
+  });
 
   const state = createInitialState(config);
   state.focusedPaneId = TEST_PANE_ID;
   state.tickers = new Map([[ticker.metadata.ticker, ticker]]);
   if (quotePrice != null) {
-    state.financials = new Map([[ticker.metadata.ticker, makeFinancials(quotePrice)]]);
+    const financials = makeFinancials(quotePrice);
+    financials.quote.stale = quoteStale;
+    if (history) financials.priceHistory = history;
+    state.financials = new Map([[ticker.metadata.ticker, financials]]);
   }
 
   return (
-    <AppContext value={{ state, dispatch: () => {} }}>
-      <PaneInstanceProvider paneId={TEST_PANE_ID}>
-        <PluginRenderProvider pluginId="ticker-research" runtime={createTestPluginRuntime()}>
-          <OptionsView width={width} height={14} focused onCapture={onCapture} />
-        </PluginRenderProvider>
-      </PaneInstanceProvider>
-    </AppContext>
+    <TestPaneProvider state={state} paneId={TEST_PANE_ID} pluginId="ticker-research" runtime={createTestPluginRuntime()}>
+      {showFooter ? <PaneFooterProvider>{(footer) => <Box width={width} height={height} flexDirection="column">
+        <Box width={width} height={height - 1}><OptionsView width={width} height={height - 1} focused onCapture={onCapture} /></Box>
+        <PaneFooterBar footer={footer} focused width={width} />
+      </Box>}</PaneFooterProvider> : <OptionsView width={width} height={height} focused onCapture={onCapture} />}
+    </TestPaneProvider>
   );
 }
 
 function RealtimeOptionsHarness({ ticker }: { ticker: TickerRecord }) {
   const [quotePrice, setQuotePrice] = useState(120.2);
   setOptionsQuotePrice = setQuotePrice;
-  return <OptionsHarness ticker={ticker} quotePrice={quotePrice} />;
+  return <OptionsHarness ticker={ticker} quotePrice={quotePrice} height={20} />;
 }
 
 async function renderSettled() {
@@ -204,6 +197,38 @@ test("defaults the table around the nearest strike to the current quote", async
   expect(frame).not.toContain(" 50 ");
 });
 
+test("keeps table geometry and scroll steady while a cold expiry loads", async () => {
+  const firstExpiry = 1_782_345_600;
+  const nextExpiry = firstExpiry + 7 * 86400;
+  const initial = makeChain(Array.from({ length: 100 }, (_, index) => 50 + index), 120, [firstExpiry, nextExpiry]);
+  let finishNext!: (chain: OptionsChain) => void;
+  const next = new Promise<OptionsChain>((resolve) => { finishNext = resolve; });
+  const provider = createTestDataProvider({
+    getOptionsChain: async (_symbol, _exchange, expiration) => expiration === nextExpiry ? next : initial,
+  });
+  setSharedMarketDataCoordinator(new MarketDataCoordinator(provider));
+  await act(async () => {
+    testSetup = await testRender(<OptionsHarness ticker={makeTicker("AAPL")} quotePrice={120} />, { width: 124, height: 16 });
+  });
+  await renderSettled();
+  const tableHeight = () => (testSetup!.renderer.root.findDescendantById("options-table-body-scroll") as ScrollBoxRenderable).height;
+  const before = tableHeight();
+  await act(async () => { testSetup!.mockInput.pressEnter(); });
+  await renderSettled();
+  await act(async () => { testSetup!.mockInput.pressKey("l"); });
+  await renderSettled();
+  expect(testSetup!.captureCharFrame()).toContain("Loading strikes");
+  expect(tableHeight()).toBe(before);
+  await act(async () => { finishNext({ ...initial,
+    calls: initial.calls.map((c) => ({ ...c, expiration: nextExpiry, contractSymbol: c.contractSymbol.replace("260619", "260626") })),
+    puts: initial.puts.map((c) => ({ ...c, expiration: nextExpiry, contractSymbol: c.contractSymbol.replace("260619", "260626") })),
+  }); });
+  await renderSettled();
+  expect(tableHeight()).toBe(before);
+  expect(testSetup!.captureCharFrame()).not.toContain("Loading strikes");
+  expect((testSetup!.renderer.root.findDescendantById("options-table-body-scroll") as ScrollBoxRenderable).scrollTop).toBeGreaterThan(0);
+});
+
 test("shows volatility statistics and mirrored default Greeks", async () => {
   const provider = createTestDataProvider({
     getOptionsChain: async () => makeChain([100, 101], 101),
@@ -250,13 +275,15 @@ test("streams live quotes without resetting manual scroll", async () => {
       <RealtimeOptionsHarness ticker={makeTicker("AAPL")} />,
       {
         width: 124,
-        height: 16,
+        height: 22,
       },
     );
   });
   await renderSettled();
 
-  const targets = subscriptions.at(-1) ?? [];
+  const subscribedTargets = subscriptions.at(-1) ?? [];
+  expect(subscribedTargets.some((target) => target.symbol === "AAPL" && target.exchange !== "OPTIONS")).toBe(true);
+  const targets = subscribedTargets.filter((target) => target.exchange === "OPTIONS");
   expect(targets.length).toBeGreaterThan(16);
   expect(targets.length).toBeLessThanOrEqual(80);
   expect(targets.filter((target) => target.visible === true).length).toBeGreaterThan(16);
@@ -276,6 +303,8 @@ test("streams live quotes without resetting manual scroll", async () => {
       providerId: "gloomberb-cloud",
       price: 99.9,
       mark: 99.99,
+      lastTradePrice: 99.9,
+      lastTradeTime: Date.now(),
       bid: 99.98,
       ask: 100,
       currency: "USD",
@@ -297,7 +326,7 @@ test("streams live quotes without resetting manual scroll", async () => {
       exchange: "OPTIONS",
     }).data?.mark,
   ).toBe(99.99);
-  expect(testSetup!.captureCharFrame()).toContain("99.99");
+  expect(testSetup!.captureCharFrame()).toContain("99.9");
 
   const bodyScroll = testSetup!.renderer.root.findDescendantById("options-table-body-scroll") as ScrollBoxRenderable;
   await act(async () => {
@@ -314,6 +343,32 @@ test("streams live quotes without resetting manual scroll", async () => {
   expect(bodyScroll.scrollTop).toBe(0);
 });
 
+test("a standalone chain subscribes to its underlying and resolves ATM without a research pane", async () => {
+  let targets: QuoteSubscriptionTarget[] = [];
+  let emit: ((target: QuoteSubscriptionTarget, quote: Quote) => void) | undefined;
+  const provider = createTestDataProvider({
+    getTickerFinancials: async () => ({ annualStatements: [], quarterlyStatements: [], priceHistory: [] }),
+    getOptionsChain: async () => makeChain(Array.from({ length: 100 }, (_, index) => 50 + index), 120),
+    subscribeQuotes: (nextTargets, onQuote) => {
+      targets = nextTargets;
+      emit = onQuote;
+      return () => {};
+    },
+  });
+  setSharedMarketDataCoordinator(new MarketDataCoordinator(provider));
+  await act(async () => {
+    testSetup = await testRender(<OptionsHarness ticker={makeTicker("AAPL")} />, { width: 124, height: 16 });
+  });
+  await renderSettled();
+  const underlying = targets.find((target) => target.symbol === "AAPL");
+  expect(underlying).toBeDefined();
+  await act(async () => { emit!(underlying!, makeFinancials(120.2).quote!); });
+  await renderSettled();
+  const scrollBox = testSetup!.renderer.root.findDescendantById("options-table-body-scroll") as ScrollBoxRenderable;
+  expect(scrollBox.scrollTop).toBeGreaterThan(0);
+  expect(testSetup!.captureCharFrame()).toContain("ATM IV 20.0%");
+});
+
 test("lets the expiration tab row use the full available width", async () => {
   const expirationDates = Array.from({ length: 9 }, (_, index) => (
     Math.floor(Date.UTC(2026, index, 20) / 1000)
@@ -347,7 +402,11 @@ test("keeps expiration tabs independently scrollable from a narrow strike table"
   const provider = createTestDataProvider({
     getOptionsChain: async (_ticker, _exchange, expirationDate) => {
       requestedExpirations.push(expirationDate);
-      return makeChain([100, 101], 101, expirationDates);
+      const chain = makeChain([100, 101], 101, expirationDates);
+      for (const contract of [...chain.calls, ...chain.puts]) {
+        contract.expiration = expirationDate ?? expirationDates[0]!;
+      }
+      return chain;
     },
   });
   setSharedMarketDataCoordinator(new MarketDataCoordinator(provider));
@@ -434,3 +493,172 @@ test("clicking the option table focuses expiration tabs for arrow navigation", a
 
   expect(requestedExpirations).toContain(expirationDates[1]);
 });
+
+test("starts at a held contract's expiry and preserves a researcher-selected roll expiry", async () => {
+  const expirationDates = [Date.UTC(2026, 8, 18), Date.UTC(2026, 9, 16), Date.UTC(2026, 10, 20)]
+    .map((ms) => ms / 1000);
+  const requestedExpirations: Array<number | undefined> = [];
+  const provider = createTestDataProvider({
+    getTickerFinancials: async () => makeFinancials(326.72),
+    getOptionsChain: async (_ticker, _exchange, expirationDate) => {
+      if (_ticker === "MSFT") return new Promise<OptionsChain>(() => {});
+      requestedExpirations.push(expirationDate);
+      const expiry = expirationDate ?? expirationDates[0]!;
+      const chain = makeChain([330 + expirationDates.indexOf(expiry) * 10], 340, expirationDates);
+      for (const contract of [...chain.calls, ...chain.puts]) contract.expiration = expiry;
+      return chain;
+    },
+  });
+  const coordinator = new MarketDataCoordinator(provider);
+  setSharedMarketDataCoordinator(coordinator);
+  const ticker = makeTicker("AAPL 261016C00340000");
+  ticker.metadata.assetCategory = "OPT";
+  ticker.metadata.positions = [
+    { portfolio: "fixture", shares: 2, side: "short", avgCost: 5.52, broker: "manual", multiplier: 100 },
+    { portfolio: "fixture", shares: -1, avgCost: 5.52, broker: "manual", multiplier: 100 },
+    { portfolio: "fixture", shares: 1, side: "long", avgCost: 5.52, broker: "manual", multiplier: 100 },
+  ];
+  let selectTicker: (ticker: TickerRecord) => void = () => {};
+  function SwitchingHarness() {
+    const [selected, setSelected] = useState(ticker);
+    selectTicker = setSelected;
+    return <OptionsHarness ticker={selected} />;
+  }
+  await act(async () => {
+    testSetup = await testRender(<SwitchingHarness />, { width: 124, height: 16 });
+  });
+  await renderSettled();
+  expect(requestedExpirations.at(-1)).toBe(expirationDates[1]);
+  expect(testSetup!.captureCharFrame()).toContain("Position: -2 call contracts (SHORT)");
+
+  await act(async () => { testSetup!.mockInput.pressEnter(); });
+  await renderSettled();
+  await act(async () => { testSetup!.mockInput.pressArrow("right"); });
+  await renderSettled();
+  expect(requestedExpirations.at(-1)).toBe(expirationDates[2]);
+  expect(testSetup!.captureCharFrame()).toContain("350");
+
+  // A refreshed expiry catalogue must not undo the user's chosen roll date.
+  await act(async () => {
+    await coordinator.loadOptions({ instrument: { symbol: "AAPL", exchange: "" } }, { forceRefresh: true });
+  });
+  await renderSettled();
+  expect(testSetup!.captureCharFrame()).toContain("350");
+  await act(async () => { testSetup!.mockInput.pressArrow("left"); });
+  await renderSettled();
+  expect(testSetup!.captureCharFrame()).toContain("340");
+
+  // Returning before another instrument's catalogue loads must initialize the
+  // holding again, rather than retain that intermediate target's index zero.
+  await act(async () => { selectTicker(makeTicker("MSFT")); });
+  await renderSettled();
+  expect(testSetup!.captureCharFrame()).toContain("Loading options chain");
+  await act(async () => { selectTicker(ticker); });
+  await renderSettled();
+  expect(testSetup!.captureCharFrame()).toMatch(/34\.05\s+0\.3%\s+34\s+.*340/);
+});
+
+test("keeps the selected chain visible when its refresh fails", async () => {
+  let failRefresh = false;
+  const provider = createTestDataProvider({
+    getOptionsChain: async () => {
+      if (failRefresh) throw new Error("Options provider unavailable");
+      return makeChain([100, 101], 101);
+    },
+  });
+  const coordinator = new MarketDataCoordinator(provider);
+  setSharedMarketDataCoordinator(coordinator);
+  await act(async () => {
+    testSetup = await testRender(
+      <OptionsHarness ticker={makeTicker("AAPL")} quotePrice={101} />,
+      { width: 124, height: 16 },
+    );
+  });
+  await renderSettled();
+  failRefresh = true;
+  await act(async () => {
+    const entry = await coordinator.loadOptions({ instrument: { symbol: "AAPL", exchange: "NASDAQ" }, expirationDate: 1_782_345_600 }, { forceRefresh: true });
+    expect(entry.error?.message).toContain("Options provider unavailable");
+  });
+  await renderSettled();
+  const frame = testSetup!.captureCharFrame();
+  expect(frame).toContain("C LAST");
+  expect(frame).toContain("101");
+  expect(frame).not.toContain("Options chain unavailable.");
+});
+
+
+test("stale underlying preserves contract observations but cannot seed current Greeks or calculator", async () => {
+  const provider = createTestDataProvider({ getOptionsChain: async () => makeChain([100, 101], 101) });
+  setSharedMarketDataCoordinator(new MarketDataCoordinator(provider));
+  let setStale!: (value: boolean) => void;
+  function FreshnessHarness() {
+    const [stale, updateStale] = useState(true);
+    setStale = updateStale;
+    return <OptionsHarness ticker={makeTicker("AAPL")} quotePrice={101} quoteStale={stale} showFooter height={20} width={160} />;
+  }
+  await act(async () => {
+    testSetup = await testRender(<FreshnessHarness />, { width: 160, height: 20 });
+  });
+  await renderSettled();
+  const frame = testSetup!.captureCharFrame();
+  if (process.env.OPTIONS_AUDIT_EVIDENCE) await Bun.write(`${process.env.OPTIONS_AUDIT_EVIDENCE}/stale-underlying.txt`, frame);
+  expect(frame).toContain("ATM IV —");
+  expect(frame).toContain("Underlying quote stale");
+  expect(frame).not.toContain("[c]alc");
+  await exportPaneTable(TEST_PANE_ID, "stale-options.csv");
+  const saved = takeSavedTextFile()!.text;
+  if (process.env.OPTIONS_AUDIT_EVIDENCE) await Bun.write(`${process.env.OPTIONS_AUDIT_EVIDENCE}/stale-underlying.csv`, saved);
+  const lines = saved.trim().split("\n").map((line) => line.split(","));
+  const deltaColumns = lines[0]!.flatMap((cell, i) => cell.includes("Δ") ? [i] : []);
+  expect(deltaColumns).toHaveLength(2);
+  for (const row of lines.slice(1)) for (const i of deltaColumns) expect(row[i]).toBe("—");
+  expect(saved).toContain("10.05,10.15,1.0%,10.1");
+  await act(async () => { setStale(false); });
+  await renderSettled();
+  const recovered = testSetup!.captureCharFrame();
+  expect(recovered).toContain("ATM IV 20.0%");
+  expect(recovered).toContain("[c]alc");
+  expect(recovered).not.toContain("Underlying quote stale");
+  if (process.env.OPTIONS_AUDIT_EVIDENCE) await Bun.write(`${process.env.OPTIONS_AUDIT_EVIDENCE}/underlying-recovery.txt`, recovered);
+});
+
+
+test("rejected history disables HV and IV/HV without discarding healthy chain analytics", async () => {
+  const provider = createTestDataProvider({ getOptionsChain: async () => makeChain([100, 101], 101) });
+  setSharedMarketDataCoordinator(new MarketDataCoordinator(provider));
+  const history = Array.from({ length: 31 }, (_, i) => ({
+    date: new Date(Date.UTC(2026, 0, i + 1)), close: 100 + i % 2,
+    ...(i === 15 ? { high: 90, low: 110 } : {}),
+  }));
+  await act(async () => {
+    testSetup = await testRender(<OptionsHarness ticker={makeTicker("AAPL")} quotePrice={101} history={history} showFooter height={20} width={160} />, { width: 160, height: 20 });
+  });
+  await renderSettled();
+  const frame = testSetup!.captureCharFrame();
+  if (process.env.OPTIONS_AUDIT_EVIDENCE) await Bun.write(`${process.env.OPTIONS_AUDIT_EVIDENCE}/rejected-history.txt`, frame);
+  expect(frame).toContain("ATM IV 20.0%");
+  expect(frame).toContain("HV30 —");
+  expect(frame).toContain("IV/HV —");
+  expect(frame).toContain("HV30 unavailable: inconsistent OHLC history");
+  expect(frame).toContain("[c]alc");
+});
+
+test("reports the contract under the cursor in the status bar instead of above the chain", async () => {
+  const provider = createTestDataProvider({ getOptionsChain: async () => makeChain([100, 101], 101) });
+  setSharedMarketDataCoordinator(new MarketDataCoordinator(provider));
+  await act(async () => {
+    testSetup = await testRender(<OptionsHarness ticker={makeTicker("AAPL")} quotePrice={101} showFooter height={20} width={160} />, { width: 160, height: 20 });
+  });
+  await renderSettled();
+  const lines = testSetup!.captureCharFrame().split("\n");
+  const status = lines.find((line) => line.includes("[c]alc"))!;
+  const body = lines.filter((line) => line !== status).join("\n");
+  expect(status).toContain("AAPL260619C00101000");
+  // Identity, bid, ask, last and the expiry all already exist above or in the
+  // chain, so the body must not spend rows repeating them.
+  expect(body).not.toContain("AAPL260619C00101000");
+  // The spread reads per strike in its own column, so the status bar drops it.
+  expect(body).toContain("C SPRD");
+  expect(status).not.toContain("spread");
+});