明确红利账务再投来源并修复流式遗漏与校正时钟

2026-09-14 22:30:05 +08:00
parent fbc4233dcd
commit 984f9d308d
11 changed files with 681 additions and 140 deletions
@@ -0,0 +1,328 @@
+use chrono::{NaiveDate, NaiveTime};
+use fidc_core::{
+    BacktestConfig, BacktestEngine, BrokerSimulator, ChinaAShareCostModel, ChinaEquityRuleHooks,
+    DataSet, MatchingType, OrderIntent, PriceField, Strategy, StrategyContext, StrategyDecision,
+};
+use std::{cell::RefCell, collections::BTreeSet, rc::Rc};
+
+const SYMBOL: &str = "000001.SZ";
+fn day(value: u32) -> NaiveDate {
+    NaiveDate::from_ymd_opt(2026, 9, value).unwrap()
+}
+
+fn data() -> DataSet {
+    let days = [11, 14, 15].map(day);
+    DataSet::from_components_with_actions_and_quotes(
+        vec![fidc_core::Instrument {
+            symbol: SYMBOL.into(),
+            name: "fixture".into(),
+            board: "SZ".into(),
+            round_lot: 100,
+            listed_at: Some(day(1)),
+            delisted_at: None,
+            status: "active".into(),
+        }],
+        days.iter()
+            .map(|&date| {
+                let price = if date == day(11) { 10. } else { 8.95 };
+                fidc_core::DailyMarketSnapshot {
+                    date,
+                    symbol: SYMBOL.into(),
+                    timestamp: Some(format!("{date} 15:00:00")),
+                    day_open: price,
+                    open: price,
+                    high: price,
+                    low: price,
+                    close: price,
+                    last_price: price,
+                    bid1: price,
+                    ask1: price,
+                    prev_close: price,
+                    volume: 100000,
+                    minute_volume: 100000,
+                    bid1_volume: 100000,
+                    ask1_volume: 100000,
+                    trading_phase: Some("continuous".into()),
+                    paused: false,
+                    upper_limit: price * 1.1,
+                    lower_limit: price * 0.9,
+                    price_tick: 0.01,
+                }
+            })
+            .collect(),
+        days.iter()
+            .map(|&date| fidc_core::DailyFactorSnapshot {
+                date,
+                symbol: SYMBOL.into(),
+                market_cap_bn: 10.,
+                free_float_cap_bn: 10.,
+                pe_ttm: 10.,
+                turnover_ratio: None,
+                effective_turnover_ratio: None,
+                adjustment_factor_backward1: Some(1.),
+                extra_factors: Default::default(),
+            })
+            .collect(),
+        days.iter()
+            .map(|&date| fidc_core::CandidateEligibility {
+                date,
+                symbol: SYMBOL.into(),
+                is_st: false,
+                is_star_st: false,
+                is_new_listing: false,
+                is_paused: false,
+                allow_buy: true,
+                allow_sell: true,
+                is_kcb: false,
+                is_one_yuan: false,
+                risk_level_code: None,
+            })
+            .collect(),
+        days.iter()
+            .map(|&date| fidc_core::BenchmarkSnapshot {
+                date,
+                benchmark: "000300.SH".into(),
+                open: 100.,
+                close: 100.,
+                prev_close: 100.,
+                volume: 100000,
+            })
+            .collect(),
+        vec![fidc_core::CorporateAction {
+            date: day(14),
+            symbol: SYMBOL.into(),
+            payable_date: Some(day(14)),
+            share_cash: 1.05,
+            share_bonus: 0.,
+            share_gift: 0.,
+            issue_quantity: 0.,
+            issue_price: 0.,
+            reform: false,
+            adjust_factor: None,
+            successor_symbol: None,
+            successor_ratio: None,
+            successor_cash: None,
+        }],
+        [(9, 15), (9, 31)]
+            .into_iter()
+            .map(|(hour, minute)| fidc_core::IntradayExecutionQuote {
+                observation_kind: fidc_core::data::QuoteObservationKind::MinuteBar,
+                date: day(14),
+                symbol: SYMBOL.into(),
+                timestamp: day(14).and_hms_opt(hour, minute, 0).unwrap(),
+                last_price: 8.95,
+                bid1: 8.95,
+                ask1: 8.95,
+                bid1_volume: 100000,
+                ask1_volume: 100000,
+                volume_delta: 10000,
+                amount_delta: 89500.,
+                trading_phase: Some("continuous".into()),
+            })
+            .collect(),
+    )
+    .unwrap()
+}
+
+struct Hold {
+    seen: Rc<RefCell<Vec<(NaiveTime, u32)>>>,
+}
+impl Strategy for Hold {
+    fn name(&self) -> &str {
+        "accounting reinvestment contract"
+    }
+    fn initial_subscriptions(&self) -> BTreeSet<String> {
+        [SYMBOL.into()].into()
+    }
+    fn on_day(
+        &mut self,
+        ctx: &StrategyContext<'_>,
+    ) -> Result<StrategyDecision, fidc_core::BacktestError> {
+        Ok(if ctx.execution_date == day(11) {
+            StrategyDecision {
+                order_intents: vec![OrderIntent::Shares {
+                    symbol: SYMBOL.into(),
+                    quantity: 1000,
+                    reason: "initial".into(),
+                }],
+                ..Default::default()
+            }
+        } else {
+            StrategyDecision::default()
+        })
+    }
+    fn on_minute(
+        &mut self,
+        ctx: &StrategyContext<'_>,
+        _: &fidc_core::IntradayExecutionQuote,
+    ) -> Result<StrategyDecision, fidc_core::BacktestError> {
+        self.seen.borrow_mut().push((
+            ctx.current_time().unwrap(),
+            ctx.portfolio
+                .position(SYMBOL)
+                .map_or(0, |position| position.quantity),
+        ));
+        Ok(Default::default())
+    }
+}
+
+fn engine() -> BacktestEngine<Hold, ChinaAShareCostModel, ChinaEquityRuleHooks> {
+    BacktestEngine::new(
+        data(),
+        Hold {
+            seen: Rc::new(RefCell::new(Vec::new())),
+        },
+        BrokerSimulator::new_with_execution_price(
+            ChinaAShareCostModel::default()
+                .with_commission_rate(0.0008)
+                .with_minimum_commission(0.),
+            ChinaEquityRuleHooks,
+            PriceField::Open,
+        )
+        .with_matching_type(MatchingType::NextBarOpen)
+        .with_volume_limit(false)
+        .with_liquidity_limit(false),
+        BacktestConfig {
+            initial_cash: 50000.,
+            benchmark_code: "000300.SH".into(),
+            start_date: Some(day(11)),
+            end_date: Some(day(15)),
+            decision_lag_trading_days: 0,
+            execution_price_field: PriceField::Open,
+        },
+    )
+    .with_dividend_reinvestment(true)
+}
+
+#[test]
+fn accounting_reinvestment_has_an_explicit_origin_clock_and_progress_delivery() {
+    let mut progress = Vec::new();
+    let result = engine()
+        .run_with_progress(|event| progress.push(event.clone()))
+        .unwrap();
+    let reinvest = result
+        .fills
+        .iter()
+        .find(|fill| fill.reason == "dividend_reinvestment")
+        .unwrap();
+    assert_eq!(
+        (
+            reinvest.quantity,
+            reinvest.price,
+            reinvest.commission,
+            reinvest.order_id
+        ),
+        (100, 8.95, 0., None)
+    );
+    assert_eq!(
+        serde_json::to_value(reinvest).unwrap()["origin"],
+        "dividend_reinvestment"
+    );
+    assert_eq!(reinvest.execution_timestamp, day(14).and_hms_opt(0, 0, 0));
+    let received = progress.iter().find(|event| event.date == day(14)).unwrap();
+    assert!(
+        received
+            .fills
+            .iter()
+            .any(|fill| fill.reason == "dividend_reinvestment")
+    );
+    assert_eq!(
+        progress
+            .iter()
+            .map(|event| event.daily_fill_count)
+            .sum::<usize>(),
+        result.fills.len()
+    );
+}
+
+fn manual_source(delayed: bool) -> fidc_core::manual_execution::ManualExecutionReplay {
+    let observed = if delayed {
+        "2026-09-14T01:15:00Z"
+    } else {
+        "2026-09-11T06:00:01Z"
+    };
+    let mut source: fidc_core::manual_execution::ManualExecutionReplay = serde_json::from_value(serde_json::json!({
+        "schema":fidc_core::manual_execution::MANUAL_REPLAY_SCHEMA,"runtimeId":"r","accountId":"a","sourceContractSha256":"a".repeat(64),"contentSha256":"",
+        "observationCutoff":"2026-09-15T08:00:00Z","actions":[{"actionId":"manual","source":"manual_security_trade","auditEventIds":["audit"],
+            "confirmedAt":"2026-09-11T05:59:59Z","confirmationObservedAt":"2026-09-11T05:59:59Z","outcome":"orders_terminal","orders":[{
+                "orderId":"manual-order","sourceAdapter":"paper","symbol":SYMBOL,"side":"Buy","quantity":1000,
+                "orderCreatedAt":"2026-09-11T05:59:59Z","terminalObservedAt":observed,"terminalStatus":"filled","fills":[{
+                    "tradeId":"manual-fill","observationEventId":"receipt","observationSequence":1,"feeObservationEventId":"receipt","feeObservationSequence":1,
+                    "feeObservedAt":observed,"tradeDate":"2026-09-11","executedAt":"2026-09-11T06:00:00Z","observedAt":observed,
+                    "timestampPrecision":"second","quantity":1000,"price":"10","totalFee":"1"
+                }]
+            }]}]
+    })).unwrap();
+    source.content_sha256 = source.content_digest().unwrap();
+    source
+}
+
+#[test]
+fn delayed_receipt_before_market_open_reconciles_accounting_not_future_market_fills() {
+    let timely = engine()
+        .with_observed_manual_executions(manual_source(false))
+        .unwrap()
+        .run()
+        .unwrap();
+    let delayed = engine()
+        .with_observed_manual_executions(manual_source(true))
+        .unwrap()
+        .run()
+        .unwrap();
+    assert_eq!(delayed.holdings_summary[0].quantity, 2200);
+    assert_eq!(
+        delayed.holdings_summary[0].quantity,
+        timely.holdings_summary[0].quantity
+    );
+    assert_eq!(
+        delayed.equity_curve.last().unwrap().cash,
+        timely.equity_curve.last().unwrap().cash
+    );
+    assert_eq!(
+        delayed.manual_executions[0]
+            .corporate_adjustment
+            .as_ref()
+            .unwrap()
+            .corporate_cash_delta,
+        "155"
+    );
+}
+
+#[test]
+fn weekend_receipts_and_morning_allocations_are_in_the_next_progress_batch() {
+    let mut source = manual_source(true);
+    let observed = "2026-09-12T02:00:00Z".parse().unwrap();
+    let order = &mut source.actions[0].orders[0];
+    order.terminal_observed_at = observed;
+    order.fills[0].observed_at = observed;
+    order.fills[0].fee_observed_at = observed;
+    source.content_sha256 = source.content_digest().unwrap();
+    let mut progress = Vec::new();
+    let result = engine()
+        .with_observed_manual_executions(source)
+        .unwrap()
+        .run_with_progress(|event| progress.push(event.clone()))
+        .unwrap();
+    let monday = progress.iter().find(|event| event.date == day(14)).unwrap();
+    assert_eq!(monday.daily_manual_fill_count, 1);
+    assert_eq!(monday.manual_executions[0].observed_at, observed);
+    assert!(
+        monday
+            .fills
+            .iter()
+            .any(|fill| fill.origin == fidc_core::FillOrigin::DividendReinvestment)
+    );
+    assert!(
+        monday
+            .process_events
+            .iter()
+            .any(|event| event.kind == fidc_core::ProcessEventKind::ManualExecutionObserved)
+    );
+    assert_eq!(
+        progress
+            .iter()
+            .map(|event| event.daily_fill_count)
+            .sum::<usize>(),
+        result.fills.len() + result.manual_executions.len()
+    );
+}