gloomberb 0.15.2 → 0.15.4

package/src/plugins/builtin/relative-rotation/model.test.ts

@@ -1,194 +0,0 @@
-import { publishedWeekClose } from "../analytics/sharpe-cadence";
-import { expect, test } from "bun:test";
-import {
-  buildRotation,
-  rotationCloses,
-  rotationInstruments,
-  rotationQuadrant,
-  rotationTrailWeeks,
-  type RotationHistory,
-} from "./model";
-import { fetchRotation, validateRotationHistory } from "./client";
-const DAY = 86_400_000;
-const benchmark = { symbol: "SPY", exchange: "NYSEARCA", label: "SPY" };
-function history(symbol: string, ratios: number[]): RotationHistory {
-  return {
-    instrument: { ...benchmark, symbol, label: symbol },
-    currency: "USD",
-    asOf: null,
-    stale: false,
-    error: null,
-    points: ratios.map((value, index) => ({
-      date: publishedWeekClose(
-        new Date(Date.parse("2025-01-03") + index * 7 * DAY)
-          .toISOString()
-          .slice(0, 10),
-        "ARCA",
-      )!,
-      close: value * 100,
-    })),
-  };
-}
-test("relative normalization has scale invariance, stable neutral baseline and no use of incomplete weeks", () => {
-  const reference = history("SPY", Array(90).fill(1)),
-    asset = history("XLK", Array(90).fill(2));
-  const data = buildRotation(
-      reference,
-      [asset],
-      6,
-      new Date("2026-09-22T12:00:00Z"),
-    ),
-    row = data.rows[0]!;
-  expect(row.strength).toBe(100);
-  expect(row.momentum).toBe(100);
-  expect(row.quadrant).toBe("Neutral");
-  expect(row.strengthRank.percentile).toBe(50);
-  expect(row.trail).toHaveLength(6);
-  reference.points.push({ date: "2026-09-21", close: 100 });
-  asset.points.push({ date: "2026-09-21", close: 1000 });
-  expect(
-    buildRotation(reference, [asset], 6, new Date("2026-09-22T12:00:00Z"))
-      .rows[0]!.strength,
-  ).toBe(100);
-  expect(rotationQuadrant(101, 99)).toBe("Weakening");
-  expect(rotationQuadrant(99, 101)).toBe("Improving");
-});
-test("missing matched sessions and contradictory duplicates break continuity instead of crossing gaps", () => {
-  const ratios = Array.from({ length: 90 }, (_, i) => 1 + i * 0.01),
-    asset = history("XLK", ratios),
-    reference = history("SPY", Array(90).fill(1));
-  const before = buildRotation(reference, [asset], 6, new Date("2026-09-22"));
-  expect(before.rows[0]!.strength).toBeGreaterThan(100);
-  asset.points.splice(87, 1);
-  const missing = buildRotation(reference, [asset], 6, new Date("2026-09-22"))
-    .rows[0]!;
-  expect(missing.strength).toBeNull();
-  expect(missing.trail).toEqual([]);
-  const date = reference.points.at(-1)!.date;
-  expect(
-    rotationCloses(
-      [
-        { date, close: 1 },
-        { date, close: 2 },
-      ],
-      "2026-09-22",
-    ).size,
-  ).toBe(0);
-  expect(rotationCloses([{ date, close: 0 }], "2026-09-22").size).toBe(0);
-});
-test("currency mismatch, short history and no-lookahead ranks stay explicit", () => {
-  const reference = history("SPY", Array(90).fill(1)),
-    asset = history(
-      "XLK",
-      Array.from({ length: 90 }, (_, i) => 1 + i * 0.01),
-    );
-  asset.currency = "EUR";
-  expect(
-    buildRotation(reference, [asset], 6, new Date("2026-09-22")).rows[0]!
-      .strength,
-  ).toBeNull();
-  asset.currency = "USD";
-  asset.points = asset.points.slice(-17);
-  const row = buildRotation(reference, [asset], 6, new Date("2026-09-22"))
-    .rows[0]!;
-  expect(row.momentum).not.toBeNull();
-  expect(row.momentumRank.percentile).toBeNull();
-  expect(row.momentumRank.samples).toBe(1);
-  const limited = buildRotation(reference, [asset], 6, new Date("2026-07-01"));
-  expect(
-    limited.rows[0]!.history.every((point) => point.date < "2026-07-01"),
-  ).toBe(true);
-});
-test("Cloud boundary rejects intraday masquerading as daily data and invalid custom scope", () => {
-  expect(() =>
-    validateRotationHistory({
-      status: "success",
-      data: [{ date: "2026-09-21", close: 1 }],
-      providerMeta: { servedResolution: "15min" },
-    }),
-  ).toThrow("daily bars");
-  expect(() =>
-    validateRotationHistory({
-      status: "success",
-      data: [{ date: "2026-09-21", close: NaN }],
-    }),
-  ).toThrow("Invalid daily");
-  expect(rotationInstruments("AAPL:NASDAQ AAPL,AAPL:NASDAQ")).toHaveLength(2);
-  expect(() =>
-    rotationInstruments(
-      Array.from({ length: 25 }, (_, i) => `S${i}`).join(","),
-    ),
-  ).toThrow("at most");
-});
-
-test("Cloud currency and listing provenance cannot be overridden by a valid quote", async () => {
-  const reference = history("SPY", Array(90).fill(1)),
-    asset = history("XLK", Array(90).fill(2));
-  const data = await fetchRotation(
-    reference.instrument,
-    [asset.instrument],
-    6,
-    {
-      getCloudQuotesBatch: async () => ({
-        status: "success",
-        data: {
-          items: [reference, asset].map((row) => ({
-            symbol: row.instrument.symbol,
-            exchange: "NYSEARCA",
-            status: "success",
-            data: { currency: "USD" } as any,
-          })),
-        },
-      }),
-      getCloudHistory: async (symbol) => ({
-        status: "success",
-        currency: symbol === "XLK" ? "EUR" : "USD",
-        data: symbol === "XLK" ? asset.points : reference.points,
-      }),
-    },
-    new Date("2026-09-22"),
-  );
-  expect(data.rows[0]!.strength).toBeNull();
-  expect(data.rows[0]!.gaps.join(" ")).toContain("currency does not match");
-  expect(() =>
-    validateRotationHistory(
-      {
-        status: "success",
-        data: asset.points,
-        providerMeta: { normalizedSymbol: "XLF" },
-      },
-      asset.instrument,
-      "USD",
-    ),
-  ).toThrow("listing identity");
-});
-
-test("calendar gaps, canonical aliases and screenshot trail settings stay consistent", () => {
-  expect(publishedWeekClose("2026-07-03", "NYSEARCA")).toBe("2026-07-02");
-  expect(publishedWeekClose("2026-09-18", "NYSEARCA")).toBe("2026-09-18");
-  expect(publishedWeekClose("2026-09-18", "LSE")).toBeNull();
-  expect(rotationInstruments("SPY:NYSEARCA SPY:ARCA")).toHaveLength(1);
-  expect(rotationTrailWeeks(3)).toBe(3);
-  const reference = history("SPY", Array(90).fill(1)),
-    asset = history("XLK", Array(90).fill(2));
-  reference.points.at(-1)!.date = "2026-09-17";
-  asset.points.at(-1)!.date = "2026-09-17";
-  const data = buildRotation(reference, [asset], 3, new Date("2026-09-22"));
-  expect(data.asOf).not.toBe("2026-09-17");
-  expect(data.gaps.join(" ")).toContain(
-    "missing its verified 2026-09-18 close",
-  );
-  asset.currency = "EUR";
-  const mismatched = buildRotation(
-    reference,
-    [asset],
-    3,
-    new Date("2026-09-22"),
-  ).rows[0]!;
-  expect(
-    mismatched.history.every(
-      (point) => point.strength == null && point.momentum == null,
-    ),
-  ).toBe(true);
-  expect(mismatched.strengthRank.samples).toBe(0);
-});

