Skip to main content

barter_execution/exchange/mock/
request.rs

1use crate::{
2    UnindexedAccountSnapshot,
3    balance::AssetBalance,
4    error::UnindexedOrderError,
5    order::{
6        Order,
7        request::{OrderRequestCancel, OrderRequestOpen, UnindexedOrderResponseCancel},
8        state::Open,
9    },
10    trade::Trade,
11};
12use barter_instrument::{
13    asset::{QuoteAsset, name::AssetNameExchange},
14    exchange::ExchangeId,
15    instrument::name::InstrumentNameExchange,
16};
17use chrono::{DateTime, Utc};
18use tokio::sync::oneshot;
19
20#[derive(Debug)]
21pub struct MockExchangeRequest {
22    pub time_request: DateTime<Utc>,
23    pub kind: MockExchangeRequestKind,
24}
25
26impl MockExchangeRequest {
27    pub fn new(time_request: DateTime<Utc>, kind: MockExchangeRequestKind) -> Self {
28        Self { time_request, kind }
29    }
30
31    pub fn fetch_account_snapshot(
32        time_request: DateTime<Utc>,
33        response_tx: oneshot::Sender<UnindexedAccountSnapshot>,
34    ) -> Self {
35        Self::new(
36            time_request,
37            MockExchangeRequestKind::FetchAccountSnapshot { response_tx },
38        )
39    }
40
41    pub fn fetch_balances(
42        time_request: DateTime<Utc>,
43        assets: Vec<AssetNameExchange>,
44        response_tx: oneshot::Sender<Vec<AssetBalance<AssetNameExchange>>>,
45    ) -> Self {
46        Self::new(
47            time_request,
48            MockExchangeRequestKind::FetchBalances {
49                response_tx,
50                assets,
51            },
52        )
53    }
54
55    pub fn fetch_orders_open(
56        time_request: DateTime<Utc>,
57        instruments: Vec<InstrumentNameExchange>,
58        response_tx: oneshot::Sender<Vec<Order<ExchangeId, InstrumentNameExchange, Open>>>,
59    ) -> Self {
60        Self::new(
61            time_request,
62            MockExchangeRequestKind::FetchOrdersOpen {
63                response_tx,
64                instruments,
65            },
66        )
67    }
68
69    pub fn fetch_trades(
70        time_request: DateTime<Utc>,
71        response_tx: oneshot::Sender<Vec<Trade<QuoteAsset, InstrumentNameExchange>>>,
72        time_since: DateTime<Utc>,
73    ) -> Self {
74        Self::new(
75            time_request,
76            MockExchangeRequestKind::FetchTrades {
77                response_tx,
78                time_since,
79            },
80        )
81    }
82
83    pub fn cancel_order(
84        time_request: DateTime<Utc>,
85        response_tx: oneshot::Sender<UnindexedOrderResponseCancel>,
86        request: OrderRequestCancel<ExchangeId, InstrumentNameExchange>,
87    ) -> Self {
88        Self::new(
89            time_request,
90            MockExchangeRequestKind::CancelOrder {
91                response_tx,
92                request,
93            },
94        )
95    }
96
97    pub fn open_order(
98        time_request: DateTime<Utc>,
99        response_tx: oneshot::Sender<
100            Order<ExchangeId, InstrumentNameExchange, Result<Open, UnindexedOrderError>>,
101        >,
102        request: OrderRequestOpen<ExchangeId, InstrumentNameExchange>,
103    ) -> Self {
104        Self::new(
105            time_request,
106            MockExchangeRequestKind::OpenOrder {
107                response_tx,
108                request,
109            },
110        )
111    }
112}
113
114#[derive(Debug)]
115pub enum MockExchangeRequestKind {
116    FetchAccountSnapshot {
117        response_tx: oneshot::Sender<UnindexedAccountSnapshot>,
118    },
119    FetchBalances {
120        assets: Vec<AssetNameExchange>,
121        response_tx: oneshot::Sender<Vec<AssetBalance<AssetNameExchange>>>,
122    },
123    FetchOrdersOpen {
124        instruments: Vec<InstrumentNameExchange>,
125        response_tx: oneshot::Sender<Vec<Order<ExchangeId, InstrumentNameExchange, Open>>>,
126    },
127    FetchTrades {
128        response_tx: oneshot::Sender<Vec<Trade<QuoteAsset, InstrumentNameExchange>>>,
129        time_since: DateTime<Utc>,
130    },
131    CancelOrder {
132        response_tx: oneshot::Sender<UnindexedOrderResponseCancel>,
133        request: OrderRequestCancel<ExchangeId, InstrumentNameExchange>,
134    },
135    OpenOrder {
136        response_tx: oneshot::Sender<
137            Order<ExchangeId, InstrumentNameExchange, Result<Open, UnindexedOrderError>>,
138        >,
139        request: OrderRequestOpen<ExchangeId, InstrumentNameExchange>,
140    },
141}