gloomberb 0.10.0 → 0.10.2

package/src/sources/gloomberb-cloud/index.test.ts

@@ -1,5 +1,6 @@
 import { afterEach, describe, expect, test } from "bun:test";
 import { createGloomberbCloudCapabilities, GloomberbCloudProvider } from "./index";
+import { getRangeStartDate, toHistoryRequest } from "./normalizers";
 import type { NewsCapability } from "../../capabilities";
 import { apiClient, type AuthUser, type CloudNewsPayload } from "../../api-client";
 
@@ -25,6 +26,17 @@ const originalGetCloudNews = apiClient.getCloudNews.bind(apiClient);
 const originalGetCloudNewsStory = apiClient.getCloudNewsStory.bind(apiClient);
 const originalSubscribeQuotes = apiClient.subscribeQuotes.bind(apiClient);
 
+test("requests fifty years of cloud history for the ALL range", () => {
+  const endDate = new Date("2026-07-30T20:00:00.000Z");
+
+  expect(getRangeStartDate("ALL", endDate).toISOString()).toBe("1976-07-30T20:00:00.000Z");
+  expect(toHistoryRequest("ALL")).toEqual({
+    interval: "1month",
+    outputsize: 600,
+    rangeKey: "ALL",
+  });
+});
+
 function makeCloudNewsPayload(overrides: Partial<CloudNewsPayload> = {}): CloudNewsPayload {
   return {
     id: "story-1",
@@ -124,6 +136,154 @@ describe("GloomberbCloudProvider", () => {
     expect(history[0]?.date.toISOString()).toBe("2026-03-27T14:15:00.000Z");
   });
 
+  test("rejects isolated cloud OHLC spikes so another history source can be used", async () => {
+    apiClient.ensureVerifiedSession = async () => verifiedUser;
+    apiClient.getCloudHistory = async () => ({
+      status: "success",
+      data: [
+        {
+          date: "2026-07-29T20:46:00Z",
+          open: 728.4,
+          high: 728.7,
+          low: 728.3,
+          close: 728.5,
+          volume: 0,
+        },
+        {
+          date: "2026-07-29T20:47:00Z",
+          open: 686.98,
+          high: 728.67,
+          low: 686.98,
+          close: 728.6,
+          volume: 0,
+        },
+        {
+          date: "2026-07-29T20:48:00Z",
+          open: 728.6,
+          high: 728.7,
+          low: 728.1,
+          close: 728.3,
+          volume: 0,
+        },
+      ],
+    });
+
+    const provider = new GloomberbCloudProvider();
+
+    await expect(
+      provider.getPriceHistoryForResolution("SPY", "NYSEARCA", "1W", "1m"),
+    ).rejects.toThrow("failed OHLC validation");
+  });
+
+  test("validates an outlier after normalizing descending cloud history", async () => {
+    apiClient.ensureVerifiedSession = async () => verifiedUser;
+    apiClient.getCloudHistory = async () => ({
+      status: "success",
+      data: [
+        {
+          date: "2026-07-29T20:48:00Z",
+          open: 728.6,
+          high: 728.7,
+          low: 728.1,
+          close: 728.3,
+          volume: 0,
+        },
+        {
+          date: "2026-07-29T20:47:00Z",
+          open: 686.98,
+          high: 728.67,
+          low: 686.98,
+          close: 728.6,
+          volume: 0,
+        },
+        {
+          date: "2026-07-29T20:46:00Z",
+          open: 728.4,
+          high: 728.7,
+          low: 728.3,
+          close: 728.5,
+          volume: 0,
+        },
+      ],
+    });
+
+    const provider = new GloomberbCloudProvider();
+
+    await expect(
+      provider.getPriceHistoryForResolution("SPY", "NYSEARCA", "1W", "1m"),
+    ).rejects.toThrow("failed OHLC validation");
+  });
+
+  test("preserves a wide cloud bar during a continuing price move", async () => {
+    apiClient.ensureVerifiedSession = async () => verifiedUser;
+    apiClient.getCloudHistory = async () => ({
+      status: "success",
+      data: [
+        {
+          date: "2026-07-29T20:10:00Z",
+          open: 561.1,
+          high: 561.3,
+          low: 560.7,
+          close: 560.8994,
+        },
+        {
+          date: "2026-07-29T20:15:00Z",
+          open: 560.11,
+          high: 585.61,
+          low: 553.41,
+          close: 555.4,
+        },
+        {
+          date: "2026-07-29T20:20:00Z",
+          open: 555.2,
+          high: 556,
+          low: 548.9,
+          close: 549.01,
+        },
+      ],
+    });
+
+    const provider = new GloomberbCloudProvider();
+    const history = await provider.getPriceHistoryForResolution(
+      "META",
+      "NASDAQ",
+      "1W",
+      "5m",
+    );
+
+    expect(history).toHaveLength(3);
+  });
+
+  test("does not reject an explicitly Yahoo-backed cloud history response", async () => {
+    apiClient.ensureVerifiedSession = async () => verifiedUser;
+    apiClient.getCloudHistory = async () => ({
+      status: "success",
+      providerMeta: { provider: "yahoo" },
+      data: [
+        { date: "2026-07-29T20:46:00Z", close: 728.5 },
+        {
+          date: "2026-07-29T20:47:00Z",
+          open: 686.98,
+          high: 728.67,
+          low: 686.98,
+          close: 728.6,
+          volume: 0,
+        },
+        { date: "2026-07-29T20:48:00Z", close: 728.3 },
+      ],
+    });
+
+    const provider = new GloomberbCloudProvider();
+    const history = await provider.getPriceHistoryForResolution(
+      "SPY",
+      "NYSEARCA",
+      "1W",
+      "1m",
+    );
+
+    expect(history[1]?.low).toBe(686.98);
+  });
+
   test("normalizes daily detailed history requests to 1day", async () => {
     apiClient.ensureVerifiedSession = async () => verifiedUser;
 
@@ -362,6 +522,11 @@ describe("GloomberbCloudProvider", () => {
           providerId: "gloomberb-cloud",
           underlyingSymbol: "AMD",
           expirationDates: [1_800_000_000],
+          dataSource: "live",
+          feed: "opra",
+          delayMinutes: 0,
+          realtimeEligible: true,
+          asOf: "2027-01-15T14:30:00.000Z",
           calls: [{
             contractSymbol: "AMD270917C00230000",
             strike: 230,
@@ -393,6 +558,14 @@ describe("GloomberbCloudProvider", () => {
     });
     expect(chain.underlyingSymbol).toBe("AMD");
     expect(chain.calls[0]?.contractSymbol).toBe("AMD270917C00230000");
+    expect(chain).toMatchObject({
+      providerId: "gloomberb-cloud",
+      dataSource: "live",
+      feed: "opra",
+      delayMinutes: 0,
+      realtimeEligible: true,
+      asOf: "2027-01-15T14:30:00.000Z",
+    });
   });
 
   test("preserves original target context when streaming quotes", () => {

package/src/sources/gloomberb-cloud/index.ts

@@ -1,9 +1,9 @@
-import type { TimeRange } from "../../components/chart/core/types";
+import type { TimeRange } from "../../time-series/range";
 import {
   normalizeChartResolutionSupport,
   type ChartResolutionSupport,
   type ManualChartResolution,
-} from "../../components/chart/core/resolution";
+} from "../../time-series/resolution";
 import { assetDataProvider, newsProvider, type PluginCapability } from "../../capabilities";
 import type {
   AssetDataProvider,
@@ -22,11 +22,14 @@ import {
   type CloudCorporateActionsPayload,
   type CloudHoldersPayload,
   type CloudMarketResponse,
+  type CloudPricePointPayload,
 } from "../../api-client";
 import type { NewsArticle, NewsQuery } from "../../types/news-source";
 import { resolvePriceHistoryCurrencyUnit } from "../../utils/currency-units";
 import { canonicalTickerKey } from "../../utils/exchanges";
+import { normalizePriceHistory } from "../../utils/price-history";
 import { createProviderMiss } from "../provider-errors";
+import { hasMalformedCloudIntradayHistory } from "./history-quality";
 import {
   cloudNewsParams,
   mapCloudNewsArticle,
@@ -83,6 +86,40 @@ function isStaleCloudResponse(response: CloudMarketResponse<unknown>): boolean {
   return response.stale === true || response.providerMeta?.stale === true;
 }
 
+function mapCloudPriceHistory(
+  response: CloudMarketResponse<CloudPricePointPayload[]>,
+  ticker: string,
+  exchange: string,
+  interval: string,
+): PricePoint[] {
+  if (isStaleCloudResponse(response)) {
+    throw createProviderMiss(`Cloud chart data is stale for ${ticker}`);
+  }
+  const { divisor } = resolvePriceHistoryCurrencyUnit(
+    response.currency ?? response.providerMeta?.currency,
+    exchange,
+  );
+  const points = normalizePriceHistory(
+    unwrapRequiredCloudResponse(
+      response,
+      `Cloud chart data is unavailable for ${ticker}`,
+    ).map((point) => mapPricePoint(point, divisor, exchange)),
+  );
+  const upstream = (
+    response.providerMeta?.provider
+    ?? response.providerMeta?.upstream
+    ?? ""
+  ).trim().toLowerCase();
+  if (
+    /(min|h)$/i.test(interval)
+    && upstream !== "yahoo"
+    && hasMalformedCloudIntradayHistory(points)
+  ) {
+    throw createProviderMiss(`Cloud chart data failed OHLC validation for ${ticker}`);
+  }
+  return points;
+}
+
 function quoteTargetKey(symbol: string, exchange?: string): string {
   return canonicalTickerKey(symbol, exchange);
 }
@@ -269,12 +306,7 @@ export class GloomberbCloudProvider implements AssetDataProvider {
       () => apiClient.getCloudHistory(ticker, exchange, request),
       `Cloud chart data is unavailable for ${ticker}`,
     );
-    if (isStaleCloudResponse(response)) {
-      throw createProviderMiss(`Cloud chart data is stale for ${ticker}`);
-    }
-    const { divisor } = resolvePriceHistoryCurrencyUnit(response.currency ?? response.providerMeta?.currency, exchange);
-    return unwrapRequiredCloudResponse(response, `Cloud chart data is unavailable for ${ticker}`)
-      .map((point) => mapPricePoint(point, divisor, exchange));
+    return mapCloudPriceHistory(response, ticker, exchange, request.interval);
   }
 
   async getPriceHistoryForResolution(
@@ -297,12 +329,7 @@ export class GloomberbCloudProvider implements AssetDataProvider {
       }),
       `Cloud chart data is unavailable for ${ticker}`,
     );
-    if (isStaleCloudResponse(response)) {
-      throw createProviderMiss(`Cloud chart data is stale for ${ticker}`);
-    }
-    const { divisor } = resolvePriceHistoryCurrencyUnit(response.currency ?? response.providerMeta?.currency, exchange);
-    return unwrapRequiredCloudResponse(response, `Cloud chart data is unavailable for ${ticker}`)
-      .map((point) => mapPricePoint(point, divisor, exchange));
+    return mapCloudPriceHistory(response, ticker, exchange, interval);
   }
 
   async getDetailedPriceHistory(
@@ -324,12 +351,7 @@ export class GloomberbCloudProvider implements AssetDataProvider {
       }),
       `Cloud detailed chart history is unavailable for ${ticker}`,
     );
-    if (isStaleCloudResponse(response)) {
-      throw createProviderMiss(`Cloud detailed chart history is stale for ${ticker}`);
-    }
-    const { divisor } = resolvePriceHistoryCurrencyUnit(response.currency ?? response.providerMeta?.currency, exchange);
-    return unwrapRequiredCloudResponse(response, `Cloud detailed chart history is unavailable for ${ticker}`)
-      .map((point) => mapPricePoint(point, divisor, exchange));
+    return mapCloudPriceHistory(response, ticker, exchange, interval);
   }
 
   async getOptionsChain(ticker: string, exchange?: string, expirationDate?: number, _context?: MarketDataRequestContext): Promise<OptionsChain> {

package/src/sources/gloomberb-cloud/normalizers.ts

@@ -1,4 +1,4 @@
-import type { TimeRange } from "../../components/chart/core/types";
+import type { TimeRange } from "../../time-series/range";
 import type {
   OptionsChain,
   PricePoint,
@@ -217,6 +217,12 @@ export function mapOptionsChain(
     expirationDates: chain.expirationDates ?? [],
     calls: chain.calls ?? [],
     puts: chain.puts ?? [],
+    providerId: chain.providerId,
+    dataSource: chain.dataSource,
+    feed: chain.feed,
+    delayMinutes: chain.delayMinutes,
+    realtimeEligible: chain.realtimeEligible,
+    asOf: chain.asOf,
   };
 }
 
@@ -320,7 +326,7 @@ export function getRangeStartDate(
       startDate.setFullYear(startDate.getFullYear() - 5);
       break;
     case "ALL":
-      startDate.setFullYear(startDate.getFullYear() - 20);
+      startDate.setFullYear(startDate.getFullYear() - 50);
       break;
   }
   return startDate;
@@ -347,7 +353,7 @@ export function toHistoryRequest(range: TimeRange): {
     case "5Y":
       return { interval: "1week", outputsize: 261, rangeKey: range };
     case "ALL":
-      return { interval: "1month", outputsize: 240, rangeKey: range };
+      return { interval: "1month", outputsize: 600, rangeKey: range };
     default:
       return { interval: "1day", outputsize: 366, rangeKey: range };
   }

package/src/sources/provider-router/cache.ts

@@ -1,5 +1,5 @@
 import type { CachedResourceRecord, ResourceStore } from "../../data/resource-store";
-import type { TimeRange } from "../../components/chart/core/types";
+import type { TimeRange } from "../../time-series/range";
 import type { BrokerContractRef } from "../../types/instrument";
 import type { PricePoint } from "../../types/financials";
 import type { CachePolicy, CachePolicyMap } from "../../types/persistence";

package/src/sources/provider-router/document-routes.ts

@@ -13,7 +13,7 @@ import { shouldLogProviderError } from "../provider-errors";
 import type { ProviderRouterCoreDeps, SourceResult } from "./route-types";
 import {
   firstProviderResult,
-  makeRouterRevalidationKey,
+  makeRouterRequestIdentity,
   resolveProviderBySourceKey,
   scheduleRouterRevalidation,
 } from "./routing";
@@ -24,15 +24,20 @@ export class ProviderRouterDocumentRoutes {
   constructor(private readonly deps: ProviderRouterCoreDeps) {}
 
   async getSecFilings(ticker: string, count = 15, exchange?: string, context?: MarketDataRequestContext): Promise<SecFilingItem[]> {
-    const entityKey = this.deps.getEntityKey(ticker, context?.instrument);
+    const identity = makeRouterRequestIdentity(this.deps, {
+      kind: "sec-filings",
+      ticker,
+      context,
+      variantParts: [["exchange", canonicalExchange(exchange)], ["count", count]],
+    });
     const variantKeys = [
-      buildVariantKey([["exchange", canonicalExchange(exchange)], ["count", count]]),
+      identity.variantKey,
       buildVariantKey([["count", count]]),
       "",
     ];
-    const cached = selectCachedResource<SecFilingItem[]>(this.deps.resources, "sec-filings", entityKey, variantKeys, this.deps.getProviderSourceKeys(), false);
+    const cached = selectCachedResource<SecFilingItem[]>(this.deps.resources, identity.kind, identity.entityKey, variantKeys, this.deps.getProviderSourceKeys(), false);
     if (cached) {
-      scheduleRouterRevalidation(this.revalidationInFlight, makeRouterRevalidationKey(this.deps, "sec-filings", ticker, context, count), async () => {
+      scheduleRouterRevalidation(this.revalidationInFlight, identity.revalidationKey, async () => {
         await this.revalidateSecFilings(ticker, count, exchange, context);
       });
       return cached.value;

package/src/sources/provider-router/financials.test.ts

@@ -22,6 +22,20 @@ describe("provider-router financial quote usability", () => {
     }), "FWB2")).toBe(false);
   });
 
+  test("accepts a streamed 15-minute delayed quote during the active session", () => {
+    expect(
+      isProviderQuoteUsableForCurrentSession(
+        makeQuote({
+          dataSource: "delayed",
+          listingExchangeName: "NASDAQ",
+          marketState: "REGULAR",
+          lastUpdated: Date.now() - 15 * 60_000,
+        }),
+        "NASDAQ",
+      ),
+    ).toBe(true);
+  });
+
   test("rejects empty zero provider quotes", () => {
     expect(isProviderQuoteUsableForCurrentSession(makeQuote({
       price: 0,

package/src/sources/provider-router/financials.ts

@@ -82,12 +82,17 @@ function finitePositiveNumber(value: unknown): value is number {
 }
 
 const ACTIVE_PROVIDER_QUOTE_MAX_AGE_MS = 10 * 60_000;
+const ACTIVE_DELAYED_PROVIDER_QUOTE_MAX_AGE_MS = 20 * 60_000;
 const ACTIVE_QUOTE_MARKET_STATES = new Set(["PRE", "REGULAR", "POST"]);
 
 function isActiveProviderQuoteTooOld(quote: Quote, now = Date.now()): boolean {
   if (!ACTIVE_QUOTE_MARKET_STATES.has(quote.marketState ?? "")) return false;
   if (!Number.isFinite(quote.lastUpdated)) return false;
-  return now - quote.lastUpdated > ACTIVE_PROVIDER_QUOTE_MAX_AGE_MS;
+  const maxAge =
+    quote.dataSource === "delayed"
+      ? ACTIVE_DELAYED_PROVIDER_QUOTE_MAX_AGE_MS
+      : ACTIVE_PROVIDER_QUOTE_MAX_AGE_MS;
+  return now - quote.lastUpdated > maxAge;
 }
 
 export function isProviderQuoteUsableForCurrentSession(quote: Quote | null | undefined, exchange?: string): quote is Quote {

package/src/sources/provider-router/history.test.ts

@@ -135,6 +135,59 @@ describe("AssetDataRouter chart history", () => {
     persistence.close();
   });
 
+  test("ignores the previous chart history cache generation", async () => {
+    const dbPath = createTempDbPath("previous-chart-cache-generation");
+    const persistence = new AppPersistence(dbPath);
+    const latestDate = new Date(Date.now() - 60_000);
+    const previousDate = new Date(latestDate.getTime() - 5 * 60_000);
+
+    persistence.resources.set(
+      {
+        namespace: "market",
+        kind: "price-history",
+        entityKey: "META",
+        variantKey: "exchange=NASDAQ;range=1M;resolution=5m;version=2",
+        sourceKey: "provider:gloomberb-cloud",
+      },
+      [
+        { date: previousDate, close: 620 },
+        { date: latestDate, close: 680 },
+      ],
+      {
+        cachePolicy: { staleMs: 60_000, expireMs: 60_000 },
+      },
+    );
+
+    let providerCalls = 0;
+    const router = new AssetDataRouter({
+      ...fallbackProvider,
+      id: "gloomberb-cloud",
+      name: "Gloomberb Cloud",
+      async getPriceHistoryForResolution() {
+        providerCalls += 1;
+        return [
+          { date: previousDate, close: 620 },
+          { date: latestDate, close: 560 },
+        ];
+      },
+    }, [], persistence.resources);
+
+    const history = await router.getPriceHistoryForResolution("META", "NASDAQ", "1M", "5m");
+
+    expect(providerCalls).toBe(1);
+    expect(history.map((point) => point.close)).toEqual([620, 560]);
+
+    const cachedRows = persistence.database.connection
+      .query("SELECT variant_key FROM resource_cache WHERE namespace = ? AND kind = ? AND entity_key = ? ORDER BY variant_key")
+      .all("market", "price-history", "META") as Array<{ variant_key: string }>;
+    expect(cachedRows.map((row) => row.variant_key)).toEqual([
+      "exchange=NASDAQ;range=1M;resolution=5m;version=2",
+      "exchange=NASDAQ;range=1M;resolution=5m;version=3",
+    ]);
+
+    persistence.close();
+  });
+
   test("ignores legacy unversioned sub-unit chart history caches", async () => {
     const dbPath = createTempDbPath("subunit-chart-cache");
     const persistence = new AppPersistence(dbPath);
@@ -180,7 +233,7 @@ describe("AssetDataRouter chart history", () => {
       .all("market", "price-history", "FTC") as Array<{ variant_key: string }>;
     expect(cachedRows.map((row) => row.variant_key)).toEqual([
       "exchange=LSE;range=ALL;resolution=1wk",
-      "exchange=LSE;range=ALL;resolution=1wk;unit=GBP",
+      "exchange=LSE;range=ALL;resolution=1wk;version=3;unit=GBP",
     ]);
 
     persistence.close();
@@ -349,6 +402,115 @@ describe("AssetDataRouter chart history", () => {
     expect(await router.getChartResolutionCapabilities("AAPL", "NASDAQ")).toEqual(["1d", "1wk"]);
   });
 
+  test("skips unavailable providers when resolving chart resolution support", async () => {
+    let cloudSupportCalls = 0;
+    const cloudProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "cloud",
+      name: "Cloud",
+      priority: 100,
+      async canProvide() {
+        return false;
+      },
+      getChartResolutionSupport() {
+        cloudSupportCalls += 1;
+        return [{ resolution: "1m", maxRange: "1W" }];
+      },
+    };
+    const yahooProvider: DataProvider = {
+      ...fallbackProvider,
+      id: "yahoo",
+      name: "Yahoo",
+      priority: 1000,
+      getChartResolutionSupport() {
+        return [{ resolution: "1d", maxRange: "5Y" }];
+      },
+    };
+
+    const router = new AssetDataRouter(yahooProvider, [cloudProvider]);
+
+    expect(await router.getChartResolutionSupport("AAPL", "NASDAQ")).toEqual([
+      { resolution: "1d", maxRange: "5Y" },
+    ]);
+    expect(cloudSupportCalls).toBe(0);
+  });
+
+  test("refreshes each history request type before falling back to its cached value", async () => {
+    const dbPath = createTempDbPath("forced-history-refresh");
+    const persistence = new AppPersistence(dbPath);
+    const startDate = new Date("2026-03-28T09:30:00Z");
+    const endDate = new Date("2026-03-28T16:00:00Z");
+    const seedProvider: DataProvider = {
+      ...fallbackProvider,
+      async getPriceHistory() {
+        return [{ date: endDate, close: 101 }];
+      },
+      async getPriceHistoryForResolution() {
+        return [{ date: endDate, close: 102 }];
+      },
+      async getDetailedPriceHistory() {
+        return [{ date: endDate, close: 103 }];
+      },
+    };
+    const seedRouter = new AssetDataRouter(seedProvider, [], persistence.resources);
+    await seedRouter.getPriceHistory("AAPL", "NASDAQ", "1Y");
+    await seedRouter.getPriceHistoryForResolution("AAPL", "NASDAQ", "1Y", "1d");
+    await seedRouter.getDetailedPriceHistory("AAPL", "NASDAQ", startDate, endDate, "15m");
+
+    const calls = { range: 0, resolution: 0, detailed: 0 };
+    const refreshProvider: DataProvider = {
+      ...fallbackProvider,
+      async getPriceHistory() {
+        calls.range += 1;
+        return [];
+      },
+      async getPriceHistoryForResolution() {
+        calls.resolution += 1;
+        return [];
+      },
+      async getDetailedPriceHistory() {
+        calls.detailed += 1;
+        return [];
+      },
+    };
+    const refreshRouter = new AssetDataRouter(refreshProvider, [], persistence.resources);
+
+    const range = await refreshRouter.getPriceHistory("AAPL", "NASDAQ", "1Y", { cacheMode: "refresh" });
+    const resolution = await refreshRouter.getPriceHistoryForResolution(
+      "AAPL",
+      "NASDAQ",
+      "1Y",
+      "1d",
+      { cacheMode: "refresh" },
+    );
+    const detailed = await refreshRouter.getDetailedPriceHistory(
+      "AAPL",
+      "NASDAQ",
+      startDate,
+      endDate,
+      "15m",
+      { cacheMode: "refresh" },
+    );
+
+    expect(calls).toEqual({ range: 1, resolution: 1, detailed: 1 });
+    expect([range[0]?.close, resolution[0]?.close, detailed[0]?.close]).toEqual([101, 102, 103]);
+
+    persistence.close();
+  });
+
+  test("preserves each history request type's missing-provider result", async () => {
+    const router = new AssetDataRouter(null);
+    const startDate = new Date("2026-03-28T09:30:00Z");
+    const endDate = new Date("2026-03-28T16:00:00Z");
+
+    await expect(router.getPriceHistory("AAPL", "NASDAQ", "1Y"))
+      .rejects.toThrow("No history provider available for AAPL");
+    await expect(router.getPriceHistoryForResolution("AAPL", "NASDAQ", "1Y", "1d"))
+      .rejects.toThrow("No resolution-aware history provider available for AAPL");
+    await expect(router.getDetailedPriceHistory("AAPL", "NASDAQ", startDate, endDate, "15m"))
+      .resolves.toEqual([]);
+  });
+
   test("falls back to later providers when detailed chart history is empty", async () => {
     const cloudProvider: DataProvider = {
       ...fallbackProvider,