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 hash: "sample_hash_raw".to_string(),
79 };
80
81 assert_eq!(raw_trade.symbol, "BTC/USD");
82 assert!(raw_trade.is_buy);
83 assert!(!raw_trade.is_taker);
84 assert_eq!(raw_trade.price, "50000.0");
85 assert_eq!(raw_trade.amount, "0.1");
86 assert_eq!(raw_trade.quote_amount, "5000.0");
87 assert_eq!(raw_trade.event_at, 1678887000);
88 assert_eq!(raw_trade.transaction_id, "ext-xyz");
89 assert_eq!(raw_trade.wallet_address, "0x12345");
90 assert_eq!(raw_trade.market_type, MarketType::Perp as i32);
91 assert_eq!(raw_trade.hash, "sample_hash_raw");
92 }
93
94 #[test]
95 fn test_raw_trade_serialization() {
96 let raw_trade = RawTrade {
97 symbol: "ETH/USD".to_string(),
98 is_buy: false,
99 is_taker: true,
100 price: "2000.0".to_string(),
101 amount: "0.5".to_string(),
102 quote_amount: "1000.0".to_string(),
103 event_at: 1678887100,
104 transaction_id: "ext-uvw".to_string(),
105 wallet_address: "0x67890".to_string(),
106 market_type: MarketType::Spot as i32,
107 hash: "new_hash_raw".to_string(),
108 };
109
110 let mut buf = Vec::new();
111 raw_trade.encode(&mut buf).unwrap();
112 let deserialized_raw_trade = RawTrade::decode(&buf[..]).unwrap();
113
114 assert_eq!(deserialized_raw_trade.symbol, "ETH/USD");
115 assert!(!deserialized_raw_trade.is_buy);
116 assert!(deserialized_raw_trade.is_taker);
117 assert_eq!(deserialized_raw_trade.price, "2000.0");
118 assert_eq!(deserialized_raw_trade.amount, "0.5");
119 assert_eq!(deserialized_raw_trade.quote_amount, "1000.0");
120 assert_eq!(deserialized_raw_trade.event_at, 1678887100);
121 assert_eq!(deserialized_raw_trade.transaction_id, "ext-uvw");
122 assert_eq!(deserialized_raw_trade.wallet_address, "0x67890");
123 assert_eq!(deserialized_raw_trade.market_type, MarketType::Spot as i32);
124 assert_eq!(deserialized_raw_trade.hash, "new_hash_raw");
125 }
126
127 #[test]
128 fn test_hyperliquid_trade_default_values() {
129 let trade = HyperliquidTrade::default();
130 assert_eq!(trade.coin, "");
131 assert_eq!(trade.side, "");
132 assert_eq!(trade.px, "");
133 assert_eq!(trade.sz, "");
134 assert_eq!(trade.hash, "");
135 assert_eq!(trade.time, 0);
136 assert_eq!(trade.tid, 0);
137 assert!(trade.users.is_empty());
138 }
139
140 #[test]
141 fn test_create_hyperliquid_trade_zero_values() {
142 let trade = HyperliquidTrade {
143 px: "0.0".to_string(),
144 sz: "0.0".to_string(),
145 users: vec!["buyer_address".to_string()],
146 ..Default::default()
147 };
148 assert_eq!(trade.px, "0.0");
149 assert_eq!(trade.sz, "0.0");
150 assert_eq!(trade.users, vec!["buyer_address"]);
151 }
152
153 #[test]
154 fn test_raw_trade_default_values() {
155 let raw_trade = RawTrade::default();
156 assert_eq!(raw_trade.symbol, "");
157 assert!(!raw_trade.is_buy);
158 assert!(!raw_trade.is_taker);
159 assert_eq!(raw_trade.price, "");
160 assert_eq!(raw_trade.amount, "");
161 assert_eq!(raw_trade.quote_amount, "");
162 assert_eq!(raw_trade.event_at, 0);
163 assert_eq!(raw_trade.transaction_id, "");
164 assert_eq!(raw_trade.wallet_address, "");
165 assert_eq!(raw_trade.market_type, MarketType::Perp as i32); assert_eq!(raw_trade.hash, "");
167 }
168
169 #[test]
170 fn test_create_raw_trade_zero_values() {
171 let raw_trade = RawTrade {
172 price: "0.0".to_string(),
173 amount: "0.0".to_string(),
174 quote_amount: "0.0".to_string(),
175 transaction_id: "".to_string(),
176 wallet_address: "".to_string(),
177 market_type: MarketType::Perp as i32,
178 hash: "".to_string(),
179 ..Default::default()
180 };
181 assert_eq!(raw_trade.price, "0.0");
182 assert_eq!(raw_trade.amount, "0.0");
183 assert_eq!(raw_trade.quote_amount, "0.0");
184 assert_eq!(raw_trade.transaction_id, "");
185 assert_eq!(raw_trade.wallet_address, "");
186 assert_eq!(raw_trade.hash, "");
187 }
188
189 #[test]
190 fn test_raw_trade_serialization_all_market_types() {
191 let market_types = [
192 MarketType::Perp,
193 MarketType::Spot,
194 ];
195 for mt in market_types.iter() {
196 let raw_trade = RawTrade {
197 symbol: "XRP/USD".to_string(),
198 is_buy: true,
199 is_taker: false,
200 price: "0.5".to_string(),
201 amount: "100.0".to_string(),
202 quote_amount: "50.0".to_string(),
203 event_at: 1678887300,
204 transaction_id: "ext-test".to_string(),
205 wallet_address: "0xabcde".to_string(),
206 market_type: *mt as i32,
207 hash: "test_hash_raw".to_string(),
208 };
209
210 let mut buf = Vec::new();
211 raw_trade.encode(&mut buf).unwrap();
212 let deserialized_raw_trade = RawTrade::decode(&buf[..]).unwrap();
213 assert_eq!(deserialized_raw_trade.market_type, *mt as i32);
214 assert_eq!(deserialized_raw_trade.hash, "test_hash_raw");
215 }
216 }
217
218 #[test]
219 fn test_market_type_enum() {
220 assert_eq!(MarketType::Perp as i32, 0); assert_eq!(MarketType::Spot as i32, 1); }
223
224 #[test]
225 fn test_create_enriched_trade() {
226 let enriched_trade = EnrichedTrade {
227 symbol: "BTC/USD".to_string(),
228 is_buy: true,
229 is_taker: false,
230 price: "50000.0".to_string(),
231 amount: "0.1".to_string(),
232 quote_amount: "5000.0".to_string(),
233 event_at: 1678887000,
234 transaction_id: "ext-xyz".to_string(),
235 wallet_address: "0x12345".to_string(),
236 market_type: MarketType::Perp as i32,
237 pnl: "100.0".to_string(),
238 pnl_usd: "100.0".to_string(),
239 holding_duration: 3600,
240 hash: "sample_hash_enriched".to_string(),
241 };
242
243 assert_eq!(enriched_trade.symbol, "BTC/USD");
244 assert!(enriched_trade.is_buy);
245 assert!(!enriched_trade.is_taker);
246 assert_eq!(enriched_trade.price, "50000.0");
247 assert_eq!(enriched_trade.amount, "0.1");
248 assert_eq!(enriched_trade.quote_amount, "5000.0");
249 assert_eq!(enriched_trade.event_at, 1678887000);
250 assert_eq!(enriched_trade.transaction_id, "ext-xyz");
251 assert_eq!(enriched_trade.wallet_address, "0x12345");
252 assert_eq!(enriched_trade.market_type, MarketType::Perp as i32);
253 assert_eq!(enriched_trade.pnl, "100.0");
254 assert_eq!(enriched_trade.pnl_usd, "100.0");
255 assert_eq!(enriched_trade.holding_duration, 3600);
256 assert_eq!(enriched_trade.hash, "sample_hash_enriched");
257 }
258
259 #[test]
260 fn test_enriched_trade_default_values() {
261 let enriched_trade = EnrichedTrade::default();
262 assert_eq!(enriched_trade.symbol, "");
263 assert!(!enriched_trade.is_buy);
264 assert!(!enriched_trade.is_taker);
265 assert_eq!(enriched_trade.price, "");
266 assert_eq!(enriched_trade.amount, "");
267 assert_eq!(enriched_trade.quote_amount, "");
268 assert_eq!(enriched_trade.event_at, 0);
269 assert_eq!(enriched_trade.transaction_id, "");
270 assert_eq!(enriched_trade.wallet_address, "");
271 assert_eq!(enriched_trade.market_type, MarketType::Perp as i32);
272 assert_eq!(enriched_trade.pnl, "");
273 assert_eq!(enriched_trade.pnl_usd, "");
274 assert_eq!(enriched_trade.holding_duration, 0);
275 assert_eq!(enriched_trade.hash, "");
276 }
277
278 #[test]
279 fn test_enriched_trade_serialization() {
280 let enriched_trade = EnrichedTrade {
281 symbol: "ETH/USD".to_string(),
282 is_buy: false,
283 is_taker: true,
284 price: "2000.0".to_string(),
285 amount: "0.5".to_string(),
286 quote_amount: "1000.0".to_string(),
287 event_at: 1678887100,
288 transaction_id: "ext-uvw".to_string(),
289 wallet_address: "0x67890".to_string(),
290 market_type: MarketType::Spot as i32,
291 pnl: "-50.0".to_string(),
292 pnl_usd: "-50.0".to_string(),
293 holding_duration: 7200,
294 hash: "new_hash_enriched".to_string(),
295 };
296
297 let mut buf = Vec::new();
298 enriched_trade.encode(&mut buf).unwrap();
299 let deserialized_enriched_trade = EnrichedTrade::decode(&buf[..]).unwrap();
300
301 assert_eq!(deserialized_enriched_trade.symbol, "ETH/USD");
302 assert!(!deserialized_enriched_trade.is_buy);
303 assert!(deserialized_enriched_trade.is_taker);
304 assert_eq!(deserialized_enriched_trade.price, "2000.0");
305 assert_eq!(deserialized_enriched_trade.amount, "0.5");
306 assert_eq!(deserialized_enriched_trade.quote_amount, "1000.0");
307 assert_eq!(deserialized_enriched_trade.event_at, 1678887100);
308 assert_eq!(deserialized_enriched_trade.transaction_id, "ext-uvw");
309 assert_eq!(deserialized_enriched_trade.wallet_address, "0x67890");
310 assert_eq!(deserialized_enriched_trade.market_type, MarketType::Spot as i32);
311 assert_eq!(deserialized_enriched_trade.pnl, "-50.0");
312 assert_eq!(deserialized_enriched_trade.pnl_usd, "-50.0");
313 assert_eq!(deserialized_enriched_trade.holding_duration, 7200);
314 assert_eq!(deserialized_enriched_trade.hash, "new_hash_enriched");
315 }
316
317 #[test]
318 fn test_create_enriched_trade_zero_values() {
319 let enriched_trade = EnrichedTrade {
320 price: "0.0".to_string(),
321 amount: "0.0".to_string(),
322 quote_amount: "0.0".to_string(),
323 transaction_id: "".to_string(),
324 wallet_address: "".to_string(),
325 market_type: MarketType::Perp as i32,
326 pnl: "0.0".to_string(),
327 pnl_usd: "0.0".to_string(),
328 holding_duration: 0,
329 hash: "".to_string(),
330 ..Default::default()
331 };
332 assert_eq!(enriched_trade.price, "0.0");
333 assert_eq!(enriched_trade.amount, "0.0");
334 assert_eq!(enriched_trade.quote_amount, "0.0");
335 assert_eq!(enriched_trade.transaction_id, "");
336 assert_eq!(enriched_trade.wallet_address, "");
337 assert_eq!(enriched_trade.pnl, "0.0");
338 assert_eq!(enriched_trade.pnl_usd, "0.0");
339 assert_eq!(enriched_trade.holding_duration, 0);
340 assert_eq!(enriched_trade.hash, "");
341 }
342
343 #[test]
344 fn test_create_position() {
345 let position = Position {
346 symbol: "BTC/USD".to_string(),
347 is_buy: true,
348 average_price: "50000.0".to_string(),
349 amount: "0.1".to_string(),
350 quote_amount: "5000.0".to_string(),
351 wallet_address: "0x12345".to_string(),
352 market_type: MarketType::Perp as i32,
353 };
354
355 assert_eq!(position.symbol, "BTC/USD");
356 assert!(position.is_buy);
357 assert_eq!(position.average_price, "50000.0");
358 assert_eq!(position.amount, "0.1");
359 assert_eq!(position.quote_amount, "5000.0");
360 assert_eq!(position.wallet_address, "0x12345");
361 assert_eq!(position.market_type, MarketType::Perp as i32);
362 }
363
364 #[test]
365 fn test_position_default_values() {
366 let position = Position::default();
367 assert_eq!(position.symbol, "");
368 assert!(!position.is_buy);
369 assert_eq!(position.average_price, "");
370 assert_eq!(position.amount, "");
371 assert_eq!(position.quote_amount, "");
372 assert_eq!(position.wallet_address, "");
373 assert_eq!(position.market_type, MarketType::Perp as i32);
374 }
375
376 #[test]
377 fn test_position_serialization() {
378 let position = Position {
379 symbol: "ETH/USD".to_string(),
380 is_buy: false,
381 average_price: "2000.0".to_string(),
382 amount: "0.5".to_string(),
383 quote_amount: "1000.0".to_string(),
384 wallet_address: "0x67890".to_string(),
385 market_type: MarketType::Spot as i32,
386 };
387
388 let mut buf = Vec::new();
389 position.encode(&mut buf).unwrap();
390 let deserialized_position = Position::decode(&buf[..]).unwrap();
391
392 assert_eq!(deserialized_position.symbol, "ETH/USD");
393 assert!(!deserialized_position.is_buy);
394 assert_eq!(deserialized_position.average_price, "2000.0");
395 assert_eq!(deserialized_position.amount, "0.5");
396 assert_eq!(deserialized_position.quote_amount, "1000.0");
397 assert_eq!(deserialized_position.wallet_address, "0x67890");
398 assert_eq!(deserialized_position.market_type, MarketType::Spot as i32);
399 }
400
401 #[test]
402 fn test_create_position_zero_values() {
403 let position = Position {
404 average_price: "0.0".to_string(),
405 amount: "0.0".to_string(),
406 quote_amount: "0.0".to_string(),
407 wallet_address: "".to_string(),
408 market_type: MarketType::Perp as i32,
409 ..Default::default()
410 };
411 assert_eq!(position.average_price, "0.0");
412 assert_eq!(position.amount, "0.0");
413 assert_eq!(position.quote_amount, "0.0");
414 assert_eq!(position.wallet_address, "");
415 }
416}