package/src/plugins/builtin/research/analyst-headless.test.ts

@@ -1,88 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { createTestDataProvider } from "../../../test-support/data-provider";
-import { createDefaultConfig } from "../../../types/config";
-import type { AnalystResearchData } from "../../../types/financials";
-import type { HeadlessPaneContext, HeadlessPaneLoadArgs } from "../../../types/plugin";
-import { createAnalystResearchHeadless } from "./analyst-headless";
-
-const data: AnalystResearchData = {
-  symbol: "AMD",
-  currency: "USD",
-  priceTarget: { current: 150, average: 180, low: 120, median: 175, high: 230 },
-  recommendationRating: 8.4,
-  recommendations: [{ period: "current month", strongBuy: 10, buy: 8, hold: 4, sell: 1 }],
-  ratings: [
-    { date: "2026-08-20", firm: "Beta", action: "Maintains", current: "Buy", currentPriceTarget: 190 },
-    { date: "2026-08-25", firm: "Alpha", action: "Raises", current: "Buy", prior: "Hold", currentPriceTarget: 210, priorPriceTarget: 180 },
-  ],
-  earningsEstimates: [],
-  revenueEstimates: [],
-};
-
-function context(): HeadlessPaneContext {
-  return {
-    marketData: createTestDataProvider(),
-    apiClient: {} as HeadlessPaneContext["apiClient"],
-    config: createDefaultConfig("/tmp/gloomberb-headless-analyst"),
-    signal: new AbortController().signal,
-  };
-}
-
-function args(overrides: Partial<HeadlessPaneLoadArgs["options"]> = {}): HeadlessPaneLoadArgs {
-  return {
-    rawArgument: "AMD",
-    argument: "AMD",
-    symbols: ["AMD"],
-    options: { sort: "date", order: "desc", limit: 25, ...overrides },
-  };
-}
-
-describe("analyst research headless model", () => {
-  test("keeps an explicit zero target distinct from missing data and exposes stale reference prices", async () => {
-    const headless = createAnalystResearchHeadless({ loadData: async () => ({ ...data,
-      stale: true, fetchedAt: "2026-09-09T16:00:00Z", priceTarget: { average: 0, current: 2, currency: "USD" },
-    }) });
-    const result = await headless.load(args(), context());
-    expect(result.sections[0]?.entries?.slice(0, 3)).toMatchObject([
-      { label: "Average target", value: 0 }, { label: "Target upside", value: -1 }, { label: "Upside reference price", value: 2 },
-    ]);
-    expect(result.errors).toEqual(["Analyst research is stale"]);
-    expect(result.metadata).toMatchObject({ stale: true, fetchedAt: "2026-09-09T16:00:00Z" });
-  });
-  test("projects summary and ratings while applying sort and limit", async () => {
-    const headless = createAnalystResearchHeadless({ loadData: async () => data });
-
-    const latest = await headless.load(args({ limit: 1 }), context());
-    expect(latest.sections[0]?.title).toBe("Summary");
-    const entries = "entries" in latest.sections[0]! ? latest.sections[0]!.entries : [];
-    expect(entries.slice(0, 2)).toMatchObject([
-      { label: "Average target", value: 180 },
-      { label: "Target upside", value: 0.2 },
-    ]);
-    expect(latest.sections[1]).toMatchObject({
-      title: "Recent analyst actions",
-      rows: [{ firm: "Alpha", currentPriceTarget: 210, priorPriceTarget: 180 }],
-    });
-
-    const byFirm = await headless.load(args({ sort: "firm", order: "desc", limit: 2 }), context());
-    const ratings = "rows" in byFirm.sections[1]! ? byFirm.sections[1]!.rows : [];
-    expect(ratings.map((row) => row.firm)).toEqual(["Beta", "Alpha"]);
-  });
-});
-
-test("default analyst loader keeps remembered venue and returns unknown currency/counts without defaults", async () => {
-  const calls: Array<[string, string | undefined]> = [];
-  const headless = createAnalystResearchHeadless();
-  const ctx = context();
-  ctx.resolveInstrument = async (symbol) => ({ symbol, exchange: "LSE" });
-  ctx.marketData = createTestDataProvider({ getAnalystResearch: async (symbol, exchange) => {
-    calls.push([symbol, exchange]);
-    return { ...data, symbol, currency: undefined, priceTarget: { average: 0, current: 2 }, recommendations: [] };
-  } });
-  const result = await headless.load(args(), ctx);
-  expect(calls).toEqual([["AMD", "LSE"]]);
-  expect(result.metadata?.currency).toBeNull();
-  expect(result.sections[0]?.entries?.[0]).toMatchObject({ value: 0, formatted: "0.00 (ccy?)" });
-  expect(result.sections[0]?.entries?.find((entry) => entry.label === "Analysts")?.value).toBeNull();
-  expect(result.sections[1]?.rows?.[0]?.currency).toBeNull();
-});

