1pub mod models {
6 #![allow(warnings)]
7 include!(concat!(env!("OUT_DIR"), "/hyperflow.core.v1.rs"));
8}
9
10#[cfg(test)]
11mod tests {
12 use super::models::{HyperliquidTrade, RawTrade, MarketType, EnrichedTrade, Position};
13 use prost::Message;
14
15 #[test]
16 fn test_create_hyperliquid_trade() {
17 let trade = HyperliquidTrade {
18 coin: "ETH".to_string(),
19 side: "buy".to_string(),
20 px: "123.45".to_string(),
21 sz: "1.0".to_string(),
22 hash: "0xabc123".to_string(),
23 time: 1678886400,
24 tid: 1,
25 users: vec!["buyer_address".to_string(), "seller_address".to_string()],
26 };
27
28 assert_eq!(trade.coin, "ETH");
29 assert_eq!(trade.side, "buy");
30 assert_eq!(trade.px, "123.45");
31 assert_eq!(trade.sz, "1.0");
32 assert_eq!(trade.hash, "0xabc123");
33 assert_eq!(trade.time, 1678886400);
34 assert_eq!(trade.tid, 1);
35 assert_eq!(trade.users, vec!["buyer_address", "seller_address"]);
36 }
37
38 #[test]
39 fn test_hyperliquid_trade_serialization() {
40 let trade = HyperliquidTrade {
41 coin: "BTC".to_string(),
42 side: "sell".to_string(),
43 px: "456.78".to_string(),
44 sz: "0.5".to_string(),
45 hash: "0xdef456".to_string(),
46 time: 1678886500,
47 tid: 2,
48 users: vec!["userA".to_string(), "userB".to_string()],
49 };
50
51 let mut buf = Vec::new();
52 trade.encode(&mut buf).unwrap();
53 let deserialized_trade = HyperliquidTrade::decode(&buf[..]).unwrap();
54
55 assert_eq!(deserialized_trade.coin, "BTC");
56 assert_eq!(deserialized_trade.side, "sell");
57 assert_eq!(deserialized_trade.px, "456.78");
58 assert_eq!(deserialized_trade.sz, "0.5");
59 assert_eq!(deserialized_trade.hash, "0xdef456");
60 assert_eq!(deserialized_trade.time, 1678886500);
61 assert_eq!(deserialized_trade.tid, 2);
62 assert_eq!(deserialized_trade.users, vec!["userA", "userB"]);
63 }
64
65 #[test]
66 fn test_create_raw_trade() {
67 let raw_trade = RawTrade {
68 symbol: "BTC/USD".to_string(),
69 is_buy: true,
70 is_taker: false,
71 price: "50000.0".to_string(),
72 amount: "0.1".to_string(),
73 quote_amount: "5000.0".to_string(),
74 event_at: 1678887000,
75 transaction_id: "ext-xyz".to_string(),
76 wallet_address: "0x12345".to_string(),
77 market_type: MarketType::Perp as i32,
78 };
79
80 assert_eq!(raw_trade.symbol, "BTC/USD");
81 assert!(raw_trade.is_buy);
82 assert!(!raw_trade.is_taker);
83 assert_eq!(raw_trade.price, "50000.0");
84 assert_eq!(raw_trade.amount, "0.1");
85 assert_eq!(raw_trade.quote_amount, "5000.0");
86 assert_eq!(raw_trade.event_at, 1678887000);
87 assert_eq!(raw_trade.transaction_id, "ext-xyz");
88 assert_eq!(raw_trade.wallet_address, "0x12345");
89 assert_eq!(raw_trade.market_type, MarketType::Perp as i32);
90 }
91
92 #[test]
93 fn test_raw_trade_serialization() {
94 let raw_trade = RawTrade {
95 symbol: "ETH/USD".to_string(),
96 is_buy: false,
97 is_taker: true,
98 price: "2000.0".to_string(),
99 amount: "0.5".to_string(),
100 quote_amount: "1000.0".to_string(),
101 event_at: 1678887100,
102 transaction_id: "ext-uvw".to_string(),
103 wallet_address: "0x67890".to_string(),
104 market_type: MarketType::Spot as i32,
105 };
106
107 let mut buf = Vec::new();
108 raw_trade.encode(&mut buf).unwrap();
109 let deserialized_raw_trade = RawTrade::decode(&buf[..]).unwrap();
110
111 assert_eq!(deserialized_raw_trade.symbol, "ETH/USD");
112 assert!(!deserialized_raw_trade.is_buy);
113 assert!(deserialized_raw_trade.is_taker);
114 assert_eq!(deserialized_raw_trade.price, "2000.0");
115 assert_eq!(deserialized_raw_trade.amount, "0.5");
116 assert_eq!(deserialized_raw_trade.quote_amount, "1000.0");
117 assert_eq!(deserialized_raw_trade.event_at, 1678887100);
118 assert_eq!(deserialized_raw_trade.transaction_id, "ext-uvw");
119 assert_eq!(deserialized_raw_trade.wallet_address, "0x67890");
120 assert_eq!(deserialized_raw_trade.market_type, MarketType::Spot as i32);
121 }
122
123 #[test]
124 fn test_hyperliquid_trade_default_values() {
125 let trade = HyperliquidTrade::default();
126 assert_eq!(trade.coin, "");
127 assert_eq!(trade.side, "");
128 assert_eq!(trade.px, "");
129 assert_eq!(trade.sz, "");
130 assert_eq!(trade.hash, "");
131 assert_eq!(trade.time, 0);
132 assert_eq!(trade.tid, 0);
133 assert!(trade.users.is_empty());
134 }
135
136 #[test]
137 fn test_create_hyperliquid_trade_zero_values() {
138 let trade = HyperliquidTrade {
139 px: "0.0".to_string(),
140 sz: "0.0".to_string(),
141 users: vec!["buyer_address".to_string()],
142 ..Default::default()
143 };
144 assert_eq!(trade.px, "0.0");
145 assert_eq!(trade.sz, "0.0");
146 assert_eq!(trade.users, vec!["buyer_address"]);
147 }
148
149 #[test]
150 fn test_raw_trade_default_values() {
151 let raw_trade = RawTrade::default();
152 assert_eq!(raw_trade.symbol, "");
153 assert!(!raw_trade.is_buy);
154 assert!(!raw_trade.is_taker);
155 assert_eq!(raw_trade.price, "");
156 assert_eq!(raw_trade.amount, "");
157 assert_eq!(raw_trade.quote_amount, "");
158 assert_eq!(raw_trade.event_at, 0);
159 assert_eq!(raw_trade.transaction_id, "");
160 assert_eq!(raw_trade.wallet_address, "");
161 assert_eq!(raw_trade.market_type, MarketType::Perp as i32); }
163
164 #[test]
165 fn test_create_raw_trade_zero_values() {
166 let raw_trade = RawTrade {
167 price: "0.0".to_string(),
168 amount: "0.0".to_string(),
169 quote_amount: "0.0".to_string(),
170 transaction_id: "".to_string(),
171 wallet_address: "".to_string(),
172 market_type: MarketType::Perp as i32,
173 ..Default::default()
174 };
175 assert_eq!(raw_trade.price, "0.0");
176 assert_eq!(raw_trade.amount, "0.0");
177 assert_eq!(raw_trade.quote_amount, "0.0");
178 assert_eq!(raw_trade.transaction_id, "");
179 assert_eq!(raw_trade.wallet_address, "");
180 }
181
182 #[test]
183 fn test_raw_trade_serialization_all_market_types() {
184 let market_types = [
185 MarketType::Perp,
186 MarketType::Spot,
187 ];
188 for mt in market_types.iter() {
189 let raw_trade = RawTrade {
190 symbol: "XRP/USD".to_string(),
191 is_buy: true,
192 is_taker: false,
193 price: "0.5".to_string(),
194 amount: "100.0".to_string(),
195 quote_amount: "50.0".to_string(),
196 event_at: 1678887300,
197 transaction_id: "ext-test".to_string(),
198 wallet_address: "0xabcde".to_string(),
199 market_type: *mt as i32,
200 };
201
202 let mut buf = Vec::new();
203 raw_trade.encode(&mut buf).unwrap();
204 let deserialized_raw_trade = RawTrade::decode(&buf[..]).unwrap();
205 assert_eq!(deserialized_raw_trade.market_type, *mt as i32);
206 }
207 }
208
209 #[test]
210 fn test_market_type_enum() {
211 assert_eq!(MarketType::Perp as i32, 0); assert_eq!(MarketType::Spot as i32, 1); }
214
215 #[test]
216 fn test_create_enriched_trade() {
217 let enriched_trade = EnrichedTrade {
218 symbol: "BTC/USD".to_string(),
219 is_buy: true,
220 is_taker: false,
221 price: "50000.0".to_string(),
222 amount: "0.1".to_string(),
223 quote_amount: "5000.0".to_string(),
224 event_at: 1678887000,
225 transaction_id: "ext-xyz".to_string(),
226 wallet_address: "0x12345".to_string(),
227 market_type: MarketType::Perp as i32,
228 pnl: "100.0".to_string(),
229 pnl_usd: "100.0".to_string(),
230 holding_duration: 3600,
231 };
232
233 assert_eq!(enriched_trade.symbol, "BTC/USD");
234 assert!(enriched_trade.is_buy);
235 assert!(!enriched_trade.is_taker);
236 assert_eq!(enriched_trade.price, "50000.0");
237 assert_eq!(enriched_trade.amount, "0.1");
238 assert_eq!(enriched_trade.quote_amount, "5000.0");
239 assert_eq!(enriched_trade.event_at, 1678887000);
240 assert_eq!(enriched_trade.transaction_id, "ext-xyz");
241 assert_eq!(enriched_trade.wallet_address, "0x12345");
242 assert_eq!(enriched_trade.market_type, MarketType::Perp as i32);
243 assert_eq!(enriched_trade.pnl, "100.0");
244 assert_eq!(enriched_trade.pnl_usd, "100.0");
245 assert_eq!(enriched_trade.holding_duration, 3600);
246 }
247
248 #[test]
249 fn test_enriched_trade_default_values() {
250 let enriched_trade = EnrichedTrade::default();
251 assert_eq!(enriched_trade.symbol, "");
252 assert!(!enriched_trade.is_buy);
253 assert!(!enriched_trade.is_taker);
254 assert_eq!(enriched_trade.price, "");
255 assert_eq!(enriched_trade.amount, "");
256 assert_eq!(enriched_trade.quote_amount, "");
257 assert_eq!(enriched_trade.event_at, 0);
258 assert_eq!(enriched_trade.transaction_id, "");
259 assert_eq!(enriched_trade.wallet_address, "");
260 assert_eq!(enriched_trade.market_type, MarketType::Perp as i32);
261 assert_eq!(enriched_trade.pnl, "");
262 assert_eq!(enriched_trade.pnl_usd, "");
263 assert_eq!(enriched_trade.holding_duration, 0);
264 }
265
266 #[test]
267 fn test_enriched_trade_serialization() {
268 let enriched_trade = EnrichedTrade {
269 symbol: "ETH/USD".to_string(),
270 is_buy: false,
271 is_taker: true,
272 price: "2000.0".to_string(),
273 amount: "0.5".to_string(),
274 quote_amount: "1000.0".to_string(),
275 event_at: 1678887100,
276 transaction_id: "ext-uvw".to_string(),
277 wallet_address: "0x67890".to_string(),
278 market_type: MarketType::Spot as i32,
279 pnl: "-50.0".to_string(),
280 pnl_usd: "-50.0".to_string(),
281 holding_duration: 7200,
282 };
283
284 let mut buf = Vec::new();
285 enriched_trade.encode(&mut buf).unwrap();
286 let deserialized_enriched_trade = EnrichedTrade::decode(&buf[..]).unwrap();
287
288 assert_eq!(deserialized_enriched_trade.symbol, "ETH/USD");
289 assert!(!deserialized_enriched_trade.is_buy);
290 assert!(deserialized_enriched_trade.is_taker);
291 assert_eq!(deserialized_enriched_trade.price, "2000.0");
292 assert_eq!(deserialized_enriched_trade.amount, "0.5");
293 assert_eq!(deserialized_enriched_trade.quote_amount, "1000.0");
294 assert_eq!(deserialized_enriched_trade.event_at, 1678887100);
295 assert_eq!(deserialized_enriched_trade.transaction_id, "ext-uvw");
296 assert_eq!(deserialized_enriched_trade.wallet_address, "0x67890");
297 assert_eq!(deserialized_enriched_trade.market_type, MarketType::Spot as i32);
298 assert_eq!(deserialized_enriched_trade.pnl, "-50.0");
299 assert_eq!(deserialized_enriched_trade.pnl_usd, "-50.0");
300 assert_eq!(deserialized_enriched_trade.holding_duration, 7200);
301 }
302
303 #[test]
304 fn test_create_enriched_trade_zero_values() {
305 let enriched_trade = EnrichedTrade {
306 price: "0.0".to_string(),
307 amount: "0.0".to_string(),
308 quote_amount: "0.0".to_string(),
309 transaction_id: "".to_string(),
310 wallet_address: "".to_string(),
311 market_type: MarketType::Perp as i32,
312 pnl: "0.0".to_string(),
313 pnl_usd: "0.0".to_string(),
314 holding_duration: 0,
315 ..Default::default()
316 };
317 assert_eq!(enriched_trade.price, "0.0");
318 assert_eq!(enriched_trade.amount, "0.0");
319 assert_eq!(enriched_trade.quote_amount, "0.0");
320 assert_eq!(enriched_trade.transaction_id, "");
321 assert_eq!(enriched_trade.wallet_address, "");
322 assert_eq!(enriched_trade.pnl, "0.0");
323 assert_eq!(enriched_trade.pnl_usd, "0.0");
324 assert_eq!(enriched_trade.holding_duration, 0);
325 }
326
327 #[test]
328 fn test_create_position() {
329 let position = Position {
330 symbol: "BTC/USD".to_string(),
331 is_buy: true,
332 average_price: "50000.0".to_string(),
333 amount: "0.1".to_string(),
334 quote_amount: "5000.0".to_string(),
335 wallet_address: "0x12345".to_string(),
336 market_type: MarketType::Perp as i32,
337 };
338
339 assert_eq!(position.symbol, "BTC/USD");
340 assert!(position.is_buy);
341 assert_eq!(position.average_price, "50000.0");
342 assert_eq!(position.amount, "0.1");
343 assert_eq!(position.quote_amount, "5000.0");
344 assert_eq!(position.wallet_address, "0x12345");
345 assert_eq!(position.market_type, MarketType::Perp as i32);
346 }
347
348 #[test]
349 fn test_position_default_values() {
350 let position = Position::default();
351 assert_eq!(position.symbol, "");
352 assert!(!position.is_buy);
353 assert_eq!(position.average_price, "");
354 assert_eq!(position.amount, "");
355 assert_eq!(position.quote_amount, "");
356 assert_eq!(position.wallet_address, "");
357 assert_eq!(position.market_type, MarketType::Perp as i32);
358 }
359
360 #[test]
361 fn test_position_serialization() {
362 let position = Position {
363 symbol: "ETH/USD".to_string(),
364 is_buy: false,
365 average_price: "2000.0".to_string(),
366 amount: "0.5".to_string(),
367 quote_amount: "1000.0".to_string(),
368 wallet_address: "0x67890".to_string(),
369 market_type: MarketType::Spot as i32,
370 };
371
372 let mut buf = Vec::new();
373 position.encode(&mut buf).unwrap();
374 let deserialized_position = Position::decode(&buf[..]).unwrap();
375
376 assert_eq!(deserialized_position.symbol, "ETH/USD");
377 assert!(!deserialized_position.is_buy);
378 assert_eq!(deserialized_position.average_price, "2000.0");
379 assert_eq!(deserialized_position.amount, "0.5");
380 assert_eq!(deserialized_position.quote_amount, "1000.0");
381 assert_eq!(deserialized_position.wallet_address, "0x67890");
382 assert_eq!(deserialized_position.market_type, MarketType::Spot as i32);
383 }
384
385 #[test]
386 fn test_create_position_zero_values() {
387 let position = Position {
388 average_price: "0.0".to_string(),
389 amount: "0.0".to_string(),
390 quote_amount: "0.0".to_string(),
391 wallet_address: "".to_string(),
392 market_type: MarketType::Perp as i32,
393 ..Default::default()
394 };
395 assert_eq!(position.average_price, "0.0");
396 assert_eq!(position.amount, "0.0");
397 assert_eq!(position.quote_amount, "0.0");
398 assert_eq!(position.wallet_address, "");
399 }
400}