添加kucoin单元测试

添加binance交易所交易方法

standard/src/binance_swap.rs

@@ -6,8 +6,8 @@ use std::str::FromStr;
 use async_trait::async_trait;
 use rust_decimal::Decimal;
 use rust_decimal_macros::dec;
-use tracing::error;
-use crate::{Platform, ExchangeEnum, Account, Position, Ticker, Market, Order, OrderCommand};
+use tokio::sync::mpsc::Sender;
+use crate::{Platform, ExchangeEnum, Account, Position, Ticker, Market, Order, OrderCommand, utils, PositionModeEnum};
 use exchanges::binance_swap_rest::BinanceSwapRest;
 
 #[allow(dead_code)]
@@ -18,17 +18,26 @@ pub struct BinanceSwap {
     is_colo: bool,
     params: BTreeMap<String, String>,
     request: BinanceSwapRest,
+    market: Market,
+    order_sender: Sender<Order>,
+    error_sender: Sender<Error>,
 }
 
 impl BinanceSwap {
-    pub async fn new(symbol: String, is_colo: bool, params: BTreeMap<String, String>) -> BinanceSwap {
-        BinanceSwap {
+    pub async fn new(symbol: String, is_colo: bool, params: BTreeMap<String, String>, order_sender: Sender<Order>, error_sender: Sender<Error>) -> BinanceSwap {
+        let market = Market::new();
+        let mut binance_swap = BinanceSwap {
             exchange: ExchangeEnum::BinanceSwap,
             symbol: symbol.to_uppercase(),
             is_colo,
             params: params.clone(),
             request: BinanceSwapRest::new(is_colo, params.clone()),
-        }
+            market,
+            order_sender,
+            error_sender,
+        };
+        binance_swap.market = BinanceSwap::get_market(&mut binance_swap).await.unwrap_or(binance_swap.market);
+        return binance_swap;
     }
 }
 
@@ -51,16 +60,25 @@ impl Platform for BinanceSwap {
         self.params.clone()
     }
     // 获取market信息
-    fn get_self_market(&self) -> Market { todo!() }
+    fn get_self_market(&self) -> Market { self.market.clone() }
     // 获取请求时间
     fn get_request_delays(&self) -> Vec<i64> { self.request.get_delays() }
     // 获取请求平均时间
     fn get_request_avg_delay(&self) -> Decimal { self.request.get_avg_delay() }
     // 获取请求最大时间
     fn get_request_max_delay(&self) -> i64 { self.request.get_max_delay() }
+
     // 获取服务器时间
     async fn get_server_time(&mut self) -> Result<String, Error> {
-        todo!()
+        let res_data = self.request.get_server_time().await;
+        if res_data.code == "200" {
+            let res_data_str = &res_data.data;
+            let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
+            let result = res_data_json["serverTime"].to_string();
+            Ok(result)
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.message))
+        }
     }
     // 获取账号信息
     async fn get_account(&mut self) -> Result<Account, Error> {
@@ -72,7 +90,6 @@ impl Platform for BinanceSwap {
             let balance_info = res_data_json.iter().find(|item| item["asset"].as_str().unwrap().to_string() == symbol_array[1].to_string());
             match balance_info {
                 None => {
-                    error!("格式化Binance账号信息错误!");
                     panic!("格式化Binance账号信息错误!\nget_account: balance_info={:?}", balance_info)
                 }
                 Some(value) => {
@@ -96,33 +113,128 @@ impl Platform for BinanceSwap {
     }
     // 获取仓位信息
     async fn get_position(&mut self) -> Result<Vec<Position>, Error> {
-        todo!()
+        let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        let amount_size = self.market.amount_size;
+        let res_data = self.request.get_position_risk(symbol_format).await;
+        if res_data.code == "200" {
+            let res_data_str = &res_data.data;
+            let res_data_json: Vec<serde_json::Value> = serde_json::from_str(res_data_str).unwrap();
+            let result = res_data_json.iter().map(|item| { format_position_item(item, amount_size) }).collect();
+            Ok(result)
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.message))
+        }
     }
 
     async fn get_positions(&mut self) -> Result<Vec<Position>, Error> {
-        todo!()
+        let amount_size = self.market.amount_size;
+        let res_data = self.request.get_position_risk("".to_string()).await;
+        if res_data.code == "200" {
+            let res_data_str = &res_data.data;
+            let res_data_json: Vec<serde_json::Value> = serde_json::from_str(res_data_str).unwrap();
+            let result = res_data_json.iter().map(|item| { format_position_item(item, amount_size) }).collect();
+            Ok(result)
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.message))
+        }
     }
 
     // 获取市场行情
     async fn get_ticker(&mut self) -> Result<Ticker, Error> {
-        todo!()
+        let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        let res_data = self.request.get_book_ticker(symbol_format).await;
+        if res_data.code == "200" {
+            let res_data_str = &res_data.data;
+            let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
+            let result = Ticker {
+                time: res_data_json["time"].as_i64().unwrap(),
+                high: Decimal::from_str(res_data_json["askPrice"].as_str().unwrap()).unwrap(),
+                low: Decimal::from_str(res_data_json["bidPrice"].as_str().unwrap()).unwrap(),
+                sell: Decimal::from_str(res_data_json["askPrice"].as_str().unwrap()).unwrap(),
+                buy: Decimal::from_str(res_data_json["bidPrice"].as_str().unwrap()).unwrap(),
+                last: dec!(-1),
+                volume: dec!(-1),
+            };
+            Ok(result)
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.message))
+        }
     }
 