package/src/plugins/builtin/research/analyst-model.test.ts

@@ -1,125 +0,0 @@
-import { expect, test } from "bun:test";
-import type { AnalystRatingRecord, AnalystResearchData, Quote } from "../../../types/financials";
-import { analystReferencePrice, analystTargetCurrency, buildAnalystFooterInfo, buildAnalystStatusSegments, buildAnalystTargetHistory, formatAnalystPrice, formatRecommendationMix, latestRecommendation, recommendationMix, recommendationTotal, targetUpside } from "./analyst-model";
-const data: AnalystResearchData = { symbol: "FIX", recommendations: [], ratings: [], earningsEstimates: [], revenueEstimates: [] };
-const complete = { period: "current month", strongBuy: 2, buy: 3, hold: 4, sell: 0, strongSell: 0 };
-
-test("unknown and explicit minor units format without a currency or scale guess", () => {
-  expect(formatAnalystPrice(0, undefined)).toBe("0.00 (ccy?)");
-  expect(formatAnalystPrice(125, "GBp")).toBe("£1.25");
-  expect(formatAnalystPrice(1.25, "GBP")).toBe("£1.25");
-  expect(formatAnalystPrice(Infinity, "USD")).toBe("-");
-  expect(analystTargetCurrency({ ...data, currency: " GBP ", priceTarget: { currency: " " } })).toBe("GBP");
-  expect(analystTargetCurrency({ ...data, currency: "USD", priceTarget: { currency: " EUR " } })).toBe("EUR");
-  expect(targetUpside({ average: 0, current: 2 })).toBe(-1);
-});
-
-test("consensus total requires every finite nonnegative integer bucket", () => {
-  expect(recommendationTotal(data)).toBeNull();
-  expect(recommendationTotal({ ...data, recommendations: [complete] })).toBe(9);
-  for (const strongSell of [undefined, -1, NaN, Infinity, 0.5]) {
-    const incomplete = { ...data, recommendations: [{ ...complete, strongSell }] };
-    expect(recommendationTotal(incomplete)).toBeNull();
-    expect(recommendationMix(incomplete)?.strongSell).toBeNull();
-    expect(formatRecommendationMix(incomplete)).toBe("SB 2  B 3  H 4  S -");
-  }
-  expect(recommendationTotal({ ...data, recommendations: [{ ...complete, strongBuy: 0, buy: 0, hold: 0 }] })).toBe(0);
-});
-
-test("status segments name an older mix's period and never claim fresh stale data", () => {
-  const research: AnalystResearchData = {
-    ...data,
-    currency: "USD",
-    priceTarget: { current: 467.5, average: 472.17, low: 225, median: 482.5, high: 625, currency: "USD" },
-    recommendationRating: 8.8,
-    fetchedAt: new Date(Date.now() - 7_200_000).toISOString(),
-    recommendations: [complete],
-  };
-  const text = (research: AnalystResearchData) => buildAnalystStatusSegments(research)
-    .map((segment) => segment.parts.map((part) => part.text).join(" ")).join(" · ");
-
-  expect(text(research)).toBe(
-    "low $225.00 med $482.50 high $625.00 · rating 8.8/10 · SB 2  B 3  H 4  S 0 9 analysts"
-    + " · upside vs $467.50 · fetched 2h ago",
-  );
-  expect(text({ ...research, recommendations: [{ ...complete, period: "previous month" }] }))
-    .toContain("9 analysts (prev month)");
-  const stale = text({ ...research, stale: true });
-  expect(stale.startsWith("stale · ")).toBe(true);
-  expect(stale).not.toContain("fetched");
-
-  // A narrow pane drops whole segments instead of shrinking them into stubs,
-  // and a failure keeps its room ahead of the context.
-  const info = (width: number, error: string | null = null) =>
-    buildAnalystFooterInfo(research, { width, loading: false, error })
-      .map((segment) => segment.parts.map((part) => part.text).join(" "));
-  expect(info(200)).toHaveLength(5);
-  expect(info(60)).toEqual(["low $225.00 med $482.50 high $625.00", "rating 8.8/10"]);
-  expect(info(60, "provider down")).toEqual(["provider down", "low $225.00 med $482.50 high $625.00"]);
-});
-
-test("rebuilt target history dates one point per publishing day and ages firms out", () => {
-  const rating = (date: string, firm: string, currentPriceTarget?: number): AnalystRatingRecord => ({
-    date,
-    firm,
-    ...(currentPriceTarget == null ? {} : { currentPriceTarget }),
-    // An undated prior must never reach the mean.
-    priorPriceTarget: 999,
-  });
-  // Newest first, the order the source serves.
-  const ratings = [
-    rating("2026-05-10", "Zenith", 120),
-    rating("2026-05-10", "zenith ", 110),
-    rating("2026-05-10", "Beta", 60),
-    rating("2026-03-01", "No Target"),
-    rating("2026-03-01", "Zenith", 90),
-    rating("2026-02-01", "Beta", 30),
-    rating("2025-03-01", "Alpha", 300),
-  ];
-
-  // Alpha holds its target until it leaves the window before 2026-05-10, and
-  // Zenith's two rows of one day collapse into the one served first.
-  expect(buildAnalystTargetHistory(ratings, { minFirms: 2 })).toEqual([
-    { date: "2026-02-01", average: 165, firms: 2 },
-    { date: "2026-03-01", average: 140, firms: 3 },
-    { date: "2026-05-10", average: 90, firms: 2 },
-  ]);
-  expect(buildAnalystTargetHistory(ratings, { minFirms: 3 })).toEqual([
-    { date: "2026-03-01", average: 140, firms: 3 },
-  ]);
-  expect(buildAnalystTargetHistory(ratings, { minFirms: 2, windowDays: 7 })).toEqual([
-    { date: "2026-05-10", average: 90, firms: 2 },
-  ]);
-});
-
-test("explicit current month is selected without inventing an observation date", () => {
-  for (const period of ["current month", "current_month", "0m"]) {
-    const current = { ...complete, period };
-    expect(latestRecommendation({ ...data, recommendations: [{ ...complete, period: "previous month" }, current] })).toBe(current);
-  }
-  const historical = { ...complete, period: "previous month" };
-  expect(latestRecommendation({ ...data, recommendations: [historical] })).toBe(historical);
-});
-
-test("upside follows the live price only when it is quoted in the target's currency", () => {
-  const research: AnalystResearchData = {
-    ...data,
-    currency: "USD",
-    priceTarget: { current: 100, average: 120, currency: "USD" },
-  };
-  const quote = (overrides: Partial<Quote>): Quote => ({
-    symbol: "FIX", price: 110, change: 0, changePercent: 0, currency: "USD", lastUpdated: 1, dataSource: "live", ...overrides,
-  });
-  const live = analystReferencePrice(research, quote({}));
-  expect(live).toEqual({ price: 110, freshness: "real-time", live: true });
-  expect(targetUpside(research.priceTarget, live.price)).toBeCloseTo(120 / 110 - 1);
-  expect(analystReferencePrice(research, quote({ dataSource: "delayed" })).freshness).toBe("15m delayed");
-  // An ADR quoted in another currency, a pence line or a stale quote keep the provider's reference.
-  for (const other of [quote({ currency: "EUR" }), quote({ currency: "GBp" }), quote({ stale: true })]) {
-    expect(analystReferencePrice(research, other)).toEqual({ price: 100, freshness: null, live: false });
-  }
-  const footer = buildAnalystStatusSegments(research, live)
-    .find((segment) => segment.id === "analyst-reference-price")!
-    .parts.map((part) => part.text).join(" ");
-  expect(footer).toBe("upside vs $110.00 real-time");
-});

