alpaca-mock 0.30.0

Executable mock server for alpaca-rust trading and market-data flows
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

use alpaca_trade::calendar::{
    Calendar, CalendarDay, CalendarMarket, CalendarTimezone, CalendarV3Response, Market,
};

pub(crate) fn legacy_catalog() -> Vec<Calendar> {
    vec![Calendar {
        date: "2026-07-13".to_owned(),
        open: "09:30".to_owned(),
        close: "16:00".to_owned(),
        session_open: "04:00".to_owned(),
        session_close: "20:00".to_owned(),
        settlement_date: "2026-07-14".to_owned(),
    }]
}

pub(crate) fn v3_calendar(
    market: Market,
    start: Option<chrono::NaiveDate>,
    end: Option<chrono::NaiveDate>,
    timezone: Option<CalendarTimezone>,
) -> CalendarV3Response {
    let date = chrono::NaiveDate::from_ymd_opt(2026, 7, 13).expect("mock date should be valid");
    let included = start.is_none_or(|start| date >= start) && end.is_none_or(|end| date <= end);
    let utc = timezone == Some(CalendarTimezone::Utc);
    let (pre_start, pre_end, core_start, core_end, post_start, post_end) = if utc {
        (
            "2026-07-13T08:00:00Z",
            "2026-07-13T13:30:00Z",
            "2026-07-13T13:30:00Z",
            "2026-07-13T20:00:00Z",
            "2026-07-13T20:00:00Z",
            "2026-07-14T00:00:00Z",
        )
    } else {
        (
            "2026-07-13T04:00:00-04:00",
            "2026-07-13T09:30:00-04:00",
            "2026-07-13T09:30:00-04:00",
            "2026-07-13T16:00:00-04:00",
            "2026-07-13T16:00:00-04:00",
            "2026-07-13T20:00:00-04:00",
        )
    };

    CalendarV3Response {
        market: CalendarMarket {
            mic: (market == Market::NYSE).then(|| "XNYS".to_owned()),
            bic: None,
            acronym: market.to_string(),
            name: if market == Market::NYSE {
                "New York Stock Exchange".to_owned()
            } else {
                market.to_string()
            },
            timezone: if market == Market::NYSE {
                "America/New_York".to_owned()
            } else {
                "UTC".to_owned()
            },
        },
        calendar: included
            .then(|| CalendarDay {
                date: "2026-07-13".to_owned(),
                pre_start: Some(pre_start.to_owned()),
                pre_end: Some(pre_end.to_owned()),
                lunch_start: None,
                lunch_end: None,
                core_start: core_start.to_owned(),
                core_end: core_end.to_owned(),
                post_start: Some(post_start.to_owned()),
                post_end: Some(post_end.to_owned()),
                settlement_date: Some("2026-07-14".to_owned()),
            })
            .into_iter()
            .collect(),
    }
}