-    async fn get_market(&mut self) -> Result<Market, Error> { todo!() }
+    async fn get_market(&mut self) -> Result<Market, Error> {
+        let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        let res_data = self.request.get_exchange_info().await;
+        if res_data.code == "200" {
+            let res_data_str = &res_data.data;
+            let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
+            let symbols: Vec<serde_json::Value> = res_data_json["symbols"].as_array().unwrap().clone();
+            let market_info = symbols.iter().find(|&item| item["symbol"].as_str().unwrap() == symbol_format);
+            match market_info {
+                None => {
+                    panic!("Binance：获取Market信息错误!\nget_market:res_data={:?}", res_data_str)
+                }
+                Some(value) => {
+                    let base_asset = value["baseAsset"].as_str().unwrap_or("").to_string();
+                    let quote_asset = value["quoteAsset"].as_str().unwrap_or("").to_string();
+
+                    let filter_array = value["filters"].as_array().unwrap().clone();
+                    let price_filter = filter_array.iter().find(|&item| item["filterType"].as_str().unwrap() == "PRICE_FILTER").unwrap();
+                    let lot_size_filter = filter_array.iter().find(|&item| item["filterType"].as_str().unwrap() == "LOT_SIZE").unwrap();
+
+                    let result = Market {
+                        symbol: format!("{}_{}", base_asset, quote_asset),
+                        base_asset,
+                        quote_asset,
+                        tick_size: Decimal::from_str(&price_filter["tickSize"].as_str().unwrap()).unwrap(),
+                        amount_size: dec!(1),
+                        price_precision: Decimal::from_str(&value["pricePrecision"].to_string()).unwrap(),
+                        amount_precision: Decimal::from_str(&value["quantityPrecision"].to_string()).unwrap(),
+                        min_qty: Decimal::from_str(lot_size_filter["minQty"].as_str().unwrap()).unwrap(),
+                        max_qty: Decimal::from_str(lot_size_filter["maxQty"].as_str().unwrap()).unwrap(),
+                        min_notional: Decimal::from_str(price_filter["minPrice"].as_str().unwrap()).unwrap(),
+                        max_notional: Decimal::from_str(price_filter["maxPrice"].as_str().unwrap()).unwrap(),
+                        ct_val: Default::default(),
+                    };
+                    Ok(result)
+                }
+            }
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.message))
+        }
+    }
 
