@openfinclaw/openfinclaw-strategy 0.0.11

package/src/validate.test.ts

@@ -0,0 +1,841 @@
+/**
+ * Tests for strategy package validation (FEP v2.0).
+ * Uses real node:fs/promises for file operations.
+ */
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { validateStrategyPackage } from "./validate.js";
+
+describe("validateStrategyPackage (FEP v2.0)", () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = mkdtempSync(path.join(tmpdir(), "fep-v2-validate-"));
+  });
+
+  afterEach(() => {
+    if (tmpDir) {
+      try {
+        rmSync(tmpDir, { recursive: true, force: true });
+      } catch {
+        // ignore
+      }
+    }
+  });
+
+  /**
+   * 创建最小有效策略包
+   */
+  function createMinimalValidPackage(): string {
+    writeFileSync(
+      path.join(tmpDir, "fep.yaml"),
+      `
+fep: "2.0"
+identity:
+  id: fin-test-minimal
+  name: "Test Strategy"
+  type: strategy
+  version: "1.0.0"
+  style: trend
+  visibility: private
+  summary: "A test strategy"
+  description: "A simple test strategy for validation"
+  license: MIT
+  tags: [test, validation]
+  author:
+    name: "Test Author"
+  changelog:
+    - version: "1.0.0"
+      date: "2025-01-01"
+      changes: "Initial release"
+technical:
+  language: python
+  entryPoint: strategy.py
+backtest:
+  symbol: "BTC/USDT"
+  defaultPeriod:
+    startDate: "2024-01-01"
+    endDate: "2024-12-31"
+  initialCapital: 10000
+`,
+    );
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(
+      path.join(scriptDir, "strategy.py"),
+      `
+import numpy as np
+
+def compute(data, context=None):
+    close = data["close"].values
+    price = float(close[-1])
+    return {"action": "hold", "amount": 0, "price": price, "reason": "test"}
+`,
+    );
+
+    return tmpDir;
+  }
+
+  // ── 基础验证测试 ──
+
+  it("returns valid for minimal FEP v2.0 package", async () => {
+    const dir = createMinimalValidPackage();
+    const result = await validateStrategyPackage(dir);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toEqual([]);
+  });
+
+  it("returns invalid when fep.yaml is missing", async () => {
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(path.join(scriptDir, "strategy.py"), "def compute(data): return {}");
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("fep.yaml"))).toBe(true);
+  });
+
+  it("returns invalid when scripts/strategy.py is missing", async () => {
+    writeFileSync(path.join(tmpDir, "fep.yaml"), `fep: "2.0"\nidentity:\n  id: test\n  name: Test`);
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("strategy.py"))).toBe(true);
+  });
+
+  // ── 版本验证测试 ──
+
+  it("rejects fep version other than 2.0", async () => {
+    writeFileSync(path.join(tmpDir, "fep.yaml"), `fep: "1.2"\nidentity:\n  id: test\n  name: Test`);
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(path.join(scriptDir, "strategy.py"), "def compute(data): return {}");
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("版本必须为") && e.includes("2.0"))).toBe(true);
+  });
+
+  // ── identity 必填字段测试 ──
+
+  it("requires identity.id", async () => {
+    writeFileSync(path.join(tmpDir, "fep.yaml"), `fep: "2.0"\nidentity:\n  name: Test`);
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(path.join(scriptDir, "strategy.py"), "def compute(data): return {}");
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("identity") && e.includes("id"))).toBe(true);
+  });
+
+  it("requires identity.name", async () => {
+    writeFileSync(path.join(tmpDir, "fep.yaml"), `fep: "2.0"\nidentity:\n  id: test`);
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(path.join(scriptDir, "strategy.py"), "def compute(data): return {}");
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("identity") && e.includes("name"))).toBe(true);
+  });
+
+  it("requires identity.author.name", async () => {
+    writeFileSync(
+      path.join(tmpDir, "fep.yaml"),
+      `
+fep: "2.0"
+identity:
+  id: test
+  name: Test
+  type: strategy
+  version: "1.0.0"
+  style: trend
+  visibility: private
+  summary: "test"
+  description: "test"
+  license: MIT
+  tags: [test]
+  author:
+    wallet: "0x..."
+  changelog:
+    - version: "1.0.0"
+      date: "2025-01-01"
+      changes: "Initial"
+backtest:
+  symbol: "BTC/USDT"
+  defaultPeriod:
+    startDate: "2024-01-01"
+    endDate: "2024-12-31"
+  initialCapital: 10000
+`,
+    );
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(path.join(scriptDir, "strategy.py"), "def compute(data): return {}");
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("author") && e.includes("name"))).toBe(true);
+  });
+
+  // ── style 枚举验证测试 ──
+
+  it("validates style enum values", async () => {
+    writeFileSync(
+      path.join(tmpDir, "fep.yaml"),
+      `
+fep: "2.0"
+identity:
+  id: test
+  name: Test
+  type: strategy
+  version: "1.0.0"
+  style: invalid_style
+  visibility: private
+  summary: "test"
+  description: "test"
+  license: MIT
+  tags: [test]
+  author:
+    name: "Author"
+  changelog:
+    - version: "1.0.0"
+      date: "2025-01-01"
+      changes: "Initial"
+backtest:
+  symbol: "BTC/USDT"
+  defaultPeriod:
+    startDate: "2024-01-01"
+    endDate: "2024-12-31"
+  initialCapital: 10000
+`,
+    );
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(path.join(scriptDir, "strategy.py"), "def compute(data): return {}");
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("style"))).toBe(true);
+  });
+
+  // ── backtest 验证测试 ──
+
+  it("requires backtest.symbol", async () => {
+    writeFileSync(
+      path.join(tmpDir, "fep.yaml"),
+      `
+fep: "2.0"
+identity:
+  id: test
+  name: Test
+  type: strategy
+  version: "1.0.0"
+  style: trend
+  visibility: private
+  summary: "test"
+  description: "test"
+  license: MIT
+  tags: [test]
+  author:
+    name: "Author"
+  changelog:
+    - version: "1.0.0"
+      date: "2025-01-01"
+      changes: "Initial"
+backtest:
+  defaultPeriod:
+    startDate: "2024-01-01"
+    endDate: "2024-12-31"
+  initialCapital: 10000
+`,
+    );
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(path.join(scriptDir, "strategy.py"), "def compute(data): return {}");
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("symbol"))).toBe(true);
+  });
+
+  it("requires backtest.initialCapital", async () => {
+    writeFileSync(
+      path.join(tmpDir, "fep.yaml"),
+      `
+fep: "2.0"
+identity:
+  id: test
+  name: Test
+  type: strategy
+  version: "1.0.0"
+  style: trend
+  visibility: private
+  summary: "test"
+  description: "test"
+  license: MIT
+  tags: [test]
+  author:
+    name: "Author"
+  changelog:
+    - version: "1.0.0"
+      date: "2025-01-01"
+      changes: "Initial"
+backtest:
+  symbol: "BTC/USDT"
+  defaultPeriod:
+    startDate: "2024-01-01"
+    endDate: "2024-12-31"
+`,
+    );
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(path.join(scriptDir, "strategy.py"), "def compute(data): return {}");
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("initialCapital"))).toBe(true);
+  });
+
+  // ── symbol 格式验证测试 ──
+
+  it("recognizes Crypto symbol format (BTC/USDT)", async () => {
+    const dir = createMinimalValidPackage();
+    const result = await validateStrategyPackage(dir);
+    expect(result.valid).toBe(true);
+  });
+
+  it("recognizes A-share symbol format (000001.SZ)", async () => {
+    writeFileSync(
+      path.join(tmpDir, "fep.yaml"),
+      `
+fep: "2.0"
+identity:
+  id: test
+  name: Test
+  type: strategy
+  version: "1.0.0"
+  style: trend
+  visibility: private
+  summary: "test"
+  description: "test"
+  license: MIT
+  tags: [test]
+  author:
+    name: "Author"
+  changelog:
+    - version: "1.0.0"
+      date: "2025-01-01"
+      changes: "Initial"
+backtest:
+  symbol: "000001.SZ"
+  defaultPeriod:
+    startDate: "2024-01-01"
+    endDate: "2024-12-31"
+  initialCapital: 100000
+`,
+    );
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(path.join(scriptDir, "strategy.py"), "def compute(data): return {}");
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(true);
+  });
+
+  it("recognizes US stock symbol format (AAPL)", async () => {
+    writeFileSync(
+      path.join(tmpDir, "fep.yaml"),
+      `
+fep: "2.0"
+identity:
+  id: test
+  name: Test
+  type: strategy
+  version: "1.0.0"
+  style: trend
+  visibility: private
+  summary: "test"
+  description: "test"
+  license: MIT
+  tags: [test]
+  author:
+    name: "Author"
+  changelog:
+    - version: "1.0.0"
+      date: "2025-01-01"
+      changes: "Initial"
+backtest:
+  symbol: "AAPL"
+  defaultPeriod:
+    startDate: "2024-01-01"
+    endDate: "2024-12-31"
+  initialCapital: 10000
+`,
+    );
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(path.join(scriptDir, "strategy.py"), "def compute(data): return {}");
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(true);
+  });
+
+  it("recognizes HK stock symbol format (00700.HK)", async () => {
+    writeFileSync(
+      path.join(tmpDir, "fep.yaml"),
+      `
+fep: "2.0"
+identity:
+  id: test
+  name: Test
+  type: strategy
+  version: "1.0.0"
+  style: trend
+  visibility: private
+  summary: "test"
+  description: "test"
+  license: MIT
+  tags: [test]
+  author:
+    name: "Author"
+  changelog:
+    - version: "1.0.0"
+      date: "2025-01-01"
+      changes: "Initial"
+backtest:
+  symbol: "00700.HK"
+  defaultPeriod:
+    startDate: "2024-01-01"
+    endDate: "2024-12-31"
+  initialCapital: 10000
+`,
+    );
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(path.join(scriptDir, "strategy.py"), "def compute(data): return {}");
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(true);
+  });
+
+  // ── 策略函数验证测试 ──
+
+  it("accepts compute(data) function", async () => {
+    const dir = createMinimalValidPackage();
+    const result = await validateStrategyPackage(dir);
+    expect(result.valid).toBe(true);
+  });
+
+  it("accepts compute(data, context=None) function", async () => {
+    const dir = createMinimalValidPackage();
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    writeFileSync(
+      path.join(scriptDir, "strategy.py"),
+      `
+def compute(data, context=None):
+    position = context.get("position") if context else None
+    return {"action": "hold", "amount": 0, "price": 0, "reason": "test"}
+`,
+    );
+
+    const result = await validateStrategyPackage(dir);
+    expect(result.valid).toBe(true);
+  });
+
+  it("accepts select(universe) function for multi-asset strategies", async () => {
+    writeFileSync(
+      path.join(tmpDir, "fep.yaml"),
+      `
+fep: "2.0"
+identity:
+  id: test-rotation
+  name: "Rotation Strategy"
+  type: strategy
+  version: "1.0.0"
+  style: rotation
+  visibility: private
+  summary: "test"
+  description: "test"
+  license: MIT
+  tags: [test]
+  author:
+    name: "Author"
+  changelog:
+    - version: "1.0.0"
+      date: "2025-01-01"
+      changes: "Initial"
+backtest:
+  symbol: "000001.SZ"
+  universe:
+    symbols:
+      - "000001.SZ"
+      - "000002.SZ"
+      - "600519.SH"
+  defaultPeriod:
+    startDate: "2024-01-01"
+    endDate: "2024-12-31"
+  initialCapital: 1000000
+`,
+    );
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(
+      path.join(scriptDir, "strategy.py"),
+      `
+import numpy as np
+
+def select(universe):
+    scores = []
+    for symbol, df in universe.items():
+        close = df["close"].values
+        if len(close) >= 20:
+            momentum = (close[-1] / close[-20]) - 1
+            scores.append((symbol, momentum))
+    scores.sort(key=lambda x: x[1], reverse=True)
+    return [s[0] for s in scores]
+`,
+    );
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(true);
+  });
+
+  it("rejects strategy without compute or select function", async () => {
+    writeFileSync(
+      path.join(tmpDir, "fep.yaml"),
+      `
+fep: "2.0"
+identity:
+  id: test
+  name: Test
+  type: strategy
+  version: "1.0.0"
+  style: trend
+  visibility: private
+  summary: "test"
+  description: "test"
+  license: MIT
+  tags: [test]
+  author:
+    name: "Author"
+  changelog:
+    - version: "1.0.0"
+      date: "2025-01-01"
+      changes: "Initial"
+backtest:
+  symbol: "BTC/USDT"
+  defaultPeriod:
+    startDate: "2024-01-01"
+    endDate: "2024-12-31"
+  initialCapital: 10000
+`,
+    );
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(
+      path.join(scriptDir, "strategy.py"),
+      `
+# No compute or select function
+def helper():
+    pass
+`,
+    );
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("compute") || e.includes("select"))).toBe(true);
+  });
+
+  // ── 安全沙箱测试 ──
+
+  it("rejects forbidden import os", async () => {
+    const dir = createMinimalValidPackage();
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    writeFileSync(
+      path.join(scriptDir, "strategy.py"),
+      `
+import os
+
+def compute(data):
+    return {"action": "hold"}
+`,
+    );
+
+    const result = await validateStrategyPackage(dir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("禁止的导入") && e.includes("os"))).toBe(true);
+  });
+
+  it("rejects forbidden eval() call", async () => {
+    const dir = createMinimalValidPackage();
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    writeFileSync(
+      path.join(scriptDir, "strategy.py"),
+      `
+def compute(data):
+    result = eval("1 + 1")
+    return {"action": "hold"}
+`,
+    );
+
+    const result = await validateStrategyPackage(dir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("禁止的函数调用") && e.includes("eval"))).toBe(
+      true,
+    );
+  });
+
+  it("rejects datetime.now() that breaks backtest consistency", async () => {
+    const dir = createMinimalValidPackage();
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    writeFileSync(
+      path.join(scriptDir, "strategy.py"),
+      `
+import datetime
+
+def compute(data):
+    now = datetime.datetime.now()
+    return {"action": "hold"}
+`,
+    );
+
+    const result = await validateStrategyPackage(dir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("datetime.now") && e.includes("回测一致性"))).toBe(
+      true,
+    );
+  });
+
+  it("ignores datetime.now() in comments", async () => {
+    const dir = createMinimalValidPackage();
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    writeFileSync(
+      path.join(scriptDir, "strategy.py"),
+      `
+# Note: do not use datetime.now() in production
+def compute(data):
+    return {"action": "hold"}
+`,
+    );
+
+    const result = await validateStrategyPackage(dir);
+    expect(result.valid).toBe(true);
+  });
+
+  it("rejects forbidden requests import", async () => {
+    const dir = createMinimalValidPackage();
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    writeFileSync(
+      path.join(scriptDir, "strategy.py"),
+      `
+import requests
+
+def compute(data):
+    return {"action": "hold"}
+`,
+    );
+
+    const result = await validateStrategyPackage(dir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("requests"))).toBe(true);
+  });
+
+  // ── timeframe 验证测试 ──
+
+  it("validates timeframe enum values", async () => {
+    writeFileSync(
+      path.join(tmpDir, "fep.yaml"),
+      `
+fep: "2.0"
+identity:
+  id: test
+  name: Test
+  type: strategy
+  version: "1.0.0"
+  style: trend
+  visibility: private
+  summary: "test"
+  description: "test"
+  license: MIT
+  tags: [test]
+  author:
+    name: "Author"
+  changelog:
+    - version: "1.0.0"
+      date: "2025-01-01"
+      changes: "Initial"
+backtest:
+  symbol: "BTC/USDT"
+  timeframe: 1h
+  defaultPeriod:
+    startDate: "2024-01-01"
+    endDate: "2024-12-31"
+  initialCapital: 10000
+`,
+    );
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(path.join(scriptDir, "strategy.py"), "def compute(data): return {}");
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(true);
+  });
+
+  it("rejects invalid timeframe value", async () => {
+    writeFileSync(
+      path.join(tmpDir, "fep.yaml"),
+      `
+fep: "2.0"
+identity:
+  id: test
+  name: Test
+  type: strategy
+  version: "1.0.0"
+  style: trend
+  visibility: private
+  summary: "test"
+  description: "test"
+  license: MIT
+  tags: [test]
+  author:
+    name: "Author"
+  changelog:
+    - version: "1.0.0"
+      date: "2025-01-01"
+      changes: "Initial"
+backtest:
+  symbol: "BTC/USDT"
+  timeframe: 2h
+  defaultPeriod:
+    startDate: "2024-01-01"
+    endDate: "2024-12-31"
+  initialCapital: 10000
+`,
+    );
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(path.join(scriptDir, "strategy.py"), "def compute(data): return {}");
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(false);
+    expect(result.errors.some((e) => e.includes("timeframe"))).toBe(true);
+  });
+
+  // ── 完整配置测试 ──
+
+  it("accepts full configuration with all optional fields", async () => {
+    writeFileSync(
+      path.join(tmpDir, "fep.yaml"),
+      `
+fep: "2.0"
+identity:
+  id: fin-full-test
+  name: "Full Test Strategy"
+  type: strategy
+  version: "1.0.0"
+  style: hybrid
+  visibility: public
+  summary: "A comprehensive test strategy"
+  description: "Full configuration test with all optional fields"
+  license: MIT
+  tags: [test, full, hybrid]
+  author:
+    name: "Test Author"
+    wallet: "0x1234567890abcdef"
+  changelog:
+    - version: "1.0.0"
+      date: "2025-01-01"
+      changes: "Initial release"
+technical:
+  language: python
+  entryPoint: strategy.py
+parameters:
+  - name: fast_period
+    default: 12
+    type: integer
+    label: "快速周期"
+    range: { min: 5, max: 50 }
+  - name: slow_period
+    default: 26
+    type: integer
+    label: "慢速周期"
+backtest:
+  symbol: "BTC/USDT"
+  timeframe: 4h
+  defaultPeriod:
+    startDate: "2023-01-01"
+    endDate: "2024-12-31"
+  initialCapital: 50000
+risk:
+  maxDrawdownThreshold: 20
+  dailyLossLimitPct: 5
+  maxTradesPerDay: 10
+paper:
+  barIntervalSeconds: 60
+  maxDurationHours: 24
+  warmupBars: 100
+  timeframe: 1h
+classification:
+  archetype: systematic
+  market: Crypto
+  assetClasses: [crypto]
+  frequency: daily
+  riskProfile: medium
+`,
+    );
+
+    const scriptDir = path.join(tmpDir, "scripts");
+    mkdirSync(scriptDir, { recursive: true });
+    writeFileSync(
+      path.join(scriptDir, "strategy.py"),
+      `
+import numpy as np
+import pandas as pd
+
+def compute(data, context=None):
+    close = data["close"].values
+    price = float(close[-1])
+    ma20 = float(np.mean(close[-20:])) if len(close) >= 20 else price
+
+    has_position = context and context.get("position") is not None
+
+    if not has_position and price > ma20:
+        return {"action": "buy", "amount": 1000, "price": price, "reason": "Price above MA20"}
+    elif has_position and price < ma20:
+        return {"action": "sell", "reason": "Price below MA20"}
+
+    return {"action": "hold", "reason": f"MA20={ma20:.2f}"}
+`,
+    );
+
+    const result = await validateStrategyPackage(tmpDir);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toEqual([]);
+  });
+});