package/src/plugins/builtin/research/analyst-pane.test.tsx

@@ -1,162 +0,0 @@
-import { afterEach, expect, test } from "bun:test";
-import { act } from "react";
-import { PaneFooterBar, PaneFooterProvider } from "../../../components/layout/pane/footer";
-import { emitKeypress, testRender } from "../../../renderers/opentui/test-utils";
-import { createInitialState } from "../../../state/app/context";
-import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
-import type { AnalystRatingRecord, AnalystResearchData } from "../../../types/financials";
-import type { DataProvider } from "../../../types/data-provider";
-import type { TickerRecord } from "../../../types/ticker";
-import { Box } from "../../../ui";
-import { AnalystResearchView } from "./analyst-pane";
-import { TestPaneProvider, createTestTicker, createTestPaneConfig } from "../../../test-support/pane";
-
-const TEST_PANE_ID = "analyst-research:NKE";
-const WIDTH = 96;
-const HEIGHT = 20;
-
-let testSetup: Awaited<ReturnType<typeof testRender>> | undefined;
-
-const research: AnalystResearchData = {
-  providerId: "test",
-  symbol: "NKE",
-  currency: "USD",
-  priceTarget: { current: 38.4, average: 50.46, low: 23, median: 46.5, high: 94, currency: "USD" },
-  recommendationRating: 6.1,
-  recommendations: [],
-  ratings: [
-    {
-      date: "2026-08-26",
-      firm: "Truist Securities",
-      action: "Downgrade",
-      current: "Hold",
-      prior: "Buy",
-      currentPriceTarget: 42,
-      priorPriceTarget: 47,
-    },
-    {
-      date: "2026-08-25",
-      firm: "Solo Target",
-      action: "Initiates",
-      current: "Buy",
-      currentPriceTarget: 61,
-    },
-    {
-      date: "2026-08-24",
-      firm: "No Target",
-      action: "Reiterates",
-      current: "Buy",
-      prior: "Buy",
-    },
-  ],
-  earningsEstimates: [],
-  revenueEstimates: [],
-};
-
-function makeTicker(symbol: string): TickerRecord {
-  return createTestTicker(symbol, symbol, {
-    exchange: "NYSE"
-  });
-}
-
-function AnalystHarness({ provider, height }: { provider: DataProvider; height: number }) {
-  const config = createTestPaneConfig("/tmp/gloomberb-analyst-pane-test", {
-    instanceId: TEST_PANE_ID,
-    paneId: "analyst-research",
-    binding: { kind: "fixed", symbol: "NKE" },
-  });
-
-  const state = createInitialState(config);
-  state.focusedPaneId = TEST_PANE_ID;
-  state.tickers = new Map([["NKE", makeTicker("NKE")]]);
-
-  return (
-    <TestPaneProvider state={state} paneId={TEST_PANE_ID} pluginId="ticker-research" runtime={createTestPluginRuntime({ getMarketData: () => provider })}>
-      <PaneFooterProvider>
-        {(footer) => (
-          <Box flexDirection="column" width={WIDTH} height={height}>
-            <Box width={WIDTH} height={height - 1}>
-              <AnalystResearchView width={WIDTH} height={height - 1} focused />
-            </Box>
-            <PaneFooterBar footer={footer} focused width={WIDTH} />
-          </Box>
-        )}
-      </PaneFooterProvider>
-    </TestPaneProvider>
-  );
-}
-
-async function renderHarness(data: AnalystResearchData, height = HEIGHT): Promise<void> {
-  const provider = {
-    id: "test",
-    name: "Test",
-    getAnalystResearch: async () => data,
-  } as unknown as DataProvider;
-  await act(async () => {
-    testSetup = await testRender(<AnalystHarness provider={provider} height={height} />, { width: WIDTH, height });
-  });
-  for (let attempt = 0; attempt < 6; attempt += 1) {
-    await act(async () => {
-      await Bun.sleep(1);
-      await testSetup!.renderOnce();
-    });
-  }
-}
-
-afterEach(async () => {
-  if (testSetup) {
-    await act(async () => testSetup!.renderer.destroy());
-    testSetup = undefined;
-  }
-});
-
-/**
- * The pane used to reach a source that carries the aggregate price target but
- * no per-rating targets, so every TARGET cell rendered as a dash under a
- * header that advertised an average target.
- */
-test("renders each rating's price target and only dashes the rows without one", async () => {
-  await renderHarness(research);
-
-  const frame = testSetup!.captureCharFrame();
-  expect(frame).toMatch(/Avg target\s+\$50\.46/);
-  expect(frame).toContain("$47 → $42");
-  expect(frame).toContain("$61");
-  const noTargetRow = frame.split("\n").find((line) => line.includes("No Target"));
-  expect(noTargetRow).toBeDefined();
-  expect(noTargetRow).not.toMatch(/\$\d/);
-  expect(noTargetRow).toContain("-");
-});
-
-/**
- * The consensus context used to sit in a fixed block above a table that could
- * not be moved through at all, because the pane declared no row selection.
- */
-test("arrows walk the actions while the consensus context stays in the status bar", async () => {
-  // Newest first, one action a day, so row order follows the firm number.
-  const ratings: AnalystRatingRecord[] = Array.from({ length: 40 }, (_, index) => ({
-    date: new Date(Date.UTC(2026, 7, 26) - index * 86_400_000).toISOString().slice(0, 10),
-    firm: `Firm ${String(index).padStart(2, "0")}`,
-    action: "Raises",
-    current: "Buy",
-    currentPriceTarget: 40 + index,
-  }));
-  await renderHarness({ ...research, ratings, fetchedAt: "2026-08-27T10:00:00Z" }, 24);
-
-  const before = testSetup!.captureCharFrame();
-  expect(before).toContain("low $23.00 med $46.50 high $94.00");
-  expect(before).toContain("rating 6.1/10");
-  expect(before).toContain("upside vs $38.40");
-  // Body keeps the headline and the chart it labels, not the whole summary.
-  expect(before).toMatch(/Avg target\s+\$50\.46\s+\d+ firms/);
-  expect(before).not.toContain("Upside reference price");
-
-  const offscreenFirm = "Firm 20";
-  expect(before).toContain("Firm 00");
-  expect(before).not.toContain(offscreenFirm);
-  for (let step = 0; step < 20; step += 1) {
-    await emitKeypress(testSetup!, { name: "down", sequence: "\u001b[B" }, { frames: 2 });
-  }
-  await act(async () => { await Bun.sleep(200); await testSetup!.renderOnce(); });
-  expect(testSetup!.captureCharFrame()).toContain(offscreenFirm);
-});