-    async fn get_order_detail(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
+    async fn get_order_detail(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
+        let symbol_format = utils::format_symbol(self.symbol.clone(), "");
+        let res_data = self.request.get_order(symbol_format, order_id.parse().unwrap_or(-1), custom_id.to_string()).await;
+        if res_data.code == "200" {
+            let res_data_str = &res_data.data;
+            let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
 
-    async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> {
-        todo!()
+            let status = res_data_json["status"].as_str().unwrap();
+            let custom_status = if ["CANCELED", "EXPIRED", "FILLED"].contains(&status) { "REMOVE".to_string() } else if status == "NEW" { "NEW".to_string() } else { panic!("Binance：格式化订单状态错误！\nget_order_detail:status={:?}", status) };
+            let result = Order {
+                id: res_data_json["orderId"].to_string(),
+                custom_id: res_data_json["clientOrderId"].as_str().unwrap().parse().unwrap(),
+                price: Decimal::from_str(res_data_json["price"].as_str().unwrap()).unwrap(),
+                amount: Decimal::from_str(res_data_json["origQty"].as_str().unwrap()).unwrap(),
+                deal_amount: Decimal::from_str(res_data_json["executedQty"].as_str().unwrap()).unwrap(),
+                avg_price: Decimal::from_str(res_data_json["avgPrice"].as_str().unwrap()).unwrap(),
+                status: custom_status,
+                order_type: res_data_json["type"].as_str().unwrap().parse().unwrap(),
+            };
+            Ok(result)
+        } else {
+            Err(Error::new(ErrorKind::Other, res_data.message))
+        }
     }
 
+    async fn get_orders_list(&mut self, _status: &str) -> Result<Vec<Order>, Error> { todo!() }
+
     async fn take_order(&mut self, _custom_id: &str, _origin_side: &str, _price: Decimal, _amount: Decimal) -> Result<Order, Error> { todo!() }
 
     async fn cancel_order(&mut self, _order_id: &str, _custom_id: &str) -> Result<Order, Error> { todo!() }
 
-    async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> {
-        todo!()
-    }
+    async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> { todo!() }
 
     async fn set_dual_mode(&mut self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> { todo!() }
 
@@ -132,3 +244,24 @@ impl Platform for BinanceSwap {
 
     async fn command_order(&mut self, _order_command: OrderCommand) { todo!() }
 }
+
+pub fn format_position_item(position: &serde_json::Value, amount_size: Decimal) -> Position {
+    let position_mode = match position["positionSide"].as_str().unwrap_or("") {
+        "BOTH" => PositionModeEnum::Both,
+        "LONG" => PositionModeEnum::Long,
+        "SHORT" => PositionModeEnum::Short,
+        _ => panic!("Binance：格式化持仓模式错误！\nformat_position_item:position_side={:?}", position["positionSide"])
+    };
+    let size = Decimal::from_str(position["positionAmt"].as_str().unwrap()).unwrap();
+    let amount = size * amount_size;
+    Position {
+        symbol: position["symbol"].as_str().unwrap_or("").parse().unwrap(),
+        margin_level: Decimal::from_str(position["leverage"].as_str().unwrap()).unwrap(),
+        amount,
+        frozen_amount: dec!(0),
+        price: Decimal::from_str(position["entryPrice"].as_str().unwrap()).unwrap(),
+        profit: Decimal::from_str(position["unRealizedProfit"].as_str().unwrap()).unwrap(),
+        position_mode,
+        margin: Decimal::from_str(position["isolatedMargin"].as_str().unwrap()).unwrap(),
+    }
+}

standard/src/exchange.rs

@@ -66,7 +66,7 @@ impl Exchange {
     pub async fn new(exchange: ExchangeEnum, symbol: String, is_colo: bool, params: BTreeMap<String, String>, order_sender: Sender<Order>, error_sender: Sender<Error>) -> Box<dyn Platform + Send + Sync> {
         match exchange {
             ExchangeEnum::BinanceSwap => {
-                Box::new(BinanceSwap::new(symbol, is_colo, params).await)
+                Box::new(BinanceSwap::new(symbol, is_colo, params, order_sender, error_sender).await)
             }
             ExchangeEnum::BinanceSpot => {
                 Box::new(BinanceSpot::new(symbol, is_colo, params))

standard/src/gate_handle.rs

@@ -1,7 +1,7 @@
 use std::str::FromStr;
 use rust_decimal::Decimal;
 use rust_decimal_macros::dec;
-use tracing::{error, info};
+use tracing::{info};
 use exchanges::response_base::ResponseData;
 use crate::{Account, MarketOrder, Order, Position, PositionModeEnum, SpecialDepth, SpecialOrder};
 use crate::exchange::ExchangeEnum;
@@ -19,7 +19,6 @@ pub fn format_account_info(data: Vec<serde_json::Value>, symbol: String) -> Acco
     let balance_info = data.iter().find(|&item| item["text"].as_str().unwrap().contains(&symbol));
     match balance_info {
         None => {
-            error!("Gate：格式化账号信息错误!");
             panic!("Gate：格式化账号信息错误!\nformat_account_info: balance_info={:?}", balance_info)
         }
         Some(value) => {
@@ -48,7 +47,7 @@ pub fn format_position_item(position: &serde_json::Value, amount_size: Decimal)
         "single" => PositionModeEnum::Both,
         "dual_long" => PositionModeEnum::Long,
         "dual_short" => PositionModeEnum::Short,
-        _ => panic!("Gate：格式化持仓模式错误！\nformat_position_item:position_mode={}", position["mode"])
+        _ => panic!("Gate：格式化持仓模式错误！\nformat_position_item:position_mode={:?}", position["mode"])
     };
     let size = Decimal::from_str(&position["size"].to_string()).unwrap();
     let amount = size * amount_size;
@@ -89,7 +88,7 @@ pub fn format_order_item(order: serde_json::Value, amount_size: Decimal) -> Orde
 
     let amount = size * amount_size;
     let deal_amount = (size - left) * amount_size;
-    let custom_status = if status == "finished" { "REMOVE".to_string() } else if status == "open" { "NEW".to_string() } else { panic!("Gate：格式化订单状态错误！\nformat_order_item:status={}", status) };
+    let custom_status = if status == "finished" { "REMOVE".to_string() } else if status == "open" { "NEW".to_string() } else { panic!("Gate：格式化订单状态错误！\nformat_order_item:status={:?}", status) };
     let rst_order = Order {
         id: order["id"].to_string(),
         custom_id: text.replace("t-my-custom-id_", ""),

standard/src/gate_swap.rs

@@ -8,8 +8,7 @@ use rust_decimal::prelude::{FromPrimitive, ToPrimitive};
 use rust_decimal_macros::dec;
 use serde_json::{json};
 use futures::stream::FuturesUnordered;
-use futures::{TryFutureExt, TryStreamExt};
-use futures::future::err;
+use futures::{TryStreamExt};
 use tracing::{error, info};
 use crate::{Platform, ExchangeEnum, Account, Position, Ticker, Market, Order, OrderCommand, PositionModeEnum};
 use exchanges::gate_swap_rest::GateSwapRest;
@@ -145,7 +144,7 @@ impl Platform for GateSwap {
             let ticker_info = res_data_json.iter().find(|item| item["contract"].as_str().unwrap() == self.symbol);
             match ticker_info {
                 None => {
-                    panic!("Gate：获取Ticker信息错误!\nget_ticker:res_data={}", res_data_str)
+                    panic!("Gate：获取Ticker信息错误!\nget_ticker:res_data={:?}", res_data_str)
                 }
                 Some(value) => {
                     let result = Ticker {
@@ -174,7 +173,7 @@ impl Platform for GateSwap {
             let market_info = res_data_json.iter().find(|item| item["name"].as_str().unwrap() == self.symbol);
             match market_info {
                 None => {
-                    panic!("Gate：获取Market信息错误!\nget_market:res_data={}", res_data_str)
+                    panic!("Gate：获取Market信息错误!\nget_market:market_info={:?}", market_info)
                 }
                 Some(value) => {
                     let name = value["name"].as_str().unwrap();
@@ -438,7 +437,7 @@ pub fn format_position_item(position: &serde_json::Value, amount_size: Decimal)
         "single" => PositionModeEnum::Both,
         "dual_long" => PositionModeEnum::Long,
         "dual_short" => PositionModeEnum::Short,
-        _ => panic!("Gate：格式化持仓模式错误！\nformat_position_item:position_mode={}", position["mode"])
+        _ => panic!("Gate：格式化持仓模式错误！\nformat_position_item:position_mode={:?}", position["mode"])
     };
     let size = Decimal::from_str(&position["size"].to_string()).unwrap();
     let amount = size * amount_size;
@@ -464,7 +463,7 @@ pub fn format_order_item(order: serde_json::Value, amount_size: Decimal) -> Orde
 
     let amount = size * amount_size;
     let deal_amount = (size - left) * amount_size;
-    let custom_status = if status == "finished" { "REMOVE".to_string() } else if status == "open" { "NEW".to_string() } else { panic!("Gate：格式化订单状态错误！\nformat_order_item:status={}", status) };
+    let custom_status = if status == "finished" { "REMOVE".to_string() } else if status == "open" { "NEW".to_string() } else { panic!("Gate：格式化订单状态错误！\nformat_order_item:status={:?}", status) };
     let rst_order = Order {
         id: order["id"].to_string(),
         custom_id: text.replace("t-my-custom-id_", ""),

standard/src/kucoin_handle.rs

@@ -29,7 +29,7 @@ pub fn format_account_info(data: serde_json::Value, symbol: String) -> Account {
             frozen_stocks: dec!(0),
         }
     } else {
-        panic!("Kucoin：格式化账号信息错误!\nformat_account_info:data={}", data);
+        panic!("Kucoin：格式化账号信息错误!\nformat_account_info:data={:?}", data);
     }
 }
 
@@ -108,7 +108,7 @@ pub fn format_order_item(order: serde_json::Value, amount_size: Decimal) -> Orde
     let amount = size * amount_size;
     let deal_amount = filled_size * amount_size;
     let avg_price = if status == "match" { match_price } else { price };
-    let custom_status = if ["done", "match"].contains(&status) { "REMOVE".to_string() } else if status == "open" { "NEW".to_string() } else { panic!("Kucoin：格式化订单状态错误!\nformat_order_item:status={}", status); };
+    let custom_status = if ["done", "match"].contains(&status) { "REMOVE".to_string() } else if status == "open" { "NEW".to_string() } else { panic!("Kucoin：格式化订单状态错误!\nformat_order_item:status={:?}", status); };
     Order {
         id: order["id"].as_str().unwrap().to_string(),
         custom_id: order["clientOid"].as_str().unwrap().to_string(),

standard/src/kucoin_swap.rs

@@ -124,7 +124,6 @@ impl Platform for KucoinSwap {
         let symbol_array: Vec<&str> = self.symbol.split("_").collect();
         let amount_size = self.market.amount_size;
         let res_data = self.request.get_positions(symbol_array[1].to_string()).await;
-        println!("{:?}", res_data);
         if res_data.code == "200" {
             let res_data_str = &res_data.data;
             let res_data_json: Vec<serde_json::Value> = serde_json::from_str(res_data_str).unwrap();
@@ -167,7 +166,7 @@ impl Platform for KucoinSwap {
             let market_info = res_data_json.iter().find(|item| item["symbol"].as_str().unwrap() == symbol_format);
             match market_info {
                 None => {
-                    panic!("Kucoin：获取Market信息错误!\nget_market:res_data={}", res_data_str)
+                    panic!("Kucoin：获取Market信息错误!\nget_market:res_data={:?}", res_data_str)
                 }
                 Some(value) => {
                     let base_asset = value["baseCurrency"].as_str().unwrap_or("").to_string();
@@ -231,6 +230,7 @@ impl Platform for KucoinSwap {
     async fn take_order(&mut self, custom_id: &str, origin_side: &str, price: Decimal, amount: Decimal) -> Result<Order, Error> {
         let symbol_format = format!("{}M", utils::format_symbol(self.symbol.clone(), ""));
         let amount_size = self.market.amount_size;
+        let mut status = "";
         let mut params = json!({
             "clientOid": custom_id,
             "symbol": symbol_format,
@@ -242,25 +242,38 @@ impl Platform for KucoinSwap {
         match origin_side {
             "kd" => {
                 params["side"] = json!("buy");
+                status = "NEW";
             }
             "pd" => {
                 params["side"] = json!("sell");
+                status = "REMOVE";
             }
             "kk" => {
                 params["side"] = json!("sell");
+                status = "NEW";
             }
             "pk" => {
                 params["side"] = json!("buy");
+                status = "REMOVE";
             }
             _ => { error!("下单参数错误"); }
         };
 
         let res_data = self.request.swap_order(params).await;
         if res_data.code == "200" {
-            println!("{:?}",res_data);
             let res_data_str = &res_data.data;
             let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
-            let result = format_order_item(res_data_json, amount_size);
+            let id = res_data_json["orderId"].as_str().unwrap().to_string();
+            let result = Order {
+                id,
+                custom_id: custom_id.to_string(),
+                price,
+                amount,
+                deal_amount: dec!(0),
+                avg_price: dec!(0),
+                status: status.to_string(),
+                order_type: "".to_string(),
+            };
             Ok(result)
         } else {
             Err(Error::new(ErrorKind::Other, res_data.message))
@@ -268,25 +281,36 @@ impl Platform for KucoinSwap {
     }
 
     async fn cancel_order(&mut self, order_id: &str, custom_id: &str) -> Result<Order, Error> {
-        let amount_size = self.market.amount_size;
         let res_data = self.request.cancel_order(order_id.to_string(), custom_id.to_string()).await;
+        if order_id == "" { panic!("Kucoin：撤销订单错误,该交易所为提供自定义订单号撤销订单!\ncancel_order:order_id={:?},custom_id={:?}", order_id, custom_id) }
         if res_data.code == "200" {
             let res_data_str = &res_data.data;
             let res_data_json: serde_json::Value = serde_json::from_str(res_data_str).unwrap();
-            let result = format_order_item(res_data_json, amount_size);
+            let cancel_ids = res_data_json["cancelledOrderIds"].as_array().unwrap();
+            let id = cancel_ids[0].as_str().unwrap().to_string();
+            let result = Order {
+                id,
+                custom_id: custom_id.to_string(),
+                price: dec!(0),
+                amount: dec!(0),
+                deal_amount: dec!(0),
+                avg_price: dec!(0),
+                status: "REMOVE".to_string(),
+                order_type: "".to_string(),
+            };
             Ok(result)
         } else {
             Err(Error::new(ErrorKind::Other, res_data.message))
         }
     }
 
-    async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> { todo!() }
+    async fn cancel_orders(&mut self) -> Result<Vec<Order>, Error> { panic!("Kucoin：该交易所暂不支持此方法！"); }
 
-    async fn set_dual_mode(&mut self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> { todo!() }
+    async fn set_dual_mode(&mut self, _coin: &str, _is_dual_mode: bool) -> Result<String, Error> { panic!("Kucoin：该交易所暂不支持此方法！"); }
 
-    async fn set_dual_leverage(&mut self, _leverage: &str) -> Result<String, Error> { todo!() }
+    async fn set_dual_leverage(&mut self, _leverage: &str) -> Result<String, Error> { panic!("Kucoin：该交易所暂不支持此方法！"); }
 
-    async fn wallet_transfers(&mut self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> { todo!() }
+    async fn wallet_transfers(&mut self, _coin: &str, _from: &str, _to: &str, _amount: Decimal) -> Result<String, Error> { panic!("Kucoin：该交易所暂不支持此方法！"); }
 
     // 指令下单
     async fn command_order(&mut self, order_command: OrderCommand) {
@@ -374,7 +398,6 @@ impl Platform for KucoinSwap {
 }
 
 pub fn format_order_item(order: serde_json::Value, amount_size: Decimal) -> Order {
-    println!("{}", order);
     let price = Decimal::from_str(order["price"].as_str().unwrap()).unwrap();
     let size = Decimal::from_str(&order["size"].to_string()).unwrap();
     let status = order["status"].as_str().unwrap_or("");
@@ -384,7 +407,7 @@ pub fn format_order_item(order: serde_json::Value, amount_size: Decimal) -> Orde
     let amount = size * amount_size;
     let deal_amount = filled_size * amount_size;
     let avg_price = if deal_amount.is_zero() { dec!(0) } else { filled_value / deal_amount };
-    let custom_status = if ["done", "match"].contains(&status) { "REMOVE".to_string() } else if status == "open" { "NEW".to_string() } else { panic!("Kucoin：格式化订单状态错误!\nformat_order_item:status={}", status); };
+    let custom_status = if ["done", "match"].contains(&status) { "REMOVE".to_string() } else if status == "open" { "NEW".to_string() } else { panic!("Kucoin：格式化订单状态错误!\nformat_order_item:status={:?}", status); };
     Order {
         id: order["id"].as_str().unwrap().to_string(),
         custom_id: order["clientOid"].as_str().unwrap().to_string(),

standard/src/utils.rs

@@ -1,6 +1,16 @@
+use tracing::trace;
+use exchanges::proxy;
+
 /// 修改交易对连接符号
 /// - `symbol(str)`: 交易对, "BTC_USDT", 默认以下划线传递
 /// - `pat(str)`: 替换字符, "-", 把 “_” 替换为 "-"
 pub fn format_symbol(symbol: String, pat: &str) -> String {
     return symbol.to_uppercase().replace("_", pat);
+}
+
+// 检测是否走代理
+pub fn proxy_handle() {
+    if proxy::ParsingDetail::http_enable_proxy() {
+        trace!("检测有代理配置，配置走代理");
+    }
 }

standard/tests/binance_swap_test.rs

@@ -0,0 +1,162 @@
+mod exchange_test;
+
+use tracing::{instrument, trace};
+use standard::exchange::{ExchangeEnum};
+use standard::{Platform};
+use crate::exchange_test::test_new_exchange;
+
+const SYMBOL: &str = "BLZ_USDT";
+
+// 测试获取Exchange实体
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_exchange() {
+    global::log_utils::init_log_with_trace();
+
+    let binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
+    let binance_get_self_exchange = binance_swap_exchange.get_self_exchange();
+    trace!(?binance_get_self_exchange);
+}
+
+// 测试获取交易对信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_symbol() {
+    global::log_utils::init_log_with_trace();
+
+    let binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
+    let binance_get_self_symbol = binance_swap_exchange.get_self_symbol();
+    trace!(?binance_get_self_symbol);
+}
+
+// 测试获取是否使用高速通道
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_is_colo() {
+    global::log_utils::init_log_with_trace();
+
+    let binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
+    let binance_get_self_is_colo = binance_swap_exchange.get_self_is_colo();
+    trace!(?binance_get_self_is_colo);
+}
+
+// 测试获取登录params信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_params() {
+    global::log_utils::init_log_with_trace();
+
+    let binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
+    let binance_get_self_params = binance_swap_exchange.get_self_params();
+    trace!("binance_get_self_params={:?}",binance_get_self_params);
+}
+
+// 测试获取Market信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_market() {
+    global::log_utils::init_log_with_trace();
+
+    let binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
+    let binance_get_self_market = binance_swap_exchange.get_self_market();
+    trace!(?binance_get_self_market);
+}
+
+// 测试获取请求时间信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_request_delays() {
+    global::log_utils::init_log_with_trace();
+
+    let binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
+    let binance_get_request_delays = binance_swap_exchange.get_request_delays();
+    trace!(?binance_get_request_delays);
+}
+
+// 测试获取请求平均时间信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_request_avg_delay() {
+    global::log_utils::init_log_with_trace();
+
+    let binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
+    let binance_get_request_avg_delay = binance_swap_exchange.get_request_avg_delay();
+    trace!(?binance_get_request_avg_delay);
+}
+
+// 测试获取最大请求时间信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_request_max_delay() {
+    global::log_utils::init_log_with_trace();
+
+    let binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
+    let binance_get_request_max_delay = binance_swap_exchange.get_request_max_delay();
+    trace!(?binance_get_request_max_delay);
+}
+
+// 测试获取服务器时间
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_server_time() {
+    global::log_utils::init_log_with_trace();
+
+    let mut binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
+    let binance_get_server_time = binance_swap_exchange.get_server_time().await;
+    trace!(?binance_get_server_time);
+}
+
+// 测试获取账号信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_account() {
+    global::log_utils::init_log_with_trace();
+
+    let mut binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
+    let binance_get_account = binance_swap_exchange.get_account().await;
+    trace!(?binance_get_account);
+}
+
+// 测试获取持仓信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_position() {
+    global::log_utils::init_log_with_trace();
+
+    let mut binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
+    let binance_get_position = binance_swap_exchange.get_position().await;
+    trace!(?binance_get_position);
+}
+
+// 测试获取所有持仓信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_positions() {
+    global::log_utils::init_log_with_trace();
+
+    let mut binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
+    let binance_get_position = binance_swap_exchange.get_positions().await;
+    trace!(?binance_get_position);
+}
+
+// 测试获取Ticker信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_ticker() {
+    global::log_utils::init_log_with_trace();
+
+    let mut binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
+    let binance_get_ticker = binance_swap_exchange.get_ticker().await;
+    trace!(?binance_get_ticker);
+}
+
+// 测试获取订单详情信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_order_detail() {
+    global::log_utils::init_log_with_trace();
+
+    let mut binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
+    let binance_get_order_detail = binance_swap_exchange.get_order_detail("", "9999").await;
+    trace!(?binance_get_order_detail);
+}

standard/tests/exchange_test.rs

@@ -2,16 +2,12 @@ use std::collections::BTreeMap;
 use std::env;
 use std::io::Error;
 use tokio::sync::mpsc;
-use tracing::trace;
-use exchanges::proxy;
 use standard::exchange::{Exchange, ExchangeEnum};
-use standard::{Order, Platform};
+use standard::{Order, Platform, utils};
 
 // 创建实体
 pub async fn test_new_exchange(exchange: ExchangeEnum, symbol: &str) -> Box<dyn Platform> {
-    if proxy::ParsingDetail::http_enable_proxy() {
-        trace!("检测有代理配置，配置走代理");
-    }
+    utils::proxy_handle();
     let (order_sender, _order_receiver): (mpsc::Sender<Order>, mpsc::Receiver<Order>) = mpsc::channel(1024);
     let (error_sender, _error_receiver): (mpsc::Sender<Error>, mpsc::Receiver<Error>) = mpsc::channel(1024);
     match exchange {

standard/tests/gate_swap_test.rs

@@ -7,8 +7,8 @@ use rust_decimal_macros::dec;
 use tokio::sync::mpsc;
 use tracing::{instrument, trace};
 use standard::exchange::{Exchange, ExchangeEnum};
-use standard::{Order, OrderCommand, Platform};
-use crate::exchange_test::test_new_exchange;
+use standard::{Order, OrderCommand, Platform, utils};
+use crate::exchange_test::{test_new_exchange};
 
 const SYMBOL: &str = "BLZ_USDT";
 
@@ -248,6 +248,8 @@ async fn test_set_dual_leverage() {
 #[instrument(level = "TRACE")]
 async fn test_command_order() {
     global::log_utils::init_log_with_trace();
+    utils::proxy_handle();
+
     let (order_sender, mut order_receiver): (mpsc::Sender<Order>, mpsc::Receiver<Order>) = mpsc::channel(1024);
     let (error_sender, mut error_receiver): (mpsc::Sender<Error>, mpsc::Receiver<Error>) = mpsc::channel(1024);
 
@@ -266,11 +268,12 @@ async fn test_command_order() {
     command.check.insert("888888".to_string(), vec!["999999".to_string(), "".to_string()]);
     gate_swap_exchange.command_order(command).await;
 
-
-    if let Ok(order) = order_receiver.try_recv() {
-        trace!(?order);
-    }
-    if let Ok(error) = error_receiver.try_recv() {
-        trace!(?error);
+    loop {
+        if let Ok(order) = order_receiver.try_recv() {
+            trace!(?order);
+        }
+        if let Ok(error) = error_receiver.try_recv() {
+            trace!(?error);
+        }
     }
 }

standard/tests/kucoin_swap_test.rs

@@ -0,0 +1,248 @@
+mod exchange_test;
+
+use std::collections::BTreeMap;
+use std::env;
+use std::io::Error;
+use rust_decimal_macros::dec;
+use tokio::sync::mpsc;
+use tracing::{instrument, trace};
+use standard::exchange::{Exchange, ExchangeEnum};
+use standard::{Order, OrderCommand, Platform, utils};
+use crate::exchange_test::{test_new_exchange};
+
+const SYMBOL: &str = "BLZ_USDT";
+
+// 测试获取Exchange实体
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_exchange() {
+    global::log_utils::init_log_with_trace();
+
+    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_self_exchange = kucoin_swap_exchange.get_self_exchange();
+    trace!(?kucoin_get_self_exchange);
+}
+
+// 测试获取交易对信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_symbol() {
+    global::log_utils::init_log_with_trace();
+
+    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_self_symbol = kucoin_swap_exchange.get_self_symbol();
+    trace!(?kucoin_get_self_symbol);
+}
+
+// 测试获取是否使用高速通道
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_is_colo() {
+    global::log_utils::init_log_with_trace();
+
+    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_self_is_colo = kucoin_swap_exchange.get_self_is_colo();
+    trace!(?kucoin_get_self_is_colo);
+}
+
+// 测试获取登录params信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_params() {
+    global::log_utils::init_log_with_trace();
+
+    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_self_params = kucoin_swap_exchange.get_self_params();
+    trace!("kucoin_get_self_params={:?}",kucoin_get_self_params);
+}
+
+// 测试获取Market信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_self_market() {
+    global::log_utils::init_log_with_trace();
+
+    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_self_market = kucoin_swap_exchange.get_self_market();
+    trace!(?kucoin_get_self_market);
+}
+
+// 测试获取请求时间信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_request_delays() {
+    global::log_utils::init_log_with_trace();
+
+    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_request_delays = kucoin_swap_exchange.get_request_delays();
+    trace!(?kucoin_get_request_delays);
+}
+
+// 测试获取请求平均时间信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_request_avg_delay() {
+    global::log_utils::init_log_with_trace();
+
+    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_request_avg_delay = kucoin_swap_exchange.get_request_avg_delay();
+    trace!(?kucoin_get_request_avg_delay);
+}
+
+// 测试获取最大请求时间信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_request_max_delay() {
+    global::log_utils::init_log_with_trace();
+
+    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_request_max_delay = kucoin_swap_exchange.get_request_max_delay();
+    trace!(?kucoin_get_request_max_delay);
+}
+
+// 测试获取服务器时间
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_server_time() {
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_server_time = kucoin_swap_exchange.get_server_time().await;
+    trace!(?kucoin_get_server_time);
+}
+
+// 测试获取账号信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_account() {
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_account = kucoin_swap_exchange.get_account().await;
+    trace!(?kucoin_get_account);
+}
+
+// 测试获取持仓信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_position() {
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_position = kucoin_swap_exchange.get_position().await;
+    trace!(?kucoin_get_position);
+}
+
+// 测试获取所有持仓信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_positions() {
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_positions = kucoin_swap_exchange.get_positions().await;
+    trace!(?kucoin_get_positions);
+}
+
+// 测试获取Ticker信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_ticker() {
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_ticker = kucoin_swap_exchange.get_ticker().await;
+    trace!(?kucoin_get_ticker);
+}
+
+// 测试获取Market信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_market() {
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_market = kucoin_swap_exchange.get_market().await;
+    trace!(?kucoin_get_market);
+}
+
+// 测试获取Order详情信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_order_detail() {
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_order_detail = kucoin_swap_exchange.get_order_detail("", "999999").await;
+    trace!(?kucoin_get_order_detail);
+}
+
+// 测试获取Order列表信息
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_get_orders_list() {
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_get_orders_list = kucoin_swap_exchange.get_orders_list("active").await;
+    trace!(?kucoin_get_orders_list);
+}
+
+// 测试下单
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_take_order() {
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_take_order = kucoin_swap_exchange.take_order("999999", "kk", dec!(0.2), dec!(100)).await;
+    trace!(?kucoin_take_order);
+}
+
+// 测试撤销订单
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_cancel_order() {
+    global::log_utils::init_log_with_trace();
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
+    let kucoin_cancel_order = kucoin_swap_exchange.cancel_order("94627978104856576", "").await;
+    trace!(?kucoin_cancel_order);
+}
+
+// 测试指令下单
+#[tokio::test]
+#[instrument(level = "TRACE")]
+async fn test_command_order() {
+    global::log_utils::init_log_with_trace();
+    utils::proxy_handle();
+
+    let (order_sender, mut order_receiver): (mpsc::Sender<Order>, mpsc::Receiver<Order>) = mpsc::channel(1024);
+    let (error_sender, mut error_receiver): (mpsc::Sender<Error>, mpsc::Receiver<Error>) = mpsc::channel(1024);
+
+    let mut params: BTreeMap<String, String> = BTreeMap::new();
+    let access_key = env::var("kucoin_access_key").unwrap_or("".to_string());
+    let secret_key = env::var("kucoin_secret_key").unwrap_or("".to_string());
+    let pass_key = env::var("kucoin_pass_key").unwrap_or("".to_string());
+    params.insert("access_key".to_string(), access_key);
+    params.insert("secret_key".to_string(), secret_key);
+    params.insert("pass_key".to_string(), pass_key);
+
+    let mut kucoin_swap_exchange: Box<dyn Platform> = Exchange::new(ExchangeEnum::KucoinSwap, SYMBOL.to_string(), false, params, order_sender, error_sender).await;
+    let mut command = OrderCommand::new();
+    // command.cancel.insert("888888".to_string(), vec!["888888".to_string(), "94647166466789377".to_string()]);
+    command.limits_open.insert("888888".to_string(), vec!["100".to_string(), "kd".to_string(), "0.18".to_string(), "888888".to_string()]);
+    command.limits_close.insert("999999".to_string(), vec!["100".to_string(), "kk".to_string(), "0.25".to_string(), "999999".to_string()]);
+    // command.check.insert("888888".to_string(), vec!["999999".to_string(), "94647166466789377".to_string()]);
+    kucoin_swap_exchange.command_order(command).await;
+
+
+    loop {
+        if let Ok(order) = order_receiver.try_recv() {
+            trace!(?order);
+        }
+        if let Ok(error) = error_receiver.try_recv() {
+            trace!(?error);
+        }
+    }
+}

standard/tests/libs_test.rs

@@ -161,72 +161,4 @@ async fn test_get_account() {
     let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
     let kucoin_account = kucoin_swap_exchange.get_account().await;
     trace!(?kucoin_account);
-}
-
-
-
-// 测试kucoin 获取持仓信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_kucoin_swap_get_position() {
-    global::log_utils::init_log_with_trace();
-
-    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
-    let kucoin_get_position = kucoin_swap_exchange.get_position().await;
-    trace!(?kucoin_get_position);
-}
-
-// 测试kucoin 获取所有持仓信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_kucoin_swap_get_positions() {
-    global::log_utils::init_log_with_trace();
-
-    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
-    let kucoin_get_positions = kucoin_swap_exchange.get_positions().await;
-    trace!(?kucoin_get_positions);
-}
-
-// 测试kucoin 获取Ticker信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_kucoin_swap_get_ticker() {
-    global::log_utils::init_log_with_trace();
-
-    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
-    let kucoin_get_ticker = kucoin_swap_exchange.get_ticker().await;
-    trace!(?kucoin_get_ticker);
-}
-
-// 测试kucoin 获取Market信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_kucoin_swap_get_market() {
-    global::log_utils::init_log_with_trace();
-
-    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
-    let kucoin_get_market = kucoin_swap_exchange.get_market().await;
-    trace!(?kucoin_get_market);
-}
-
-// 测试kucoin 获取订单信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_kucoin_swap_get_order_detail() {
-    global::log_utils::init_log_with_trace();
-
-    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
-    let kucoin_get_order_detail = kucoin_swap_exchange.get_order_detail("123", "").await;
-    trace!(?kucoin_get_order_detail);
-}
-
-// 测试kucoin 获取订单列表
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_kucoin_swap_get_orders_list() {
-    global::log_utils::init_log_with_trace();
-
-    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap).await;
-    let kucoin_get_orders_list = kucoin_swap_exchange.get_orders_list("").await;
-    trace!(?kucoin_get_orders_list);
-}
+}