@openfinclaw/findoo-datahub-plugin 2026.3.2

package/src/datahub-client.test.ts

@@ -0,0 +1,544 @@
+/**
+ * findoo-datahub-plugin E2E 真实验收测试
+ *
+ * 覆盖重建后的 DataHubClient 全部 8 大 category + UnifiedProvider + OHLCVCache + RegimeDetector。
+ * 分两层：
+ *   1. Unit (纯本地，无外部依赖) — 始终运行
+ *   2. Live (真实 DataHub) — 默认运行（公共 DataHub 凭据内置），设 DATAHUB_SKIP_LIVE=1 跳过
+ */
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { DataHubClient } from "./datahub-client.js";
+import { OHLCVCache } from "./ohlcv-cache.js";
+import { RegimeDetector } from "./regime-detector.js";
+import type { OHLCV } from "./types.js";
+
+/* ---------- test data helpers ---------- */
+
+function generateOHLCV(
+  count: number,
+  trend: "up" | "down" | "flat" | "volatile" | "crash",
+  startPrice = 100,
+  startTime = Date.now() - count * 3600_000,
+): OHLCV[] {
+  const bars: OHLCV[] = [];
+  let price = startPrice;
+
+  for (let i = 0; i < count; i++) {
+    let change: number;
+    switch (trend) {
+      case "up":
+        change = price * (0.005 + Math.random() * 0.01);
+        break;
+      case "down":
+        change = price * -(0.005 + Math.random() * 0.01);
+        break;
+      case "flat":
+        change = price * (Math.random() - 0.5) * 0.003;
+        break;
+      case "volatile":
+        change = price * (Math.random() - 0.5) * 0.08;
+        break;
+      case "crash":
+        change = price * -(0.01 + Math.random() * 0.015);
+        break;
+    }
+
+    const open = price;
+    price = price + change;
+    const close = price;
+    // For volatile trend, widen high/low to reflect true range
+    const spread = trend === "volatile" ? 0.04 : 0.005;
+    const high = Math.max(open, close) * (1 + Math.random() * spread);
+    const low = Math.min(open, close) * (1 - Math.random() * spread);
+
+    bars.push({
+      timestamp: startTime + i * 3600_000,
+      open,
+      high,
+      low,
+      close,
+      volume: 1000 + Math.random() * 5000,
+    });
+  }
+  return bars;
+}
+
+/* ---------- tmpDir for SQLite tests ---------- */
+
+let tmpDir: string;
+
+beforeAll(() => {
+  tmpDir = join(tmpdir(), `findoo-test-${Date.now()}`);
+  mkdirSync(tmpDir, { recursive: true });
+});
+
+afterAll(() => {
+  try {
+    rmSync(tmpDir, { recursive: true, force: true });
+  } catch {
+    // Ignore cleanup errors
+  }
+});
+
+/* ============================================================
+ * Section 1: Unit Tests — 纯本地，无外部依赖
+ * ============================================================ */
+
+describe("OHLCVCache (SQLite)", () => {
+  it("upsert + query round trip", () => {
+    const cache = new OHLCVCache(join(tmpDir, "cache-unit.sqlite"));
+    const bars = generateOHLCV(10, "up");
+
+    cache.upsertBatch("BTC/USDT", "crypto", "1h", bars);
+    const result = cache.query("BTC/USDT", "crypto", "1h");
+
+    expect(result).toHaveLength(10);
+    expect(result[0]!.timestamp).toBe(bars[0]!.timestamp);
+    expect(result[9]!.close).toBeCloseTo(bars[9]!.close, 4);
+    cache.close();
+  });
+
+  it("upsert is idempotent (INSERT OR REPLACE)", () => {
+    const cache = new OHLCVCache(join(tmpDir, "cache-idem.sqlite"));
+    const bars = generateOHLCV(5, "up");
+
+    cache.upsertBatch("ETH/USDT", "crypto", "1d", bars);
+    // Modify close price and re-upsert
+    const modified = bars.map((b) => ({ ...b, close: b.close + 100 }));
+    cache.upsertBatch("ETH/USDT", "crypto", "1d", modified);
+
+    const result = cache.query("ETH/USDT", "crypto", "1d");
+    expect(result).toHaveLength(5);
+    // Should have the updated values
+    expect(result[0]!.close).toBeCloseTo(modified[0]!.close, 4);
+    cache.close();
+  });
+
+  it("getRange returns null for empty", () => {
+    const cache = new OHLCVCache(join(tmpDir, "cache-empty.sqlite"));
+    const range = cache.getRange("NONEXIST", "crypto", "1h");
+    expect(range).toBeNull();
+    cache.close();
+  });
+
+  it("getRange returns correct earliest/latest", () => {
+    const cache = new OHLCVCache(join(tmpDir, "cache-range.sqlite"));
+    const bars = generateOHLCV(20, "flat");
+    cache.upsertBatch("SOL/USDT", "crypto", "4h", bars);
+
+    const range = cache.getRange("SOL/USDT", "crypto", "4h");
+    expect(range).not.toBeNull();
+    expect(range!.earliest).toBe(bars[0]!.timestamp);
+    expect(range!.latest).toBe(bars[19]!.timestamp);
+    cache.close();
+  });
+
+  it("query with since filter", () => {
+    const cache = new OHLCVCache(join(tmpDir, "cache-since.sqlite"));
+    const bars = generateOHLCV(20, "up");
+    cache.upsertBatch("ADA/USDT", "crypto", "1h", bars);
+
+    const midTs = bars[10]!.timestamp;
+    const result = cache.query("ADA/USDT", "crypto", "1h", midTs);
+    expect(result.length).toBeLessThanOrEqual(11);
+    expect(result[0]!.timestamp).toBeGreaterThanOrEqual(midTs);
+    cache.close();
+  });
+
+  it("different symbols are isolated", () => {
+    const cache = new OHLCVCache(join(tmpDir, "cache-iso.sqlite"));
+    const btcBars = generateOHLCV(5, "up", 50000);
+    const ethBars = generateOHLCV(5, "down", 3000);
+
+    cache.upsertBatch("BTC/USDT", "crypto", "1h", btcBars);
+    cache.upsertBatch("ETH/USDT", "crypto", "1h", ethBars);
+
+    const btc = cache.query("BTC/USDT", "crypto", "1h");
+    const eth = cache.query("ETH/USDT", "crypto", "1h");
+    expect(btc).toHaveLength(5);
+    expect(eth).toHaveLength(5);
+    expect(btc[0]!.open).toBeGreaterThan(10000);
+    expect(eth[0]!.open).toBeLessThan(5000);
+    cache.close();
+  });
+});
+
+describe("RegimeDetector", () => {
+  const detector = new RegimeDetector();
+
+  it("returns sideways when < 200 bars", () => {
+    const bars = generateOHLCV(50, "up");
+    expect(detector.detect(bars)).toBe("sideways");
+  });
+
+  it("detects bull market (strong uptrend)", () => {
+    const bars = generateOHLCV(300, "up", 100);
+    const regime = detector.detect(bars);
+    // Strong uptrend should be bull or sideways (depends on SMA crossover timing)
+    expect(["bull", "sideways"]).toContain(regime);
+  });
+
+  it("detects bear market (strong downtrend)", () => {
+    const bars = generateOHLCV(300, "down", 200);
+    const regime = detector.detect(bars);
+    // Down trend may trigger bear, crisis (if >30% drawdown), or sideways
+    expect(["bear", "sideways", "crisis"]).toContain(regime);
+  });
+
+  it("detects crisis (>30% drawdown)", () => {
+    const bars = generateOHLCV(300, "crash", 200);
+    const regime = detector.detect(bars);
+    expect(["crisis", "bear", "volatile"]).toContain(regime);
+  });
+
+  it("detects volatile market", () => {
+    const bars = generateOHLCV(300, "volatile", 100);
+    const regime = detector.detect(bars);
+    // High ATR should trigger volatile; random walk may drift to bull/bear
+    expect(["volatile", "crisis", "sideways", "bull", "bear"]).toContain(regime);
+  });
+
+  it("returns valid MarketRegime type", () => {
+    const bars = generateOHLCV(300, "flat", 100);
+    const regime = detector.detect(bars);
+    expect(["bull", "bear", "sideways", "volatile", "crisis"]).toContain(regime);
+  });
+});
+
+/* ============================================================
+ * Section 2: DataHubClient Unit Tests (mock-free, tests structure)
+ * ============================================================ */
+
+describe("DataHubClient construction", () => {
+  it("builds correct auth header", () => {
+    const client = new DataHubClient("http://localhost:8088", "admin", "test-password", 5000);
+    // Just verify it can be constructed without errors
+    expect(client).toBeDefined();
+  });
+});
+
+/* ============================================================
+ * Section 3: Live E2E — 真实 DataHub 连接
+ * ============================================================ */
+
+const DATAHUB_URL = process.env.DATAHUB_API_URL ?? "http://43.134.61.136:8088";
+const DATAHUB_USERNAME = process.env.DATAHUB_USERNAME ?? "admin";
+const DATAHUB_PASSWORD =
+  process.env.DATAHUB_PASSWORD ??
+  process.env.DATAHUB_API_KEY ??
+  "98ffa5c5-1ec6-4735-8e0c-715a5eca1a8d";
+// Live tests run by default (public DataHub has baked-in credentials)
+// Set DATAHUB_SKIP_LIVE=1 to skip
+const SKIP_LIVE = process.env.DATAHUB_SKIP_LIVE === "1";
+
+describe.skipIf(SKIP_LIVE)("Live DataHub E2E", () => {
+  let client: DataHubClient;
+
+  beforeAll(() => {
+    client = new DataHubClient(DATAHUB_URL, DATAHUB_USERNAME, DATAHUB_PASSWORD, 30_000);
+  });
+
+  // --- Coverage / Meta ---
+  it("coverage/providers returns all 7 providers", async () => {
+    const results = await client.coverage("providers");
+    // coverage returns a single object, not array
+    expect(results).toBeDefined();
+  });
+
+  // --- Equity ---
+  it("equity: A-share historical (600519.SH 茅台)", async () => {
+    const results = await client.equity("price/historical", {
+      symbol: "600519.SH",
+      provider: "tushare",
+      limit: "5",
+    });
+    expect(results.length).toBeGreaterThan(0);
+    const row = results[0] as Record<string, unknown>;
+    expect(row).toHaveProperty("date");
+    expect(row).toHaveProperty("close");
+    expect(Number(row.close)).toBeGreaterThan(100);
+  });
+
+  it("equity: US stock historical (AAPL)", async () => {
+    try {
+      const results = await client.equity("price/historical", {
+        symbol: "AAPL",
+        provider: "yfinance",
+        limit: "5",
+      });
+      // yfinance may return empty when rate limited (returns 204 or empty results)
+      if (results.length > 0) {
+        const row = results[0] as Record<string, unknown>;
+        expect(row).toHaveProperty("close");
+      }
+      expect(Array.isArray(results)).toBe(true);
+    } catch (err) {
+      // yfinance rate limited — acceptable in burst test scenarios
+      expect(String(err)).toMatch(/Rate|429|Too Many|500/i);
+    }
+  });
+
+  it("equity: HK stock historical (00700.HK)", async () => {
+    const results = await client.equity("price/historical", {
+      symbol: "00700.HK",
+      provider: "tushare",
+      limit: "5",
+    });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("equity: fundamental/income (600519.SH)", async () => {
+    const results = await client.equity("fundamental/income", {
+      symbol: "600519.SH",
+      provider: "tushare",
+      limit: "3",
+    });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("equity: ownership/top10_holders", async () => {
+    const results = await client.equity("ownership/top10_holders", {
+      symbol: "600519.SH",
+      provider: "tushare",
+    });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("equity: market/top_list (龙虎榜)", async () => {
+    try {
+      const results = await client.equity("market/top_list", {
+        trade_date: "2026-02-27",
+        provider: "tushare",
+      });
+      // May be empty on non-trading days
+      expect(Array.isArray(results)).toBe(true);
+    } catch (err) {
+      // Some Tushare endpoints may return 500 for certain date ranges
+      expect(String(err)).toMatch(/DataHub error|500|rate/i);
+    }
+  });
+
+  it("equity: flow/hsgt_flow (北向资金)", async () => {
+    const results = await client.equity("flow/hsgt_flow", {
+      start_date: "2026-02-01",
+      end_date: "2026-02-28",
+      provider: "tushare",
+    });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("equity: discovery/gainers", async () => {
+    try {
+      const results = await client.equity("discovery/gainers", {
+        provider: "yfinance",
+      });
+      expect(results.length).toBeGreaterThan(0);
+    } catch (err) {
+      // yfinance rate limited — acceptable in CI
+      expect(String(err)).toMatch(/Rate|429|Too Many/i);
+    }
+  });
+
+  // --- Economy ---
+  it("economy: CPI", async () => {
+    const results = await client.economy("cpi", { limit: "5" });
+    expect(results.length).toBeGreaterThan(0);
+    const row = results[0] as Record<string, unknown>;
+    expect(row).toHaveProperty("value");
+  });
+
+  it("economy: GDP", async () => {
+    const results = await client.economy("gdp/real", { limit: "3" });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("economy: Shibor", async () => {
+    const results = await client.economy("shibor", { limit: "5" });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("economy: LPR", async () => {
+    const results = await client.economy("shibor_lpr", { limit: "5" });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("economy: US Treasury", async () => {
+    const results = await client.economy("treasury_us", { limit: "5" });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("economy: WorldBank GDP", async () => {
+    const results = await client.economy("worldbank/gdp", { country: "CN" });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  // --- Crypto ---
+  it("crypto: coin/market (CoinGecko top coins)", async () => {
+    const results = await client.crypto("coin/market", { limit: "10" });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("crypto: coin/trending", async () => {
+    const results = await client.crypto("coin/trending");
+    expect(results).toBeDefined();
+  });
+
+  it("crypto: coin/global_stats", async () => {
+    const results = await client.crypto("coin/global_stats");
+    expect(results).toBeDefined();
+  });
+
+  it("crypto: defi/protocols (DefiLlama)", async () => {
+    const results = await client.crypto("defi/protocols");
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("crypto: defi/chains", async () => {
+    const results = await client.crypto("defi/chains");
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("crypto: defi/stablecoins", async () => {
+    const results = await client.crypto("defi/stablecoins");
+    expect(results).toBeDefined();
+  });
+
+  // --- Index ---
+  it("index: price/historical (000300.SH 沪深300)", async () => {
+    const results = await client.index("price/historical", {
+      symbol: "000300.SH",
+      provider: "tushare",
+      limit: "5",
+    });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("index: constituents (000300.SH)", async () => {
+    const results = await client.index("constituents", {
+      symbol: "000300.SH",
+      provider: "tushare",
+    });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("index: thematic/ths_index", async () => {
+    const results = await client.index("thematic/ths_index", {
+      provider: "tushare",
+    });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  // --- ETF ---
+  it("etf: historical (510050.SH)", async () => {
+    const results = await client.etf("historical", {
+      symbol: "510050.SH",
+      provider: "tushare",
+      limit: "5",
+    });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("etf: fund/manager", async () => {
+    // Tushare fund codes may need .OF suffix
+    const results = await client.etf("fund/manager", {
+      symbol: "110011.OF",
+      provider: "tushare",
+    });
+    // May be empty if fund code format doesn't match
+    expect(Array.isArray(results)).toBe(true);
+  });
+
+  // --- Derivatives ---
+  it("derivatives: futures/historical", async () => {
+    const results = await client.derivatives("futures/historical", {
+      symbol: "RB2501.SHF",
+      provider: "tushare",
+      limit: "5",
+    });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("derivatives: options/basic", async () => {
+    const results = await client.derivatives("options/basic", {
+      symbol: "510050.SH",
+      provider: "tushare",
+    });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  it("derivatives: convertible/basic", async () => {
+    const results = await client.derivatives("convertible/basic", {
+      provider: "tushare",
+      limit: "5",
+    });
+    expect(results.length).toBeGreaterThan(0);
+  });
+
+  // --- Currency ---
+  it("currency: price/historical (USD/CNH)", async () => {
+    // Tushare FX uses different symbol format
+    const results = await client.currency("price/historical", {
+      symbol: "USDCNH",
+      provider: "tushare",
+    });
+    // May return empty if symbol format doesn't match provider expectations
+    expect(Array.isArray(results)).toBe(true);
+  });
+
+  // --- OHLCV convenience ---
+  it("getOHLCV: equity (600519.SH)", async () => {
+    const ohlcv = await client.getOHLCV({
+      symbol: "600519.SH",
+      market: "equity",
+      timeframe: "1d",
+      limit: 10,
+    });
+    expect(ohlcv.length).toBeGreaterThan(0);
+    expect(ohlcv[0]).toHaveProperty("timestamp");
+    expect(ohlcv[0]).toHaveProperty("open");
+    expect(ohlcv[0]).toHaveProperty("close");
+    expect(ohlcv[0]).toHaveProperty("volume");
+  });
+
+  it("getTicker: equity (AAPL)", async () => {
+    try {
+      const ticker = await client.getTicker("AAPL", "equity");
+      expect(ticker.symbol).toBe("AAPL");
+      expect(ticker.market).toBe("equity");
+      expect(ticker.last).toBeGreaterThan(0);
+    } catch (err) {
+      // yfinance rate limited — acceptable
+      expect(String(err)).toMatch(/Rate|429|Too Many|No ticker/i);
+    }
+  });
+
+  // --- Integration: OHLCV → Cache → RegimeDetector ---
+  it("full pipeline: DataHub OHLCV → Cache → Regime", async () => {
+    const cache = new OHLCVCache(join(tmpDir, "live-pipeline.sqlite"));
+    const detector = new RegimeDetector();
+
+    // Fetch 300 bars of A-share data
+    const ohlcv = await client.getOHLCV({
+      symbol: "600519.SH",
+      market: "equity",
+      timeframe: "1d",
+    });
+    expect(ohlcv.length).toBeGreaterThan(100);
+
+    // Cache them
+    cache.upsertBatch("600519.SH", "equity", "1d", ohlcv);
+    const cached = cache.query("600519.SH", "equity", "1d");
+    expect(cached.length).toBe(ohlcv.length);
+
+    // Detect regime
+    if (ohlcv.length >= 200) {
+      const regime = detector.detect(ohlcv);
+      expect(["bull", "bear", "sideways", "volatile", "crisis"]).toContain(regime);
+    }
+
+    cache.close();
+  });
+});