package/src/plugins/builtin/research/corporate-actions-pane.test.tsx

@@ -1,77 +0,0 @@
-import { afterEach, expect, test } from "bun:test";
-import { act, useState } from "react";
-import { testRender, emitKeypress } from "../../../renderers/opentui/test-utils";
-import { appReducer, createInitialState, type AppAction, type AppState } from "../../../state/app/context";
-import { createTestDataProvider } from "../../../test-support/data-provider";
-import { TestPaneProvider, createTestTicker, createTestPaneConfig } from "../../../test-support/pane";
-import { createTestPluginRuntime } from "../../../test-support/plugin-runtime";
-import type { CorporateActionsData } from "../../../types/financials";
-import { Box } from "../../../ui";
-import { CorporateActionsView } from "./corporate-actions-pane";
-
-let setup: Awaited<ReturnType<typeof testRender>> | undefined;
-
-async function frame() {
-  await act(async () => { await Bun.sleep(1); });
-  await act(async () => { await setup!.renderOnce(); });
-}
-
-async function render(actions: CorporateActionsData, variant: "corporate-actions" | "earnings-estimates", width = 80) {
-  const paneId = `${variant}:TEST`;
-  const config = createTestPaneConfig("/tmp/gloom-corporate-actions-pane-test", {
-    instanceId: paneId, paneId: variant, binding: { kind: "fixed", symbol: "TEST" },
-  });
-  const state = createInitialState(config);
-  state.focusedPaneId = paneId;
-  state.tickers = new Map([["TEST", createTestTicker("TEST", "Test", { exchange: "ASX", currency: "AUD" })]]);
-  const provider = createTestDataProvider({
-    getCorporateActions: async () => actions,
-    getAnalystResearch: async () => ({ symbol: "TEST", recommendations: [], ratings: [], earningsEstimates: [], revenueEstimates: [] }),
-  });
-  const runtime = createTestPluginRuntime({ getMarketData: () => provider });
-  function Harness() {
-    // The selected row is pane state, so the harness needs a reducer.
-    const [paneState, setPaneState] = useState<AppState["paneState"]>({});
-    state.paneState = paneState;
-    const dispatch = (action: AppAction) => setPaneState(appReducer(state, action).paneState);
-    return (
-      <TestPaneProvider state={state} dispatch={dispatch} paneId={paneId} pluginId="ticker-research" runtime={runtime}>
-        <Box width={width} height={24} flexDirection="column">
-          <CorporateActionsView focused width={width} height={24} variant={variant} footerPaneId={variant} />
-        </Box>
-      </TestPaneProvider>
-    );
-  }
-  await act(async () => {
-    setup = await testRender(<Harness />, { width, height: 24 });
-  });
-  for (let index = 0; index < 4; index++) await frame();
-}
-
-afterEach(async () => {
-  if (setup) await act(async () => { setup!.renderer.destroy(); });
-  setup = undefined;
-});
-
-test("opening a fiscal-period row cannot select a same-day pending announcement", async () => {
-  await render({ symbol: "TEST", dividends: [], splits: [], earnings: [
-    { date: "2026-09-30", dateType: "announcement", epsEstimate: 2.2 },
-    { date: "2026-09-30", dateType: "fiscal-period-end", epsActual: 2, epsEstimate: 1.8, currency: "USD" },
-  ] }, "earnings-estimates", 120);
-  await emitKeypress(setup!, { name: "down" });
-  await frame();
-  await emitKeypress(setup!, { name: "return" });
-  await frame();
-  const detail = setup!.captureCharFrame();
-  expect(detail).toMatch(/Actual\s+2 USD/);
-  expect(detail).toMatch(/Consensus\s+1\.8 USD/);
-  expect(detail).not.toMatch(/Consensus\s+2\.2/);
-});
-
-test.each(["corporate-actions", "earnings-estimates"] as const)("%s preserves unavailable source status with no visible rows", async (variant) => {
-  await render({ symbol: "TEST", earnings: [], splits: [],
-    dividends: variant === "earnings-estimates" ? [{ exDate: "2026-09-30", amount: 0.1 }] : [],
-    coverage: { dividends: "available", splits: "unavailable", earnings: "unavailable" },
-  }, variant);
-  expect(setup!.captureCharFrame()).toContain(variant === "earnings-estimates" ? "Unavailable: earnings" : "Unavailable: splits, earnings");
-});