报错与警告清除。

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "as-rust"
-version = "3.5.0"
+version = "5.0.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

derive/tests/binance_swap_export_test.rs

@@ -1,19 +0,0 @@
-mod export_excel_test;
-
-use tracing::{instrument, trace};
-use derive::export_excel::ExportEnum;
-use crate::export_excel_test::test_new_export;
-
-
-const SYMBOL: &str = "SUPER_USDT";
-
-// 测试获取Exchange实体
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_exchange() {
-    global::log_utils::init_log_with_trace();
-
-    let mut export = test_new_export(ExportEnum::BinanceSwap).await;
-    let export_trades = export.export_trades("binance_swap", SYMBOL.to_string(), 1726027200000, 1726103276000, 1000).await;
-    trace!(?export_trades);
-}

derive/tests/bitget_spot_export_test.rs

@@ -1,18 +0,0 @@
-mod export_excel_test;
-
-use tracing::{instrument, trace};
-use derive::export_excel::ExportEnum;
-use crate::export_excel_test::test_new_export;
-
-
-const SYMBOL: &str = "LOOM_USDT";
-// 测试获取Exchange实体
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_exchange() {
-    global::log_utils::init_log_with_trace();
-
-    let mut export = test_new_export(ExportEnum::BitgetSpot).await;
-    let export_trades = export.export_trades("bitget_spot",SYMBOL.to_string(), 0, 0, 100).await;
-    trace!(?export_trades);
-}

derive/tests/bitget_swap_export_test.rs

@@ -1,19 +0,0 @@
-mod export_excel_test;
-
-use tracing::{instrument, trace};
-use derive::export_excel::ExportEnum;
-use crate::export_excel_test::test_new_export;
-
-
-const SYMBOL: &str = "sushi_usdt";
-
-// 测试获取Exchange实体
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_exchange() {
-    global::log_utils::init_log_with_trace();
-
-    let mut export = test_new_export(ExportEnum::BitgetSwap).await;
-    let export_trades = export.export_trades("bitget_swap_42", SYMBOL.to_string(), 1733720400000, 1733796040000, 100).await;
-    trace!(?export_trades);
-}

derive/tests/bybit_swap_export_test.rs

@@ -1,19 +0,0 @@
-mod export_excel_test;
-
-use tracing::{instrument, trace};
-use derive::export_excel::ExportEnum;
-use crate::export_excel_test::test_new_export;
-
-
-const SYMBOL: &str = "MEMEFI_USDT";
-
-// 测试获取Exchange实体
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_exchange() {
-    global::log_utils::init_log_with_trace();
-
-    let mut export = test_new_export(ExportEnum::BybitSwap).await;
-    let export_trades = export.export_trades("bybit_swap_01", SYMBOL.to_string(), 1732605480000, 1732672800000, 100).await;
-    trace!(?export_trades);
-}

derive/tests/export_excel_test.rs

@@ -1,95 +0,0 @@
-use std::collections::{BTreeMap};
-use tracing::trace;
-use derive::export_excel::{ExportEnum, ExportExcel};
-use derive::ExportConnector;
-use exchanges::proxy;
-
-// 创建实体
-#[allow(dead_code)]
-pub async fn test_new_export(export_enum: ExportEnum) -> Box<dyn ExportConnector> {
-    // 检测是否走代理
-    pub fn proxy_handle() {
-        if proxy::ParsingDetail::http_enable_proxy(None) {
-            trace!("检测有代理配置，配置走代理");
-        }
-    }
-
-    let account_info = global::account_info::get_account_info("../test_account.toml");
-
-    match export_enum {
-        ExportEnum::BinanceSwap => {
-            let mut params: BTreeMap<String, String> = BTreeMap::new();
-            let access_key = account_info.binance_access_key;
-            let secret_key = account_info.binance_secret_key;
-            params.insert("access_key".to_string(), access_key);
-            params.insert("secret_key".to_string(), secret_key);
-            ExportExcel::new(ExportEnum::BinanceSwap, false, params).await
-        }
-        // ExportEnum::KucoinSwap => {
-        //     let mut params: BTreeMap<String, String> = BTreeMap::new();
-        //     let access_key = account_info.kucoin_access_key;
-        //     let secret_key = account_info.kucoin_secret_key;
-        //     let pass_key = account_info.kucoin_pass;
-        //     params.insert("access_key".to_string(), access_key);
-        //     params.insert("secret_key".to_string(), secret_key);
-        //     params.insert("pass_key".to_string(), pass_key);
-        //     ExportExcel::new(ExportEnum::KucoinSwap, false, params).await
-        // }
-        // ExportEnum::KucoinSpot => {
-        //     let mut params: BTreeMap<String, String> = BTreeMap::new();
-        //     let access_key = account_info.kucoin_access_key;
-        //     let secret_key = account_info.kucoin_secret_key;
-        //     let pass_key = account_info.kucoin_pass;
-        //     params.insert("access_key".to_string(), access_key);
-        //     params.insert("secret_key".to_string(), secret_key);
-        //     params.insert("pass_key".to_string(), pass_key);
-        //     ExportExcel::new(ExportEnum::KucoinSpot, false, params).await
-        // }
-        ExportEnum::GateSwap => {
-            let mut params: BTreeMap<String, String> = BTreeMap::new();
-            let access_key = account_info.gate_access_key;
-            let secret_key = account_info.gate_secret_key;
-            params.insert("access_key".to_string(), access_key);
-            params.insert("secret_key".to_string(), secret_key);
-            ExportExcel::new(ExportEnum::GateSwap, false, params).await
-        }
-        ExportEnum::BybitSwap => {
-            let mut params: BTreeMap<String, String> = BTreeMap::new();
-            let access_key = account_info.bybit_access_key;
-            let secret_key = account_info.bybit_secret_key;
-            params.insert("access_key".to_string(), access_key);
-            params.insert("secret_key".to_string(), secret_key);
-            ExportExcel::new(ExportEnum::BybitSwap, false, params).await
-        }
-        ExportEnum::BitgetSwap => {
-            let mut params: BTreeMap<String, String> = BTreeMap::new();
-            let access_key = account_info.bitget_access_key;
-            let secret_key = account_info.bitget_secret_key;
-            let pass_key = account_info.bitget_pass;
-            params.insert("access_key".to_string(), access_key);
-            params.insert("secret_key".to_string(), secret_key);
-            params.insert("pass_key".to_string(), pass_key);
-            ExportExcel::new(ExportEnum::BitgetSwap, false, params).await
-        }
-        // ExportEnum::BitgetSpot => {
-        //     let mut params: BTreeMap<String, String> = BTreeMap::new();
-        //     let access_key = account_info.bitget_access_key;
-        //     let secret_key = account_info.bitget_secret_key;
-        //     let pass_key = account_info.bitget_pass;
-        //     params.insert("access_key".to_string(), access_key);
-        //     params.insert("secret_key".to_string(), secret_key);
-        //     params.insert("pass_key".to_string(), pass_key);
-        //     ExportExcel::new(ExportEnum::BitgetSpot, false, params).await
-        // }
-        // ExportEnum::OkxSwap => {
-        //     let mut params: BTreeMap<String, String> = BTreeMap::new();
-        //     let access_key = account_info.okx_access_key;
-        //     let secret_key = account_info.okx_secret_key;
-        //     let pass_key = account_info.okx_pass;
-        //     params.insert("access_key".to_string(), access_key);
-        //     params.insert("secret_key".to_string(), secret_key);
-        //     params.insert("pass_key".to_string(), pass_key);
-        //     ExportExcel::new(ExportEnum::OkxSwap, false, params).await
-        // }
-    }
-}

derive/tests/gate_swap_export_test.rs

@@ -1,19 +0,0 @@
-mod export_excel_test;
-
-use tracing::{instrument, trace};
-use derive::export_excel::ExportEnum;
-use crate::export_excel_test::test_new_export;
-
-
-const SYMBOL: &str = "";
-
-// 测试获取Exchange实体
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_exchange() {
-    global::log_utils::init_log_with_trace();
-
-    let mut export = test_new_export(ExportEnum::GateSwap).await;
-    let export_trades = export.export_trades("gate_swap_42", SYMBOL.to_string(), 1723651201000, 1724035036000, 1000).await;
-    trace!(?export_trades);
-}

derive/tests/kucoin_spot_export_test.rs

@@ -1,18 +0,0 @@
-mod export_excel_test;
-
-use tracing::{instrument, trace};
-use derive::export_excel::ExportEnum;
-use crate::export_excel_test::test_new_export;
-
-
-const SYMBOL: &str = "LOOM_USDT";
-// 测试获取Exchange实体
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_exchange() {
-    global::log_utils::init_log_with_trace();
-
-    let mut export = test_new_export(ExportEnum::KucoinSpot).await;
-    let export_trades = export.export_trades("kucoin_spot",SYMBOL.to_string(), 0, 0, 100).await;
-    trace!(?export_trades);
-}

derive/tests/kucoin_swap_export_test.rs

@@ -1,18 +0,0 @@
-mod export_excel_test;
-
-use tracing::{instrument, trace};
-use derive::export_excel::ExportEnum;
-use crate::export_excel_test::test_new_export;
-
-
-const SYMBOL: &str = "LOOM_USDT";
-// 测试获取Exchange实体
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_exchange() {
-    global::log_utils::init_log_with_trace();
-
-    let mut export = test_new_export(ExportEnum::KucoinSwap).await;
-    let export_trades = export.export_trades("kucoin_swap",SYMBOL.to_string(), 0, 0, 100).await;
-    trace!(?export_trades);
-}

derive/tests/okx_swap_export_test.rs

@@ -1,18 +0,0 @@
-mod export_excel_test;
-
-use tracing::{instrument, trace};
-use derive::export_excel::ExportEnum;
-use crate::export_excel_test::test_new_export;
-
-
-const SYMBOL: &str = "LOOM_USDT";
-// 测试获取Exchange实体
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_exchange() {
-    global::log_utils::init_log_with_trace();
-
-    let mut export = test_new_export(ExportEnum::OkxSwap).await;
-    let export_trades = export.export_trades("okx_swap",SYMBOL.to_string(), 0, 0, 100).await;
-    trace!(?export_trades);
-}

exchanges/tests/binance_spot_test.rs

@@ -1,94 +0,0 @@
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-use std::time::Duration;
-use futures_util::StreamExt;
-
-use tokio::sync::Mutex;
-use tokio_tungstenite::tungstenite::Message;
-use tracing::trace;
-
-use exchanges::binance_spot_ws::{BinanceSpotLogin, BinanceSpotSubscribeType, BinanceSpotWs, BinanceSpotWsType};
-use exchanges::socket_tool::AbstractWsMode;
-
-// 账号密码
-const ACCESS_KEY: &str = "";
-const SECRET_KEY: &str = "";
-
-
-//ws-订阅公共频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn ws_custom_subscribe() {
-    global::log_utils::init_log_with_trace();
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded();
-
-    let login_param = BinanceSpotLogin {
-        api_key: ACCESS_KEY.to_string(),
-        api_secret: SECRET_KEY.to_string(),
-    };
-    let mut ws = get_ws(None);
-    ws.set_symbols(vec!["BTC_USDT".to_string()]);
-    ws.set_subscribe(vec![
-        // BinanceSpotSubscribeType::PuBookTicker,
-        // BinanceSpotSubscribeType::PuAggTrade,
-        BinanceSpotSubscribeType::PuDepth20levels100ms,
-    ]);
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-        // trace!("线程-数据读取-结束");
-    });
-
-    //写数据
-    // let bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    // let write_tx_clone = Arc::clone(&write_tx_am);
-    // let su = ws.get_subscription();
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20 * 1000)).await;
-    //         // let close_frame = CloseFrame {
-    //         //     code: CloseCode::Normal,
-    //         //     reason: Cow::Borrowed("Bye bye"),
-    //         // };
-    //         // let message = Message::Close(Some(close_frame));
-    //
-    //
-    //         let message = Message::Text(su.clone());
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), message.clone()).await;
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-fn get_ws(login_param: Option<BinanceSpotLogin>) -> BinanceSpotWs {
-    let binance_ws = BinanceSpotWs::new(false,
-                                        login_param, BinanceSpotWsType::PublicAndPrivate,
-    );
-    binance_ws
-}
-

exchanges/tests/binance_swap_test.rs

@@ -1,352 +0,0 @@
-use std::collections::BTreeMap;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-use serde_json::json;
-use tokio::sync::Mutex;
-use tracing::trace;
-
-use exchanges::binance_swap_rest::BinanceSwapRest;
-use exchanges::binance_swap_ws::{BinanceSwapLogin, BinanceSwapSubscribeType, BinanceSwapWs, BinanceSwapWsType};
-use exchanges::response_base::ResponseData;
-
-const ACCESS_KEY: &str = "";
-const SECRET_KEY: &str = "";
-
-
-//ws-订阅公共频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn ws_custom_subscribe() {
-    global::log_utils::init_log_with_trace();
-
-
-        let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-        let (_, mut read_rx) = futures_channel::mpsc::unbounded::<ResponseData>();
-
-        // let (write_tx, write_rx) = tokio::sync::broadcast::channel::<Message>(10);
-        // let (read_tx, mut read_rx) = tokio::sync::broadcast::channel::<ResponseData>(10);
-
-
-        let write_tx_am = Arc::new(Mutex::new(write_tx));
-        let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-        //读取
-        let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-        let _tr = tokio::spawn(async move {
-            trace!("线程-数据读取-开启");
-            loop {
-                // 从通道中接收并丢弃所有的消息，直到通道为空
-                while let Ok(Some(_)) = read_rx.try_next() {
-
-                    // 从通道中接收并丢弃所有的消息，直到通道为空
-                    while let Ok(Some(_)) = read_rx.try_next() {
-                        // 消息被忽略
-                    }
-                }
-            }
-            // trace!("线程-数据读取-结束");
-        });
-
-        //写数据
-        // let bool_v2_clone = Arc::clone(&is_shutdown_arc);
-        // let write_tx_clone = Arc::clone(&write_tx_am);
-        // let su = ws.get_subscription();
-        // let tw = tokio::spawn(async move {
-        //     trace!("线程-数据写入-开始");
-        //     loop {
-        //         tokio::time::sleep(Duration::from_millis(20 * 1000)).await;
-        //         // let close_frame = CloseFrame {
-        //         //     code: CloseCode::Normal,
-        //         //     reason: Cow::Borrowed("Bye bye"),
-        //         // };
-        //         // let message = Message::Close(Some(close_frame));
-        //
-        //
-        //         let message = Message::Text(su.clone());
-        //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), message.clone()).await;
-        //         trace!("发送指令成功");
-        //     }
-        //     trace!("线程-数据写入-结束");
-        // });
-
-        let fun = move |data: ResponseData| {
-            async move {
-                trace!("---传入的方法~~~~{:?}", data);
-            }
-        };
-        let param = BinanceSwapLogin {
-            api_key: ACCESS_KEY.to_string(),
-            api_secret: SECRET_KEY.to_string(),
-        };
-        let t1 = tokio::spawn(async move {
-            let mut ws = get_ws(Option::from(param), BinanceSwapWsType::Private).await;
-            ws.set_symbols(vec!["BTC_USDT".to_string(), "ETC_USDT".to_string()]);
-            ws.set_subscribe(vec![
-                // BinanceSwapSubscribeType::PuBookTicker,
-                // BinanceSwapSubscribeType::PuAggTrade,
-                // BinanceSwapSubscribeType::PuDepth20levels100ms,
-
-                BinanceSwapSubscribeType::PrAccount,
-                BinanceSwapSubscribeType::PrBalance,
-                BinanceSwapSubscribeType::PrPosition
-            ]);
-            //链接
-            let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-            ws.ws_connect_async(bool_v3_clone, fun, &write_tx_am, write_rx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-            trace!("test 唯一线程结束--");
-        });
-        tokio::try_join!(t1).unwrap();
-        trace!("当此结束");
-        trace!("重启！");
-        trace!("参考交易所关闭");
-        return;
-
-    //
-    // tokio::time::sleep(Duration::from_millis(10 * 1000)).await;
-    // let mut rest = get_rest();
-    // let ttt = chrono::Utc::now().timestamp_millis() + 6000000;
-    // let rep_data = rest.swap_order(json!({
-    //       "symbol":"CFXUSDT",
-    //       "side":"BUY",
-    //       "positionSide":"LONG",
-    //       "type":"LIMIT",
-    //       "quantity":50,
-    //       "price":0.11,
-    //       "timeInForce":"GTD",
-    //      "goodtilldate":ttt
-    // })).await;
-    // trace!(?rep_data);
-    // trace!("1111111111");
-}
-
-//rest-获取服务器时间
-#[tokio::test]
-async fn rest_get_server_time_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_server_time().await;
-    trace!(?rep_data)
-}
-
-//rest-获取交易规则和交易对
-#[tokio::test]
-async fn rest_get_exchange_info_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_exchange_info().await;
-    trace!(?rep_data)
-}
-
-//---------------------------------------------------------------------
-//rest-账户信息
-#[tokio::test]
-async fn rest_get_account_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_account().await;
-    trace!(?rep_data)
-}
-
-
-//rest-持仓模式
-#[tokio::test]
-async fn rest_get_pos_side_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_pos_side().await;
-    trace!(?rep_data)
-}
-
-//rest-更改持仓模式
-#[tokio::test]
-async fn rest_change_pos_side_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.change_pos_side(true).await;
-    trace!(?rep_data)
-}
-
-//rest-调整开仓杠杆
-#[tokio::test]
-async fn rest_setting_dual_leverage_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.setting_dual_leverage(json!({
-            "symbol":"symbol",
-            "leverage":"leverage"
-         })).await;
-    trace!(?rep_data)
-}
-
-//rest-查询订单
-#[tokio::test]
-async fn rest_get_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    // symbol	STRING	YES	交易对
-    // orderId	LONG	NO	系统订单号
-    // origClientOrderId	STRING	NO	用户自定义的订单号
-    // recvWindow	LONG	NO
-    // timestamp	LONG	YES
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_order(json!({
-        "symbol":"CFXUSDT",
-         "orderId":"111",
-    })).await;
-    trace!(?rep_data)
-}
-
-//rest-查询当前挂单
-#[tokio::test]
-async fn rest_get_open_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    // symbol	STRING	YES	交易对
-    // orderId	LONG	NO	系统订单号
-    // origClientOrderId	STRING	NO	用户自定义的订单号
-    // recvWindow	LONG	NO
-    // timestamp	LONG	YES
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_open_order(json!({
-        "symbol":"CFXUSDT",
-         "orderId":"111",
-    })).await;
-    trace!(?rep_data)
-}
-
-//rest-查看当前全部挂单
-#[tokio::test]
-async fn rest_get_open_orders_test() {
-    global::log_utils::init_log_with_trace();
-
-    // symbol	STRING	YES	交易对
-    // orderId	LONG	NO	系统订单号
-    // origClientOrderId	STRING	NO	用户自定义的订单号
-    // recvWindow	LONG	NO
-    // timestamp	LONG	YES
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_open_orders(json!({
-        "symbol":"CFXUSDT",
-         "orderId":"111",
-    })).await;
-    trace!(?rep_data)
-}
-
-//rest-查询所有订单(包括历史订单)
-#[tokio::test]
-async fn rest_get_all_orders_test() {
-    global::log_utils::init_log_with_trace();
-
-    // symbol	STRING	YES	交易对
-    // orderId	LONG	NO	只返回此orderID及之后的订单，缺省返回最近的订单
-    // startTime	LONG	NO	起始时间
-    // endTime	LONG	NO	结束时间
-    // limit	INT	NO	返回的结果集数量 默认值:500 最大值:1000
-    // recvWindow	LONG	NO
-    // timestamp	LONG	YES
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_all_orders(json!({
-          "symbol":"CFXUSDT",
-            "limit":100
-    })).await;
-    trace!(?rep_data)
-}
-
-//rest-下单
-#[tokio::test]
-async fn rest_swap_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let ttt = chrono::Utc::now().timestamp_millis() + 6000000;
-    let rep_data = rest.swap_order(json!({
-          "symbol":"CFXUSDT",
-          "side":"BUY",
-          "positionSide":"LONG",
-          "type":"LIMIT",
-          "quantity":50,
-          "price":0.11,
-          "timeInForce":"GTD",
-         "goodtilldate":ttt
-    })).await;
-    trace!(?rep_data)
-}
-
-//rest-根据币对 撤销全部订单
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn rest_cancel_order_all_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-
-    let rep_data = rest.cancel_order_all(json!({ "symbol":"CFXUSDT"})).await;
-    trace!(?rep_data);
-}
-
-//rest-账户成交历史
-#[tokio::test]
-async fn rest_get_user_trades_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_user_trades("BTCUSDT".to_string(), -1, -1, 500).await;
-    trace!(?rep_data)
-}
-
-//rest-生成listenKey
-#[tokio::test]
-async fn rest_get_listen_key_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_listen_key(json!({
-    })).await;
-    trace!(?rep_data)
-}
-
-//rest-生成listenKey
-#[tokio::test]
-async fn rest_up_listen_key_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.up_listen_key(json!({
-    })).await;
-    trace!(?rep_data)
-}
-
-//rest-生成listenKey
-#[tokio::test]
-async fn rest_close_listen_key_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.close_listen_key(json!({
-    })).await;
-    trace!(?rep_data)
-}
-
-async fn get_ws(btree_map: Option<BinanceSwapLogin>, ws_type: BinanceSwapWsType) -> BinanceSwapWs {
-    let binance_ws = BinanceSwapWs::new(false,
-                                        btree_map,
-                                        ws_type).await;
-    binance_ws
-}
-
-fn get_rest() -> BinanceSwapRest {
-    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-    btree_map.insert("access_key".to_string(), ACCESS_KEY.to_string());
-    btree_map.insert("secret_key".to_string(), SECRET_KEY.to_string());
-
-    let ba_exc = BinanceSwapRest::new(false, btree_map);
-    ba_exc
-}

exchanges/tests/bitget_spot_test.rs

@@ -1,515 +0,0 @@
-use std::collections::BTreeMap;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-
-use futures_util::StreamExt;
-use tokio::sync::Mutex;
-use tracing::trace;
-
-use exchanges::bitget_spot_rest::BitgetSpotRest;
-use exchanges::bitget_spot_ws::{BitgetSpotLogin, BitgetSpotSubscribeType, BitgetSpotWs, BitgetSpotWsType};
-
-const ACCESS_KEY: &str = "";
-const SECRET_KEY: &str = "";
-const PASS_KEY: &str = "";
-
-//ws-订阅公共频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn ws_custom_subscribe_pu() {
-    global::log_utils::init_log_with_trace();
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded();
-
-    let  is_shutdown_arc = Arc::new(AtomicBool::new(true));
-    let mut ws = get_ws(None, BitgetSpotWsType::Public).await;
-    ws.set_symbols(vec!["BTC_USDT".to_string()]);
-    ws.set_subscribe(vec![
-        BitgetSpotSubscribeType::PuTicker,
-        BitgetSpotSubscribeType::PuCandle1m,
-        BitgetSpotSubscribeType::PuTrade,
-        BitgetSpotSubscribeType::PuBooks5,
-    ]);
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-        // trace!("线程-数据读取-结束");
-    });
-
-    //写数据
-    // let bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    // let write_tx_clone = Arc::clone(&write_tx_am);
-    // let su = ws.get_subscription();
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20 * 1000)).await;
-    //         // let close_frame = CloseFrame {
-    //         //     code: CloseCode::Normal,
-    //         //     reason: Cow::Borrowed("Bye bye"),
-    //         // };
-    //         // let message = Message::Close(Some(close_frame));
-    //
-    //
-    //         let message = Message::Text(su.clone());
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), message.clone()).await;
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-//ws-订阅私有频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn ws_custom_subscribe_pr() {
-    global::log_utils::init_log_with_trace();
-
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded();
-
-    let login_param = BitgetSpotLogin {
-        api_key: ACCESS_KEY.to_string(),
-        secret_key: SECRET_KEY.to_string(),
-        passphrase_key: PASS_KEY.to_string(),
-    };
-    let mut ws = get_ws(None, BitgetSpotWsType::Private).await;
-    ws.set_symbols(vec!["BTC_USDT".to_string()]);
-    ws.set_subscribe(vec![
-        BitgetSpotSubscribeType::PuTicker,
-        BitgetSpotSubscribeType::PuCandle1m,
-        BitgetSpotSubscribeType::PuTrade,
-        BitgetSpotSubscribeType::PuBooks5,
-    ]);
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-//读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-        // trace!("线程-数据读取-结束");
-    });
-
-    //写数据
-    // let bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    // let write_tx_clone = Arc::clone(&write_tx_am);
-    // let su = ws.get_subscription();
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20 * 1000)).await;
-    //         // let close_frame = CloseFrame {
-    //         //     code: CloseCode::Normal,
-    //         //     reason: Cow::Borrowed("Bye bye"),
-    //         // };
-    //         // let message = Message::Close(Some(close_frame));
-    //
-    //
-    //         let message = Message::Text(su.clone());
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), message.clone()).await;
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-
-//rest-获取系统时间
-#[tokio::test]
-async fn rest_get_server_time_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_server_time().await;
-    trace!(?rep_data)
-}
-
-
-//rest-获取账户信息
-#[tokio::test]
-async fn rest_get_account_info_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_account_info().await;
-    trace!(?rep_data)
-}
-
-//rest-获取账户币种资产
-#[tokio::test]
-async fn rest_get_account_assets_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_account_assets().await;
-    trace!(?rep_data)
-}
-
-//rest-获取币种信息
-#[tokio::test]
-async fn rest_get_coins_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_coins("USDT".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-获取交易对信息
-#[tokio::test]
-async fn rest_get_symbols_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_symbols("BTCUSDT".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-获取现货VIP费率
-#[tokio::test]
-async fn rest_get_vip_fee_rate_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_vip_fee_rate().await;
-    trace!(?rep_data)
-}
-
-//rest-获取行情信息
-#[tokio::test]
-async fn rest_get_tickers_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_tickers("BTCUSDT".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-获取合并交易深度
-#[tokio::test]
-async fn rest_get_merge_depth_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_merge_depth("BTCUSDT".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-获取K线数据
-#[tokio::test]
-async fn rest_get_candles_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_candles("BTCUSDT".to_string(), "1min".to_string(), "1697701550192".to_string(), "1697701556192".to_string(), "100".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-获取历史K线数据
-#[tokio::test]
-async fn rest_get_history_candles_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_history_candles("BTCUSDT".to_string(), "1min".to_string(), "1697701556192".to_string(), "100".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-获取最近成交数据
-#[tokio::test]
-async fn rest_get_market_fills_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_market_fills("BTCUSDT".to_string(), "100".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-获取历史成交数据
-#[tokio::test]
-async fn rest_get_fills_history_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_market_fills_history("BTCUSDT".to_string(), "1697701550192".to_string(), "1697701556192".to_string(), "100".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-下单
-#[tokio::test]
-async fn rest_spot_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    //市价单
-    let mut rest = get_rest();
-    let params = serde_json::json!({
-            // "symbol":"CELRUSDT",
-            // "side":"sell",
-            // "orderType":"market",
-            // "force":"fok",
-            // "size":"887",
-            // "clientOid":"7d8zd4d_3",
-         });
-
-    //限价单
-    let params = serde_json::json!({
-            // "symbol":"CELRUSDT",
-            // "side":"buy",
-            // "orderType":"limit",
-            // "force":"gtc",
-            // "price":"0.01001",
-            // "size":"10",
-            // "clientOid":"7d8zd4d_z1",
-         });
-
-    let rep_data = rest.spot_order(params).await;
-    trace!(?rep_data)
-}
-
-
-//rest-撤单
-#[tokio::test]
-async fn rest_spot_cancel_order_test() {
-    global::log_utils::init_log_with_trace();
-    let mut rest = get_rest();
-    let rep_data = rest.spot_cancel_order("CELRUSDT".to_string(), "".to_string(), "1".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-批量撤单
-#[tokio::test]
-async fn rest_spot_cancel_orders_test() {
-    global::log_utils::init_log_with_trace();
-    let mut rest = get_rest();
-    let v = serde_json::json!({
-            "orderId":"1073370944162058240",
-            "clientOid":"1073370944162058240"
-        });
-    let rep_data = rest.spot_cancel_orders("CELRUSDT".to_string(), vec![v]).await;
-    trace!(?rep_data)
-}
-
-//rest-按币对撤单
-#[tokio::test]
-async fn rest_spot_cancel_symbol_orders_test() {
-    global::log_utils::init_log_with_trace();
-    let mut rest = get_rest();
-    let rep_data = rest.spot_cancel_symbol_orders("CELRUSDT".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-获取订单详情
-#[tokio::test]
-async fn rest_get_order_test() {
-    global::log_utils::init_log_with_trace();
-    let mut rest = get_rest();
-    let rep_data = rest.get_order("".to_string(), "1".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-获取当前委托列表
-#[tokio::test]
-async fn rest_get_unfilled_orders_test() {
-    global::log_utils::init_log_with_trace();
-    let mut rest = get_rest();
-    let rep_data = rest.get_unfilled_orders("CELRUSDT".to_string(),
-                                            "".to_string(),
-                                            "".to_string(),
-                                            "".to_string(),
-                                            "".to_string(),
-                                            "".to_string(),
-    ).await;
-    trace!(?rep_data)
-}
-
-//rest-获取历史委托列表
-#[tokio::test]
-async fn rest_get_history_orders_test() {
-    global::log_utils::init_log_with_trace();
-    let mut rest = get_rest();
-    let rep_data = rest.get_history_orders("CELRUSDT".to_string(),
-                                           "".to_string(),
-                                           "".to_string(),
-                                           "".to_string(),
-                                           "".to_string(),
-                                           "".to_string(),
-    ).await;
-    trace!(?rep_data)
-}
-
-//rest-获取成交明细
-#[tokio::test]
-async fn rest_get_fills_test() {
-    global::log_utils::init_log_with_trace();
-    let mut rest = get_rest();
-    let rep_data = rest.get_fills("CELRUSDT".to_string(),
-                                  "1".to_string(),
-                                  "".to_string(),
-                                  "".to_string(),
-                                  "".to_string(),
-                                  "".to_string(),
-    ).await;
-    trace!(?rep_data)
-}
-
-//rest-获取成交明细
-#[tokio::test]
-async fn rest_spot_place_plan_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    //限价-委托单
-    let params = serde_json::json!({
-         });
-
-    let rep_data = rest.spot_place_plan_order(params).await;
-    trace!(?rep_data)
-}
-
-//rest-修改计划委托
-#[tokio::test]
-async fn rest_update_place_plan_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    //限价-委托单
-    let params = serde_json::json!({
-         });
-
-    let rep_data = rest.update_place_plan_order(params).await;
-    trace!(?rep_data)
-}
-
-//rest-撤销计划委托
-#[tokio::test]
-async fn rest_cancel_plan_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.cancel_plan_order("32131".to_string(), "3211".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-获取当前计划委托
-#[tokio::test]
-async fn rest_get_current_plan_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_current_plan_order("CELRUSDT".to_string(),
-                                               "1".to_string(),
-                                               "".to_string(),
-                                               "".to_string(),
-                                               "".to_string(),
-    ).await;
-    trace!(?rep_data)
-}
-
-//rest-获取历史计划委托
-#[tokio::test]
-async fn rest_get_history_plan_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_history_plan_order("CELRUSDT".to_string(),
-                                               "1697701550192".to_string(),
-                                               "1697701580192".to_string(),
-                                               "100".to_string(),
-    ).await;
-    trace!(?rep_data)
-}
-
-//rest-批量撤销计划委托
-#[tokio::test]
-async fn rest_cancel_plan_orders_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.cancel_plan_orders(vec![]).await;
-    trace!(?rep_data)
-}
-
-//rest-划转
-#[tokio::test]
-async fn rest_wallet_transfer_test() {
-    global::log_utils::init_log_with_trace();
-    let mut rest = get_rest();
-    let rep_data = rest.wallet_transfer("".to_string(),
-                                        "".to_string(),
-                                        "".to_string(),
-                                        "".to_string(),
-                                        "".to_string(),
-                                        "".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-获取账单流水
-#[tokio::test]
-async fn rest_get_account_bills_test() {
-    global::log_utils::init_log_with_trace();
-    let mut rest = get_rest();
-    let rep_data = rest.get_account_bills("".to_string(),
-                                          "".to_string(),
-                                          "".to_string(),
-                                          "".to_string(), ).await;
-    trace!(?rep_data)
-}
-
-
-async fn get_ws(btree_map: Option<BitgetSpotLogin>, type_v: BitgetSpotWsType) -> BitgetSpotWs {
-    let mut ku_ws = BitgetSpotWs::new(false, btree_map.clone(), type_v);
-    ku_ws
-}
-
-fn get_rest() -> BitgetSpotRest {
-    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-    // btree_map.insert("access_key".to_string(), ACCESS_KEY.to_string());
-    // btree_map.insert("secret_key".to_string(), SECRET_KEY.to_string());
-    btree_map.insert("access_key".to_string(), ACCESS_KEY.to_string());
-    btree_map.insert("secret_key".to_string(), SECRET_KEY.to_string());
-    btree_map.insert("pass_key".to_string(), PASS_KEY.to_string());
-
-    let mut ku_exc = BitgetSpotRest::new(false, btree_map);
-    ku_exc
-}

exchanges/tests/bitget_swap_test.rs

@@ -1,145 +0,0 @@
-use std::collections::BTreeMap;
-use serde_json::json;
-use tracing::{info};
-use exchanges::bitget_swap_rest::BitgetSwapRest;
-
-const ACCESS_KEY: &str = "";
-const SECRET_KEY: &str = "";
-const PASS_KEY: &str = "";
-
-// 测试账户信息获取
-#[tokio::test]
-async fn rest_get_account_info_test() {
-    global::log_utils::init_log_with_info();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_account_info().await;
-    info!(?rep_data)
-}
-
-// 下单测试
-#[tokio::test]
-async fn post_order_test() {
-    global::log_utils::init_log_with_info();
-
-    let mut rest = get_rest();
-    let params = json!({
-        "symbol": "BTCUSDT",
-        "productType": "USDT-FUTURES",
-        "marginMode": "crossed",
-        "marginCoin": "USDT",
-        "size": "0.001",
-        "side": "buy",
-        "tradeSide": "close",
-        "orderType": "market",
-        "clientOid": "1130615113245"
-    });
-    let response = rest.swap_order(params).await;
-
-    info!(?response)
-}
-
-// 撤单测试
-#[tokio::test]
-async fn cancel_order_test() {
-    global::log_utils::init_log_with_info();
-
-    let mut rest = get_rest();
-    let params = json!({
-        "symbol": "ethusdt",
-        "productType": "USDT-FUTURES",
-        "clientOid": "1130615111",
-    });
-    let response = rest.cancel_order(params).await;
-
-    info!(?response)
-}
-
-// 获取订单详情测试
-#[tokio::test]
-async fn get_order_test() {
-    global::log_utils::init_log_with_info();
-
-    let mut rest = get_rest();
-    let params = json!({
-        "symbol": "ETHUSDT",
-        "productType": "USDT-FUTURES",
-        "clientOid": "1130615132",
-    });
-    let response = rest.get_order(params).await;
-
-    info!(?response)
-}
-
-// 获取当前的pending订单
-#[tokio::test]
-async fn get_pending_orders_test() {
-    global::log_utils::init_log_with_info();
-
-    let mut rest = get_rest();
-    let response = rest.get_pending_orders().await;
-
-    info!(?response)
-}
-
-// 设置杠杆测试
-#[tokio::test]
-async fn set_leverage_test() {
-    global::log_utils::init_log_with_info();
-
-    let mut rest = get_rest();
-
-
-    let params = json!({
-        "symbol": "ETHUSDT",
-        "productType": "USDT-FUTURES",
-        "marginCoin": "USDT",
-        "leverage": "5"
-    });
-    let response = rest.set_leverage(params).await;
-
-    info!(?response)
-}
-
-// 设置持仓模式
-#[tokio::test]
-async fn set_position_mode_test() {
-    global::log_utils::init_log_with_info();
-
-    let mut rest = get_rest();
-
-
-    let params = json!({
-        "productType": "USDT-FUTURES",
-        "posMode": "hedge_mode",
-    });
-    let response = rest.set_position_mode(params).await;
-
-    info!(?response)
-}
-
-// 获取仓位信息
-#[tokio::test]
-async fn get_single_position_test() {
-    global::log_utils::init_log_with_info();
-
-    let mut rest = get_rest();
-    let params = json!({
-        "productType": "USDT-FUTURES",
-        "symbol": "ETHUSDT",
-        "marginCoin": "USDT"
-    });
-    let response = rest.get_single_position(params).await;
-
-    info!(?response)
-}
-
-fn get_rest() -> BitgetSwapRest {
-    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-
-    btree_map.insert("access_key".to_string(), ACCESS_KEY.to_string());
-    btree_map.insert("secret_key".to_string(), SECRET_KEY.to_string());
-    btree_map.insert("pass_key".to_string(), PASS_KEY.to_string());
-
-    BitgetSwapRest::new(false, btree_map)
-}

exchanges/tests/bybit_swap_test.rs

@@ -1,359 +0,0 @@
-use std::collections::BTreeMap;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-use futures_util::StreamExt;
-use tokio::sync::Mutex;
-use tracing::trace;
-
-use exchanges::bybit_swap_rest::BybitSwapRest;
-use exchanges::bybit_swap_ws::{BybitSwapLogin, BybitSwapSubscribeType, BybitSwapWs, BybitSwapWsType};
-use exchanges::response_base::ResponseData;
-
-const ACCESS_KEY: &str = "";
-const SECRET_KEY: &str = "";
-
-
-//ws-订阅公共频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 5)]
-async fn ws_custom_subscribe_pu() {
-    global::log_utils::init_log_with_trace();
-
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded::<ResponseData>();
-
-
-    let mut ws = get_ws(None, BybitSwapWsType::Public);
-    ws.set_symbols(vec!["BTC_USDT".to_string()]);
-    ws.set_subscribe(vec![
-        // BybitSwapSubscribeType::PuOrderBook1,
-        // BybitSwapSubscribeType::PuOrderBook50,
-        // BybitSwapSubscribeType::PuBlicTrade,
-        BybitSwapSubscribeType::PuTickers,
-    ]);
-
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-        // trace!("线程-数据读取-结束");
-    });
-
-    //写数据
-    // let bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    // let write_tx_clone = Arc::clone(&write_tx_am);
-    // let su = ws.get_subscription();
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20 * 1000)).await;
-    //         // let close_frame = CloseFrame {
-    //         //     code: CloseCode::Normal,
-    //         //     reason: Cow::Borrowed("Bye bye"),
-    //         // };
-    //         // let message = Message::Close(Some(close_frame));
-    //
-    //
-    //         let message = Message::Text(su.clone());
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), message.clone()).await;
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-
-    let fun = move |data: ResponseData| {
-        // 在 async 块之前克隆 Arc
-        // let core_arc_cc = core_arc_clone.clone();
-        // let mul = multiplier.clone();
-        //
-        // let depth_asks = Arc::clone(&depth_asks);
-        // let depth_bids = Arc::clone(&depth_bids);
-
-        async move {
-            trace!("333333333333333：ResponseData:{:?}",data);
-            // let mut depth_asks = depth_asks.lock().await;
-            // let mut depth_bids = depth_bids.lock().await;
-            // 使用克隆后的 Arc，避免 move 语义
-            // on_public_data(core_arc_cc, &mul, &data, &mut depth_asks, &mut depth_bids).await
-        }
-    };
-
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone,fun, &write_tx_am, write_rx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-
-//ws-订阅私有频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 5)]
-async fn ws_custom_subscribe_pr() {
-
-    global::log_utils::init_log_with_trace();
-
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded::<ResponseData>();
-
-    let logparam = BybitSwapLogin {
-        api_key: ACCESS_KEY.to_string(),
-        secret_key: SECRET_KEY.to_string(),
-    };
-
-    let mut ws = get_ws(Option::from(logparam), BybitSwapWsType::Private);
-    ws.set_symbols(vec!["BTC_USDT".to_string()]);
-    ws.set_subscribe(vec![
-        BybitSwapSubscribeType::PrPosition,
-        // BybitSwapSubscribeType::PrExecution,
-        // BybitSwapSubscribeType::PrOrder,
-        // BybitSwapSubscribeType::PrWallet,
-    ]);
-
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-        // trace!("线程-数据读取-结束");
-    });
-
-    //写数据
-    // let bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    // let write_tx_clone = Arc::clone(&write_tx_am);
-    // let su = ws.get_subscription();
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20 * 1000)).await;
-    //         // let close_frame = CloseFrame {
-    //         //     code: CloseCode::Normal,
-    //         //     reason: Cow::Borrowed("Bye bye"),
-    //         // };
-    //         // let message = Message::Close(Some(close_frame));
-    //
-    //
-    //         let message = Message::Text(su.clone());
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), message.clone()).await;
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    let fun = move |data: ResponseData| {
-        // 在 async 块之前克隆 Arc
-        // let core_arc_cc = core_arc_clone.clone();
-        // let mul = multiplier.clone();
-        //
-        // let depth_asks = Arc::clone(&depth_asks);
-        // let depth_bids = Arc::clone(&depth_bids);
-
-        async move {
-            trace!("333333333333333：ResponseData:{:?}",data);
-            // let mut depth_asks = depth_asks.lock().await;
-            // let mut depth_bids = depth_bids.lock().await;
-            // 使用克隆后的 Arc，避免 move 语义
-            // on_public_data(core_arc_cc, &mul, &data, &mut depth_asks, &mut depth_bids).await
-        }
-    };
-
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        // ws.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        ws.ws_connect_async(bool_v3_clone,fun, &write_tx_am, write_rx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-
-//rest-服務器時間
-#[tokio::test]
-async fn rest_get_server_time_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_server_time().await;
-    println!("Bybit--服務器時間--{:?}", req_data);
-}
-
-//rest-查詢最新行情信息
-#[tokio::test]
-async fn rest_get_tickers_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_tickers("DOGEUSDT".to_string()).await;
-    println!("Bybit--查詢最新行情信息--{:?}", req_data);
-}
-
-//rest-查詢市場價格K線數據
-#[tokio::test]
-async fn rest_get_kline_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_record("DOGEUSDT".to_string(), "1".to_string(), "5".to_string()).await;
-    println!("Bybit--查詢市場價格K線數據--{:?}", req_data);
-}
-
-
-//rest-查詢公告
-#[tokio::test]
-async fn rest_get_announcements_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_announcements().await;
-    println!("Bybit--查詢公告--{:?}", req_data);
-}
-
-//rest-查詢可交易產品的規格信息
-#[tokio::test]
-async fn rest_get_instruments_info_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_instruments_info("BTCUSDT".to_string()).await;
-    println!("Bybit--查詢可交易產品的規格信息--{:?}", req_data);
-}
-
-
-//rest-查詢錢包餘額
-#[tokio::test]
-async fn rest_get_account_balance_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_account_balance("USDT".to_string()).await;
-    println!("Bybit--查詢錢包餘額--{:?}", req_data);
-}
-
-//rest-查看持仓信息
-#[tokio::test]
-async fn rest_get_positions_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_positions("DOGEUSDT".to_string(), "".to_string()).await;
-    println!("Bybit--查看持仓信息--{:?}", req_data);
-}
-
-//rest-设置持仓模式
-#[tokio::test]
-async fn rest_set_position_mode_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.set_position_mode("DOGEUSDT".to_string(), 3).await;
-    println!("Bybit--设置持仓模式--{:?}", req_data);
-}
-
-//rest-設置槓桿
-#[tokio::test]
-async fn rest_set_leverage_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.set_leverage(
-        "DOGEUSDT".to_string(), "1".to_string()).await;
-    println!("Bybit--設置槓桿--{:?}", req_data);
-}
-
-
-//rest-創建委託單
-#[tokio::test]
-async fn rest_swap_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let params = serde_json::json!({
-            "category":"linear",
-            "symbol":"DOGEUSDT",
-            "orderType":"Limit",
-            "side":"Buy",
-            "qty":"1",
-            "price":"0.085",
-         });
-    let req_data = ret.swap_order(params).await;
-    println!("Bybit--創建委託單--{:?}", req_data);
-}
-
-
-//rest-查詢實時委託單
-#[tokio::test]
-async fn rest_get_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_order("LINKUSDT".to_string(),
-                                 "".to_string(), "".to_string()).await;
-    println!("Bybit--查詢實時委託單--{:?}", req_data);
-}
-
-
-//rest-撤单
-#[tokio::test]
-async fn rest_cancel_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.cancel_order("DOGEUSDT".to_string(),
-                                    "1d3ea16f-cf1c-4dab-9a79-d441a2dea549".to_string(), "".to_string()).await;
-    println!("Bybit--撤单--{:?}", req_data);
-}
-
-//rest-撤銷所有訂單
-#[tokio::test]
-async fn rest_cancel_orders_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.cancel_orders("DOGEUSDT".to_string()).await;
-    println!("Bybit--撤銷所有訂單--{:?}", req_data);
-}
-
-
- fn get_ws(btree_map: Option<BybitSwapLogin>, type_v: BybitSwapWsType) -> BybitSwapWs {
-    let ku_ws = BybitSwapWs::new(false, btree_map, type_v);
-    ku_ws
-}
-
-fn get_rest() -> BybitSwapRest {
-    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-    btree_map.insert("access_key".to_string(), ACCESS_KEY.to_string());
-    btree_map.insert("secret_key".to_string(), SECRET_KEY.to_string());
-
-    let bybit_exc = BybitSwapRest::new(false, btree_map.clone());
-    bybit_exc
-}

exchanges/tests/coinex_swap_test.rs

@@ -1,383 +0,0 @@
-use std::collections::BTreeMap;
-use std::str::FromStr;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-use rust_decimal::Decimal;
-use serde_json::Value;
-use tokio::sync::Mutex;
-use tracing::{error, info, trace};
-use exchanges::coinex_swap_rest::CoinexSwapRest;
-use exchanges::coinex_swap_ws::{CoinexSwapLogin, CoinexSwapSubscribeType, CoinexSwapWs};
-use exchanges::response_base::ResponseData;
-use global::log_utils::{init_log_with_info, init_log_with_trace};
-
-
-const ACCESS_KEY: &str = "";
-const SECRET_KEY: &str = "";
-
-
-//ws-订阅公共频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn ws_custom_subscribe() {
-    global::log_utils::init_log_with_trace();
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (_read_tx, mut read_rx) = futures_channel::mpsc::unbounded::<ResponseData>();
-
-    // let (write_tx, write_rx) = tokio::sync::broadcast::channel::<Message>(10);
-    // let (read_tx, mut read_rx) = tokio::sync::broadcast::channel::<ResponseData>(10);
-
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            // 从通道中接收并丢弃所有的消息，直到通道为空
-            while let Ok(Some(_data)) = read_rx.try_next() {
-
-                // 从通道中接收并丢弃所有的消息，直到通道为空
-                while let Ok(Some(_)) = read_rx.try_next() {
-                    // 消息被忽略
-                }
-            }
-        }
-        // trace!("线程-数据读取-结束");
-    });
-
-    //写数据
-    // let bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    // let write_tx_clone = Arc::clone(&write_tx_am);
-    // let su = ws.get_subscription();
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20 * 1000)).await;
-    //         // let close_frame = CloseFrame {
-    //         //     code: CloseCode::Normal,
-    //         //     reason: Cow::Borrowed("Bye bye"),
-    //         // };
-    //         // let message = Message::Close(Some(close_frame));
-    //
-    //
-    //         let message = Message::Text(su.clone());
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), message.clone()).await;
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    let fun = move |data: ResponseData| {
-        async move {
-            println!("{:?}", data);
-        }
-    };
-    let param = CoinexSwapLogin {
-        api_key: ACCESS_KEY.to_string(),
-        secret: SECRET_KEY.to_string(),
-    };
-    let t1 = tokio::spawn(async move {
-        let mut ws = get_ws(Option::from(param));
-        ws.set_symbols(vec!["FTM_USDT".to_string()]);
-        ws.set_subscribe(vec![
-            // CoinexSwapSubscribeType::PuFuturesDepth,
-            CoinexSwapSubscribeType::PrFuturesOrders
-        ]);
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, fun, &write_tx_am, write_rx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-fn get_ws(btree_map: Option<CoinexSwapLogin>) -> CoinexSwapWs {
-    let coinex_ws = CoinexSwapWs::new(btree_map);
-    coinex_ws
-}
-
-#[tokio::test]
-async fn rest_account_book_test() {
-    let mut ret = get_rest();
-    let req_data = ret.get_account().await;
-    let res_data_json: Value = req_data.data;
-    println!("coinex--查询合约账户--{:?}", res_data_json);
-    let result = res_data_json.as_array().unwrap().get(0).unwrap();
-    println!("coinex--查询合约账户--{:?}", result["ccy"]);
-}
-
-#[tokio::test]
-async fn rest_spot_account_book_test() {
-    let mut ret = get_rest();
-    let req_data = ret.get_spot_account().await;
-    let res_data_json: Value = req_data.data;
-    println!("coinex--查询现货账户--{:?}", res_data_json);
-    let result = res_data_json.as_array().unwrap().get(0).unwrap();
-    println!("coinex--查询现货账户--{:?}", result["ccy"]);
-}
-
-#[tokio::test]
-async fn rest_position_test() {
-    let mut ret = get_rest();
-    let req_data = ret.get_position("BOMEUSDT".to_string()).await;
-    println!("coinex--查询仓位--{:?}", req_data);
-}
-
-#[tokio::test]
-async fn rest_positions_test() {
-    let mut ret = get_rest();
-    let req_data = ret.get_user_position().await;
-    println!("coinex--查询用户所有仓位--{:?}", req_data);
-}
-
-#[tokio::test]
-async fn rest_ticker_test() {
-    let mut ret = get_rest();
-    let req_data = ret.get_ticker("BOMEUSDT".to_string()).await;
-    println!("coinex--查询ticker--{:?}", req_data);
-}
-
-#[tokio::test]
-async fn rest_market_test() {
-    let mut ret = get_rest();
-    let req_data = ret.get_market_details("BOMEUSDT".to_string()).await;
-    println!("coinex--查询market--{:?}", req_data);
-}
-
-#[tokio::test]
-async fn rest_market_list_test() {
-    let symbol = "DOGEUSDT".to_string();
-    let price = Decimal::from_str("0.15").unwrap();
-    let custom_id = "436265461";
-    let order_side;
-    let position_side;
-    let amount = Decimal::from_str("1769").unwrap();
-    let ct_val = Decimal::from_str("1").unwrap();
-    let origin_side = "kk";
-    let size = (amount / ct_val).floor();
-    match origin_side {
-        "kd" => {
-            position_side = "long";
-            order_side = "buy";
-        }
-        "pd" => {
-            position_side = "long";
-            order_side = "sell";
-        }
-        "kk" => {
-            position_side = "short";
-            order_side = "sell";
-        }
-        "pk" => {
-            position_side = "short";
-            order_side = "buy";
-        }
-        _ => {
-            error!("下单参数错误");
-            position_side = "error";
-            order_side = "error";
-        }
-    };
-    let mut ret = get_rest();
-    let req_data = ret.order(symbol, position_side.to_string(), order_side.to_string(), size, price, custom_id.to_string()).await;
-    println!("coinex--查询swap_order--{:?}", req_data);
-}
-
-#[tokio::test]
-async fn rest_cancel_order_test() {
-    let mut ret = get_rest();
-    let req_data = ret.cancel_order("DOGEUSDT".to_string(), "", "436265461").await;
-
-    println!("coinex--查询cancel_order--{} {:?}", req_data.data.is_null(), req_data);
-}
-
-#[tokio::test]
-async fn rest_cancel_all_order_test() {
-    let mut ret = get_rest();
-    let _ct_val = Decimal::ONE;
-    let orders_res_data = ret.get_pending_orders().await;
-    let mut result = vec![];
-    if orders_res_data.code == 200 {
-        let orders_res_data_json = orders_res_data.data.as_array().unwrap();
-        for order in orders_res_data_json {
-            let cancel_res_data = ret.cancel_order_all(order["market"].as_str().unwrap().to_string()).await;
-            if cancel_res_data.code == 200 {
-                result.push(order.clone())
-            }
-        }
-    }
-    println!("coinex--查询cancel_all_order--{:?}", result);
-}
-
-#[tokio::test]
-async fn rest_finish_order_list_test() {
-    let mut ret = get_rest();
-    let req_data = ret.get_finished_orders().await;
-    println!("coinex--查询finish_order--{:?}", req_data);
-}
-
-#[tokio::test]
-async fn rest_pending_order_list_test() {
-    let mut ret = get_rest();
-    let req_data = ret.get_pending_orders().await;
-    println!("coinex--查询pending_order--{:?}", req_data);
-}
-
-#[tokio::test]
-async fn rest_order_status_test() {
-    let mut ret = get_rest();
-    let req_data = ret.get_order_details("136925916412".to_string(), "DOGEUSDT".to_string()).await;
-    println!("coinex--查询pending_order--{:?}", req_data);
-}
-
-#[tokio::test]
-async fn rest_setting_dual_leverage_test() {
-    let mut ret = get_rest();
-    let req_data = ret.setting_dual_leverage("FTMUSDT".to_string(), 10).await;
-    println!("coinex--查询setting_dual_leverage--{:?}", req_data);
-}
-
-#[tokio::test]
-async fn rest_time() {
-    let mut ret = get_rest();
-    let res_data = ret.get_server_time().await;
-    let res_data_json: Value = res_data.data;
-    let result = res_data_json["timestamp"].to_string();
-    println!("coinex--time--{:?}", result);
-}
-
-#[tokio::test]
-async fn rest_account_get_test() {
-    let mut ret = get_rest();
-    let res_data = ret.account_get().await;
-    let res_data_json: Value = res_data.data;
-    if res_data_json.is_array() {
-        let array = res_data_json.as_array().unwrap();
-        for z in array {
-            trace!("coinex--查看子账号列表--{:?}", z);
-        }
-    }
-}
-
-#[tokio::test]
-async fn rest_account_subs_api_test() {
-    let mut ret = get_rest();
-    let params = serde_json::json!({
-            "sub_user_name":"2024050",
-            "ip_whitelist":[],
-            "trade_enabled":false,
-            "remark":"",
-        });
-    let res_data = ret.account_subs_api(params).await;
-    // let res_data_json: Value = res_data.data;
-    // let result = res_data_json["timestamp"].to_string();
-    println!("coinex--获取子账号的apikey--{:?}", res_data);
-}
-
-// 将主账号下的  子账号 都创建apikey
-#[tokio::test]
-async fn rest_account_get_and_api_test() {
-    let mut ret = get_rest();
-    let res_data = ret.account_get().await;
-    let res_data_json: Value = res_data.data;
-    if res_data_json.is_array() {
-        let array = res_data_json.as_array().unwrap();
-        for z in array {
-            let sub_user_name = z["sub_user_name"].as_str().unwrap();
-            info!("coinex--查看子账号列表--{:?}", z);
-
-
-            // //每个账号创建apiKey
-            // let params2 = serde_json::json!({
-            //     "sub_user_name":sub_user_name,
-            //     "ip_whitelist":[],
-            //     "trade_enabled":false,
-            //     "remark":"",
-            // });
-            // let res_data2 = ret.account_subs_api(params2).await;
-            // // info!("coinex--创建成功响应--{:?}", res_data2);
-            // let res_data_json2: Value = res_data2.data;
-            // let api_id = res_data_json2["api_id"].as_i64().unwrap();
-            // let access_id = res_data_json2["access_id"].as_str().unwrap();
-            // let secret_key = res_data_json2["secret_key"].as_str().unwrap();
-            // info!("sub_user_name:{:?} \tapi_id:{:?} \t access_id:{:?}\t secret_key:{:?}",sub_user_name,api_id,access_id,secret_key);
-
-        }
-    }
-}
-
-// 获取子账号 APIKEY 列表
-#[tokio::test]
-async fn rest_account_get_apikey_test() {
-    let str = "api_id access_id secret_key";
-    let mut ret = get_rest();
-    let res_data = ret.account_get().await;
-    let res_data_json: Value = res_data.data;
-    if res_data_json.is_array() {
-        let array = res_data_json.as_array().unwrap();
-        for z in array {
-            let sub_user_name = z["sub_user_name"].as_str().unwrap();
-            info!("coinex--查看子账号列表--{:?}", sub_user_name);
-
-            //每个账号创建apiKey
-            let params = serde_json::json!({
-                "sub_user_name":sub_user_name,
-            });
-            let res_data2 = ret.account_get_apikey(params).await;
-            // trace!("coinex--获取子账号的apikey--{:?}", res_data2);
-            let res_data_json2: Value = res_data2.data;
-            if res_data_json2.is_array() {
-                let array2 = res_data_json2.as_array().unwrap();
-                for z2 in array2 {
-                    let api_id = z2["api_id"].as_i64().unwrap();
-                    let access_id = z2["access_id"].as_str().unwrap();
-                    info!("sub_user_name:{:?} \tapi_id:{:?} \t access_id:{:?}\t ",sub_user_name,api_id,access_id);
-
-                    //查询详情
-                    let params3 = serde_json::json!({
-                       "api_id":api_id
-                    });
-                    let res_data3 = ret.account_get_detail(params3).await;
-                    info!("coinex--详情--{:?}", res_data3.data);
-
-                    //编辑子账号 APIKEY
-                    // let params4 = serde_json::json!({
-                    //     "sub_user_name":sub_user_name,
-                    //     "api_id":api_id,
-                    //     "trade_enabled":true
-                    // });
-                    // let res_data4 = ret.account_get_update(params4).await;
-                    // info!("coinex--编辑结果--{:?}", res_data4.data);
-
-
-                    //删除
-                    // let params2 = serde_json::json!({
-                    //     "api_id":api_id
-                    // });
-                    // let res_data23 = ret.account_del_apikey(params2).await;
-                    // info!("coinex--删除结果--{:?}", res_data23);
-                }
-            }
-        }
-    }
-    // info!("sub_user_name:{:?} \tapi_id:{:?} \t access_id:{:?}\t ",sub_user_name,api_id,access_id)
-}
-
-
-fn get_rest() -> CoinexSwapRest {
-    // init_log_with_trace();
-    init_log_with_info();
-    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-    btree_map.insert("access_key".to_string(), ACCESS_KEY.to_string());
-    btree_map.insert("secret_key".to_string(), SECRET_KEY.to_string());
-
-    let ba_exc = CoinexSwapRest::new(btree_map);
-    ba_exc
-}

exchanges/tests/crypto_spot_test.rs

@@ -1,86 +0,0 @@
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-
-use futures_util::StreamExt;
-use tokio::sync::Mutex;
-use tracing::trace;
-
-use exchanges::crypto_spot_ws::{CryptoSpotLogin, CryptoSpotSubscribeType, CryptoSpotWs, CryptoSpotWsType};
-
-const ACCESS_KEY: &str = "";
-const SECRET_KEY: &str = "";
-
-
-//ws-订阅公共频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 5)]
-async fn ws_pu() {
-    global::log_utils::init_log_with_trace();
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded();
-
-    let mut ws = get_ws(None, CryptoSpotWsType::Public);
-    ws.set_symbols(vec!["BTC_USD".to_string()]);
-    ws.set_subscribe(vec![
-        // CryptoSpotSubscribeType::PuBook,
-        // CryptoSpotSubscribeType::PuTicker,
-        // CryptoSpotSubscribeType::PuTrade,
-        CryptoSpotSubscribeType::PuCandlestick,
-    ]);
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-        // trace!("线程-数据读取-结束");
-    });
-
-    //写数据
-    // let bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    // let write_tx_clone = Arc::clone(&write_tx_am);
-    // let su = ws.get_subscription();
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20 * 1000)).await;
-    //         // let close_frame = CloseFrame {
-    //         //     code: CloseCode::Normal,
-    //         //     reason: Cow::Borrowed("Bye bye"),
-    //         // };
-    //         // let message = Message::Close(Some(close_frame));
-    //
-    //
-    //         let message = Message::Text(su.clone());
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), message.clone()).await;
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-fn get_ws(btree_map: Option<CryptoSpotLogin>, ws_type: CryptoSpotWsType) -> CryptoSpotWs {
-    let binance_ws = CryptoSpotWs::new(false,
-                                       btree_map,
-                                       ws_type);
-    binance_ws
-}

exchanges/tests/gate_swap_test.rs

@@ -1,181 +0,0 @@
-use std::collections::BTreeMap;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-
-use futures_util::StreamExt;
-use tokio::sync::Mutex;
-use tracing::trace;
-
-use exchanges::gate_swap_rest::GateSwapRest;
-use exchanges::gate_swap_ws::{GateSwapLogin, GateSwapSubscribeType, GateSwapWs, GateSwapWsType};
-
-const ACCESS_KEY: &str = "";
-const SECRET_KEY: &str = "";
-
-//ws-订阅公共频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn ws_custom_subscribe() {
-    global::log_utils::init_log_with_trace();
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded();
-
-    let param = GateSwapLogin {
-        api_key: ACCESS_KEY.to_string(),
-        secret: SECRET_KEY.to_string(),
-    };
-
-    let mut ws = get_ws(Option::from(param));
-    ws.set_symbols(vec!["BTC_USDT".to_string()]);
-    ws.set_subscribe(vec![
-        // GateSwapSubscribeType::PuFuturesOrderBook,
-        GateSwapSubscribeType::PuFuturesCandlesticks,
-        GateSwapSubscribeType::PuFuturesTrades,
-
-        // GateSwapSubscribeType::PrFuturesBalances("".to_string()),
-        // GateSwapSubscribeType::PrFuturesOrders("".to_string()),
-        // GateSwapSubscribeType::PrFuturesPositions("".to_string()),
-    ]);
-
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-        // trace!("线程-数据读取-结束");
-    });
-
-    //写数据
-    // let bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    // let write_tx_clone = Arc::clone(&write_tx_am);
-    // let su = ws.get_subscription();
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20 * 1000)).await;
-    //         // let close_frame = CloseFrame {
-    //         //     code: CloseCode::Normal,
-    //         //     reason: Cow::Borrowed("Bye bye"),
-    //         // };
-    //         // let message = Message::Close(Some(close_frame));
-    //
-    //
-    //         let message = Message::Text(su.clone());
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), message.clone()).await;
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-
-//rest-设置持仓模式
-#[tokio::test]
-async fn rest_cancel_order_all_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.cancel_order_all().await;
-    println!("okx--设置持仓模式--{:?}", req_data);
-}
-
-//rest-下一个自动单
-#[tokio::test]
-async fn price_order_test() {
-    global::log_utils::init_log_with_info();
-
-    let mut rest = get_rest();
-    let mut params = json!({});
-
-    params["initial"] = json!({
-        "contract": "XRP_USDT",
-        "price": "0",
-        "tif": "ioc",
-        "reduce_only": true,
-        // [平多：close_long, 平空：close_short]
-        "auto_size": "close_long"
-    });
-
-    params["trigger"] = json!({
-        // [平多：close-long-position, 平空：close-short-position]
-        "order_type": "close-long-position",
-        // 一般都默认用0
-        "strategy_type": 0,
-        // [0 - 最新成交价，1 - 标记价格，2 - 指数价格]
-        "price_type": 0,
-        // [1: 引用价格大于等于我们传的价格，2：引用价格小于等于我们传的价格]
-        // 在止损的情况下：
-        //     1 可以理解为向上突破触发价（一般是给空单用）
-        //     2 可以理解为向下突破触发价（一般是给多单用）
-        "rule": 2,
-        // 订单触发价格
-        "price": "0.5600",
-    });
-
-    let response_data = rest.place_price_order("usdt".to_string(), params).await;
-    if response_data.code == "200" {
-        let response_obj: serde_json::Value = serde_json::from_str(response_data.data.as_str()).unwrap();
-
-        info!("resp={:?}", response_obj.as_object().unwrap());
-    } else {
-        error!(?response_data);
-    }
-}
-
-#[tokio::test]
-async fn price_order_cancel_test() {
-    global::log_utils::init_log_with_info();
-
-    let mut rest = get_rest();
-
-    // 这边取消订单只能使用系统返回的
-    let rst = rest.cancel_price_order("usdt".to_string(), "58002898".to_string()).await;
-    info!(?rst);
-}
-
-//rest-查询合约账户变更历史
-#[tokio::test]
-async fn rest_account_book_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.account_book("usdt".to_string()).await;
-    println!("okx--查询合约账户变更历史--{:?}", req_data);
-}
-
-fn get_ws(btree_map: Option<GateSwapLogin>) -> GateSwapWs {
-    let binance_ws = GateSwapWs::new(false,
-                                     btree_map,
-                                     GateSwapWsType::PublicAndPrivate("usdt".to_string()));
-    binance_ws
-}
-
-
-fn get_rest() -> GateSwapRest {
-    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-    btree_map.insert("access_key".to_string(), ACCESS_KEY.to_string());
-    btree_map.insert("secret_key".to_string(), SECRET_KEY.to_string());
-
-    let ba_exc = GateSwapRest::new(false, btree_map);
-    ba_exc
-}

exchanges/tests/htx_swap_test.rs

@@ -1,314 +0,0 @@
-use std::collections::BTreeMap;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-
-use serde_json::json;
-use tokio::sync::Mutex;
-use tracing::trace;
-
-use exchanges::htx_swap_rest::HtxSwapRest;
-use exchanges::htx_swap_ws::{HtxSwapLogin, HtxSwapSubscribeType, HtxSwapWs, HtxSwapWsType};
-use exchanges::proxy;
-use exchanges::response_base::ResponseData;
-
-const ACCESS_KEY: &str = "";
-const SECRET_KEY: &str = "";
-
-
-//ws-订阅公共频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn ws_custom_subscribe() {
-    global::log_utils::init_log_with_trace();
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (_, mut read_rx) = futures_channel::mpsc::unbounded::<ResponseData>();
-
-    // let (write_tx, write_rx) = tokio::sync::broadcast::channel::<Message>(10);
-    // let (read_tx, mut read_rx) = tokio::sync::broadcast::channel::<ResponseData>(10);
-
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            // 从通道中接收并丢弃所有的消息，直到通道为空
-            while let Ok(Some(_)) = read_rx.try_next() {
-
-                // 从通道中接收并丢弃所有的消息，直到通道为空
-                while let Ok(Some(_)) = read_rx.try_next() {
-                    // 消息被忽略
-                }
-            }
-        }
-        // trace!("线程-数据读取-结束");
-    });
-
-    //写数据
-    // let bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    // let write_tx_clone = Arc::clone(&write_tx_am);
-    // let su = ws.get_subscription();
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20 * 1000)).await;
-    //         // let close_frame = CloseFrame {
-    //         //     code: CloseCode::Normal,
-    //         //     reason: Cow::Borrowed("Bye bye"),
-    //         // };
-    //         // let message = Message::Close(Some(close_frame));
-    //
-    //
-    //         let message = Message::Text(su.clone());
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), message.clone()).await;
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    let fun = move |data: ResponseData| {
-        async move {
-            trace!("---传入的方法~~~~{:?}", data);
-        }
-    };
-    let param = HtxSwapLogin {
-        api_key: ACCESS_KEY.to_string(),
-        secret: SECRET_KEY.to_string(),
-    };
-    let t1 = tokio::spawn(async move {
-        let mut ws = get_ws(Option::from(param), HtxSwapWsType::Public);
-        ws.set_symbols(vec!["BTC_USDT".to_string(),"ETC_USDT".to_string()]);
-        ws.set_subscribe(vec![
-            HtxSwapSubscribeType::PuFuturesDepth,
-            // HtxSwapSubscribeType::PrFuturesOrders
-
-            // HtxSwapSubscribeType::PrFuturesOrders,
-            // HtxSwapSubscribeType::PrFuturesPositions,
-            // HtxSwapSubscribeType::PrFuturesBalances,
-        ]);
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, fun, &write_tx_am, write_rx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-fn get_ws(btree_map: Option<HtxSwapLogin>, ws_type: HtxSwapWsType) -> HtxSwapWs {
-    let htx_ws = HtxSwapWs::new(btree_map, ws_type);
-    htx_ws
-}
-
-
-/*服务器时间戳*/
-#[tokio::test]
-async fn rest_get_server_time_test() {
-    global::log_utils::init_log_with_trace();
-    proxy_handle();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_server_time().await;
-    trace!("htx--服务器时间戳--{:?}", req_data);
-    trace!("htx--服务器时间戳--{}", req_data.data);
-}
-
-
-/*获取聚合行情*/
-#[tokio::test]
-async fn rest_get_ticker_test() {
-    global::log_utils::init_log_with_trace();
-    proxy_handle();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_ticker(json!({
-            "contract_type":"swap"
-         })
-    ).await;
-    trace!("htx--获取聚合行情--{:?}", req_data);
-    trace!("htx--获取聚合行情--{}", req_data.data);
-}
-
-
-
-/*合约信息*/
-#[tokio::test]
-async fn rest_get_market_test() {
-    global::log_utils::init_log_with_trace();
-    proxy_handle();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_market(json!({
-            "contract_code":"BTC-USDT"
-         })
-    ).await;
-    trace!("htx--合约信息--{:?}", req_data);
-    trace!("htx--合约信息--{}", req_data.data);
-}
-
-
-/*查询合约账户*/
-#[tokio::test]
-async fn rest_get_account_test() {
-    global::log_utils::init_log_with_trace();
-    // proxy_handle();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_account(json!({
-            "valuation_asset":"USDT"
-         })
-    ).await;
-    trace!("htx--查询合约账户--{:?}", req_data);
-    trace!("htx--查询合约账户--{}", req_data.data);
-}
-
-/*用户仓位列表*/
-#[tokio::test]
-async fn rest_get_user_position_test() {
-    global::log_utils::init_log_with_trace();
-    // proxy_handle();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_user_position(
-   serde_json::json!({
-            "contract_type":"swap"
-         })
-    ).await;
-    trace!("htx--用户仓位列表--{:?}", req_data);
-    trace!("htx--用户仓位列表--{}", req_data.data);
-}
-
-/*查询合约订单列表*/
-#[tokio::test]
-async fn rest_get_orders_test() {
-    global::log_utils::init_log_with_trace();
-    // proxy_handle();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_orders(json!({
-    })).await;
-    trace!("htx--查询合约订单列表--{:?}", req_data);
-    trace!("htx--查询合约订单列表--{}", req_data.data);
-}
-
-/*查询单个订单详情*/
-#[tokio::test]
-async fn rest_get_order_details_test() {
-    global::log_utils::init_log_with_trace();
-    // proxy_handle();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_order_details(json!({
-        "order_id":"123"
-    })).await;
-    trace!("htx--查询单个订单详情--{:?}", req_data);
-    trace!("htx--查询单个订单详情--{}", req_data.data);
-}
-/*合约交易下单*/
-#[tokio::test]
-async fn rest_swap_order_test() {
-    global::log_utils::init_log_with_trace();
-    // proxy_handle();
-
-    let mut ret = get_rest();
-
-    let req_data = ret.swap_order(json!({
-        "pair":"SHIB-USDT",
-        "contract_type":"swap",
-        "order_price_type":"limit",
-        "offset":"open",
-        "direction":"buy",
-        "price":"0.000001359",
-        "volume":1,
-        "lever_rate":1,
-
-    })).await;
-    trace!("htx--合约交易下单--{:?}", req_data);
-    trace!("htx--合约交易下单--{}", req_data.data);
-}
-
-/*全部撤单*/
-#[tokio::test]
-async fn rest_cancel_price_order_test() {
-    global::log_utils::init_log_with_trace();
-    // proxy_handle();
-
-    let mut ret = get_rest();
-
-    let req_data = ret.cancel_price_order(json!({  })).await;
-    trace!("htx--全部撤单--{:?}", req_data);
-    trace!("htx--全部撤单--{}", req_data.data);
-}
-
-/*撤单*/
-#[tokio::test]
-async fn rest_cancel_order_test() {
-    global::log_utils::init_log_with_trace();
-    // proxy_handle();
-
-    let mut ret = get_rest();
-
-    let req_data = ret.cancel_order(json!({
-        "order_id":"123"
-    })).await;
-    trace!("htx--撤单--{:?}", req_data);
-    trace!("htx--撤单--{}", req_data.data);
-}
-
-
-/*设置持仓模式*/
-#[tokio::test]
-async fn rest_setting_dual_mode_test() {
-    global::log_utils::init_log_with_trace();
-    // proxy_handle();
-
-    let mut ret = get_rest();
-
-    let req_data = ret.setting_dual_mode(json!({
-        "margin_account":"USDT",
-        "position_mode":"dual_side",
-    })).await;
-    trace!("htx--设置持仓模式--{:?}", req_data);
-    trace!("htx--设置持仓模式--{}", req_data.data);
-}
-
-
-/*设置杠杆*/
-#[tokio::test]
-async fn rest_setting_dual_leverage_test() {
-    global::log_utils::init_log_with_trace();
-    // proxy_handle();
-
-    let mut ret = get_rest();
-
-    let req_data = ret.setting_dual_leverage(json!({
-        "pair":"BTC-USDT",
-        "contract_type":"swap",
-        "lever_rate":1,
-    })).await;
-    trace!("htx--设置持仓模式--{:?}", req_data);
-    trace!("htx--设置持仓模式--{}", req_data.data);
-}
-
-
-fn get_rest() -> HtxSwapRest {
-    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-    btree_map.insert("access_key".to_string(), ACCESS_KEY.to_string());
-    btree_map.insert("secret_key".to_string(), SECRET_KEY.to_string());
-
-    let htx_exc = HtxSwapRest::new(false, btree_map);
-    htx_exc
-}
-
-// 检测是否走代理
-pub fn proxy_handle() {
-    if proxy::ParsingDetail::http_enable_proxy() {
-        trace!("检测有代理配置，配置走代理");
-    }
-}

exchanges/tests/kucoin_spot_test.rs

@@ -1,264 +0,0 @@
-use std::collections::BTreeMap;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-
-use futures_util::StreamExt;
-use tokio::sync::Mutex;
-use tracing::trace;
-
-use exchanges::kucoin_spot_rest::KucoinSpotRest;
-use exchanges::kucoin_spot_ws::{KucoinSpotLogin, KucoinSpotSubscribeType, KucoinSpotWs, KucoinSpotWsType};
-
-const ACCESS_KEY: &str = "";
-const SECRET_KEY: &str = "";
-const PASS_KEY: &str = "";
-
-//ws-订阅公共频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 5)]
-async fn ws_custom_subscribe_pu() {
-    global::log_utils::init_log_with_trace();
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded();
-
-
-    let mut ws = get_ws(None, KucoinSpotWsType::Public).await;
-    ws.set_symbols(vec!["BTC-USDT".to_string()]);
-    ws.set_subscribe(vec![
-        KucoinSpotSubscribeType::PuSpotMarketLevel2Depth50,
-        KucoinSpotSubscribeType::PuMarketTicker,
-        KucoinSpotSubscribeType::PuMarketMatch,
-    ]);
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-    });
-
-    //写数据
-    let _bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    let _write_tx_clone = Arc::clone(&write_tx_am);
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20*1000)).await;
-    //         let close_frame = CloseFrame {
-    //             code: CloseCode::Normal,
-    //             reason: Cow::Borrowed("Bye bye"),
-    //         };
-    //         let close_message = Message::Close(Some(close_frame));
-    //         // AbstractWsMode::send_subscribe(write_tx_clone.clone(), Message::Text("32313221".to_string()));
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), close_message);
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    // loop {
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    // }
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-//ws-订阅私有频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn ws_custom_subscribe_pr() {
-    global::log_utils::init_log_with_trace();
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded();
-
-    let btree_map = KucoinSpotLogin {
-        access_key: ACCESS_KEY.to_string(),
-        secret_key: SECRET_KEY.to_string(),
-        pass_key: PASS_KEY.to_string(),
-    };
-    let mut ws = get_ws(Option::from(btree_map), KucoinSpotWsType::Public).await;
-    ws.set_symbols(vec!["BTC-USDT".to_string()]);
-    ws.set_subscribe(vec![
-        KucoinSpotSubscribeType::PrAccountBalance,
-        KucoinSpotSubscribeType::PrSpotMarketTradeOrders,
-    ]);
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-    });
-
-    //写数据
-    let _bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    let _write_tx_clone = Arc::clone(&write_tx_am);
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20*1000)).await;
-    //         let close_frame = CloseFrame {
-    //             code: CloseCode::Normal,
-    //             reason: Cow::Borrowed("Bye bye"),
-    //         };
-    //         let close_message = Message::Close(Some(close_frame));
-    //         // AbstractWsMode::send_subscribe(write_tx_clone.clone(), Message::Text("32313221".to_string()));
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), close_message);
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    // loop {
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    // }
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-
-//rest-获取成交记录
-#[tokio::test]
-async fn rest_get_fills_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_fills("BTC-USDT".to_string(),
-                                  "".to_string(),
-                                  "".to_string(),
-                                  -1,
-                                  -1,
-                                  500,
-    ).await;
-    trace!(?rep_data)
-}
-
-
-//rest-获取订单
-#[tokio::test]
-async fn rest_get_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_order().await;
-    trace!(?rep_data)
-}
-
-//rest-獲取行情
-#[tokio::test]
-async fn rest_get_level1_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_level1("BTC-USDT".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-通過orderId获取訂單詳情
-#[tokio::test]
-async fn rest_get_order_by_order_id_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_order_by_order_id("3123123".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-通過clientOid獲取訂單詳情
-#[tokio::test]
-async fn rest_get_order_by_client_id_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_order_by_client_id("3123123".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-獲取賬戶列表 - 現貨/槓桿/現貨高頻
-#[tokio::test]
-async fn rest_get_accounts_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_accounts("USDT".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-獲取交易對列表
-#[tokio::test]
-async fn rest_get_symbols_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.get_symbols().await;
-    trace!(?rep_data)
-}
-
-//rest-通過orderId撤單- 没权限需要查看
-#[tokio::test]
-async fn rest_cancel_order_by_order_id_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.cancel_order_by_order_id("dddd123131".to_string()).await;
-    trace!(?rep_data)
-}
-
-//rest-通過clientOid撤單- 没权限需要查看
-#[tokio::test]
-async fn rest_cancel_order_by_client_id_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut rest = get_rest();
-    let rep_data = rest.cancel_order_by_client_id("dddd123131".to_string()).await;
-    trace!(?rep_data)
-}
-
-
-async fn get_ws(btree_map: Option<KucoinSpotLogin>, type_v: KucoinSpotWsType) -> KucoinSpotWs {
-    let ku_ws = KucoinSpotWs::new(false, btree_map,
-                                  type_v).await;
-    ku_ws
-}
-
-fn get_rest() -> KucoinSpotRest {
-    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-    // btree_map.insert("access_key".to_string(), ACCESS_KEY.to_string());
-    // btree_map.insert("secret_key".to_string(), SECRET_KEY.to_string());
-    btree_map.insert("access_key".to_string(), ACCESS_KEY.to_string());
-    btree_map.insert("secret_key".to_string(), SECRET_KEY.to_string());
-    btree_map.insert("pass_key".to_string(), PASS_KEY.to_string());
-
-    let ku_exc = KucoinSpotRest::new(false, btree_map);
-    ku_exc
-}

exchanges/tests/kucoin_swap_test.rs

@@ -1,168 +0,0 @@
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-
-use futures_util::StreamExt;
-use tokio::sync::Mutex;
-use tracing::trace;
-
-use exchanges::kucoin_swap_ws::{KucoinSwapLogin, KucoinSwapSubscribeType, KucoinSwapWs, KucoinSwapWsType};
-
-const ACCESS_KEY: &str = "";
-const SECRET_KEY: &str = "";
-const PASS_KEY: &str = "";
-
-//ws-订阅公共频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 5)]
-async fn ws_custom_subscribe_pu() {
-    global::log_utils::init_log_with_trace();
-
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded();
-
-
-
-    let mut ws = get_ws(None, KucoinSwapWsType::Public).await;
-    ws.set_symbols(vec!["xbt_usdtM".to_string()]);
-    ws.set_subscribe(vec![
-        KucoinSwapSubscribeType::PuContractMarketLevel2Depth50,
-        KucoinSwapSubscribeType::PuContractMarketExecution,
-        KucoinSwapSubscribeType::PuContractMarkettickerV2,
-    ]);
-
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-    });
-
-    //写数据
-    let _bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    let _write_tx_clone = Arc::clone(&write_tx_am);
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20*1000)).await;
-    //         let close_frame = CloseFrame {
-    //             code: CloseCode::Normal,
-    //             reason: Cow::Borrowed("Bye bye"),
-    //         };
-    //         let close_message = Message::Close(Some(close_frame));
-    //         // AbstractWsMode::send_subscribe(write_tx_clone.clone(), Message::Text("32313221".to_string()));
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), close_message);
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    // loop {
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    // }
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-//ws-订阅私有频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 5)]
-async fn ws_custom_subscribe_pr() {
-    global::log_utils::init_log_with_trace();
-
-
-    //对象
-    let btree_map = KucoinSwapLogin {
-        access_key: ACCESS_KEY.to_string(),
-        secret_key: SECRET_KEY.to_string(),
-        pass_key: PASS_KEY.to_string(),
-    };
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded();
-
-    // let (write_tx, write_rx) = tokio::sync::broadcast::channel::<Message>(10);
-    // let (read_tx, mut read_rx) = tokio::sync::broadcast::channel::<ResponseData>(10);
-
-
-    let mut ws = get_ws(Option::from(btree_map), KucoinSwapWsType::Private).await;
-    ws.set_symbols(vec!["xbt_usdtM".to_string()]);
-    ws.set_subscribe(vec![
-        // KucoinSwapSubscribeType::PuContractMarketLevel2Depth50,
-        // KucoinSwapSubscribeType::PuContractMarketExecution,
-        KucoinSwapSubscribeType::PuContractMarkettickerV2,
-        KucoinSwapSubscribeType::PrContractAccountWallet,
-        KucoinSwapSubscribeType::PrContractPosition,
-        KucoinSwapSubscribeType::PrContractMarketTradeOrdersSys,
-        KucoinSwapSubscribeType::PrContractMarketTradeOrders,
-    ]);
-
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-    });
-
-    //写数据
-    let _bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    let _write_tx_clone = Arc::clone(&write_tx_am);
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20*1000)).await;
-    //         let close_frame = CloseFrame {
-    //             code: CloseCode::Normal,
-    //             reason: Cow::Borrowed("Bye bye"),
-    //         };
-    //         let close_message = Message::Close(Some(close_frame));
-    //         // AbstractWsMode::send_subscribe(write_tx_clone.clone(), Message::Text("32313221".to_string()));
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), close_message);
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    // loop {
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    // }
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-
-async fn get_ws(btree_map: Option<KucoinSwapLogin>, type_v: KucoinSwapWsType) -> KucoinSwapWs {
-    let ku_ws = KucoinSwapWs::new(false, btree_map,
-                                  type_v).await;
-    ku_ws
-}

exchanges/tests/okx_swap_test.rs

@@ -1,411 +0,0 @@
-use std::collections::BTreeMap;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-
-use futures_util::StreamExt;
-use tokio::sync::Mutex;
-use tracing::trace;
-
-use exchanges::okx_swap_rest::OkxSwapRest;
-use exchanges::okx_swap_ws::{OkxSwapLogin, OkxSwapSubscribeType, OkxSwapWs, OkxSwapWsType};
-
-const ACCESS_KEY: &str = "";
-const SECRET_KEY: &str = "";
-const PASS_KEY: &str = "";
-
-
-//ws-订阅公共频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 5)]
-async fn ws_custom_subscribe_pu() {
-    global::log_utils::init_log_with_trace();
-
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded();
-
-
-    let mut ws = get_ws(None, OkxSwapWsType::Public).await;
-    ws.set_symbols(vec!["BTC_USDT".to_string()]);
-    ws.set_subscribe(vec![
-        // OkxSwapSubscribeType::PuBooks5,
-        // OkxSwapSubscribeType::Putrades,
-        OkxSwapSubscribeType::PuBooks50L2tbt,
-        // OkxSwapSubscribeType::PuIndexTickers,
-    ]);
-
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-        // trace!("线程-数据读取-结束");
-    });
-
-    //写数据
-    // let bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    // let write_tx_clone = Arc::clone(&write_tx_am);
-    // let su = ws.get_subscription();
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20 * 1000)).await;
-    //         // let close_frame = CloseFrame {
-    //         //     code: CloseCode::Normal,
-    //         //     reason: Cow::Borrowed("Bye bye"),
-    //         // };
-    //         // let message = Message::Close(Some(close_frame));
-    //
-    //
-    //         let message = Message::Text(su.clone());
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), message.clone()).await;
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-//ws-订阅私有频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn ws_custom_subscribe_bu() {
-    global::log_utils::init_log_with_trace();
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded();
-
-    let mut ws = get_ws(None, OkxSwapWsType::Business).await;
-    ws.set_symbols(vec!["BTC-USD".to_string()]);
-    ws.set_subscribe(vec![
-        OkxSwapSubscribeType::BuIndexCandle30m,
-    ]);
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-        // trace!("线程-数据读取-结束");
-    });
-
-    //写数据
-    // let bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    // let write_tx_clone = Arc::clone(&write_tx_am);
-    // let su = ws.get_subscription();
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20 * 1000)).await;
-    //         // let close_frame = CloseFrame {
-    //         //     code: CloseCode::Normal,
-    //         //     reason: Cow::Borrowed("Bye bye"),
-    //         // };
-    //         // let message = Message::Close(Some(close_frame));
-    //
-    //
-    //         let message = Message::Text(su.clone());
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), message.clone()).await;
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-}
-
-//ws-订阅私有频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 5)]
-async fn ws_custom_subscribe_pr() {
-    global::log_utils::init_log_with_trace();
-
-    let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded();
-
-    let btree_map = OkxSwapLogin {
-        api_key: ACCESS_KEY.to_string(),
-        secret_key: SECRET_KEY.to_string(),
-        passphrase: PASS_KEY.to_string(),
-    };
-    let mut ws = get_ws(Option::from(btree_map), OkxSwapWsType::Private).await;
-    ws.set_symbols(vec!["BTC-USDT".to_string()]);
-    ws.set_subscribe(vec![
-        OkxSwapSubscribeType::PrAccount("USDT".to_string()),
-        OkxSwapSubscribeType::PrOrders,
-        OkxSwapSubscribeType::PrPositions,
-        OkxSwapSubscribeType::PrBalanceAndPosition,
-    ]);
-
-
-    let write_tx_am = Arc::new(Mutex::new(write_tx));
-    let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-    //读取
-    let _is_shutdown_arc_clone = Arc::clone(&is_shutdown_arc);
-    let _tr = tokio::spawn(async move {
-        trace!("线程-数据读取-开启");
-        loop {
-            if let Some(data) = read_rx.next().await {
-                trace!("读取数据data:{:?}",data)
-            }
-        }
-        // trace!("线程-数据读取-结束");
-    });
-
-    //写数据
-    // let bool_v2_clone = Arc::clone(&is_shutdown_arc);
-    // let write_tx_clone = Arc::clone(&write_tx_am);
-    // let su = ws.get_subscription();
-    // let tw = tokio::spawn(async move {
-    //     trace!("线程-数据写入-开始");
-    //     loop {
-    //         tokio::time::sleep(Duration::from_millis(20 * 1000)).await;
-    //         // let close_frame = CloseFrame {
-    //         //     code: CloseCode::Normal,
-    //         //     reason: Cow::Borrowed("Bye bye"),
-    //         // };
-    //         // let message = Message::Close(Some(close_frame));
-    //
-    //
-    //         let message = Message::Text(su.clone());
-    //         AbstractWsMode::send_subscribe(write_tx_clone.clone(), message.clone()).await;
-    //         trace!("发送指令成功");
-    //     }
-    //     trace!("线程-数据写入-结束");
-    // });
-
-    let t1 = tokio::spawn(async move {
-        //链接
-        let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        ws.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        trace!("test 唯一线程结束--");
-    });
-    tokio::try_join!(t1).unwrap();
-    trace!("当此结束");
-    trace!("重启！");
-    trace!("参考交易所关闭");
-    return;
-    //
-    // let mut is_shutdown_arc = Arc::new(AtomicBool::new(true));
-    // let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-    //
-    // btree_map.insert("access_key".to_string(), ACCESS_KEY.to_string());
-    // btree_map.insert("secret_key".to_string(), SECRET_KEY.to_string());
-    // btree_map.insert("pass_key".to_string(), PASS_KEY.to_string());
-    //
-    // let (tx, mut rx) = channel(1024);
-    // let mut ws = get_ws(btree_map, OkxWsType::Private, tx).await;
-    // ws.set_subscribe(vec![
-    //     OkxSubscribeType::PrBalanceAndPosition,
-    //     // OkxSubscribeType::PrAccount("USDT".to_string()),
-    //     OkxSubscribeType::PrOrders,
-    //     OkxSubscribeType::PrPositions,
-    // ]);
-    //
-    // let t1 = tokio::spawn(async move {
-    //     ws.custom_subscribe(is_shutdown_arc, vec!["BTC-USDT".to_string()]).await;
-    // });
-    //
-    // let t2 = tokio::spawn(async move {
-    //     loop {
-    //         if let Ok(received) = rx.try_recv() {
-    //             trace!( "age: {:?}", received);
-    //         }
-    //     }
-    // });
-    // try_join!(t1,t2).unwrap();
-}
-
-
-//rest-订单查询
-#[tokio::test]
-async fn rest_get_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_order("BTC-USDT".to_string(), "3333".to_string(), "".to_string()).await;
-    println!("okx--订单查询--{:?}", req_data);
-}
-
-
-//rest-未完成的订单
-#[tokio::test]
-async fn rest_get_incomplete_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_incomplete_order("BTC-USDT".to_string()).await;
-    println!("okx--未完成的订单--{:?}", req_data);
-}
-
-//rest-获取系统时间
-#[tokio::test]
-async fn rest_get_server_time_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_server_time().await;
-    println!("okx--获取系统时间--{:?}", req_data);
-}
-
-//rest-查看持仓信息
-#[tokio::test]
-async fn rest_get_positions_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_positions("SWA1P".to_string()).await;
-    println!("okx--查看持仓信息--{:?}", req_data);
-}
-
-//rest-获取单个产品行情信息
-#[tokio::test]
-async fn rest_get_ticker_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_ticker("BTC-USDT".to_string()).await;
-    println!("okx--获取单个产品行情信息--{:?}", req_data);
-}
-
-//rest-查看账户余额
-#[tokio::test]
-async fn rest_get_balance_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_balance("BTC,ETH".to_string()).await;
-    println!("okx--查看账户余额--{:?}", req_data);
-}
-
-//rest-获取交易产品基础信息
-#[tokio::test]
-async fn rest_get_instruments_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_instruments().await;
-    println!("okx--获取交易产品基础信息--{:?}", req_data);
-}
-
-//rest-获取成交明细（近三天）
-#[tokio::test]
-async fn rest_get_trade_fills_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_trade_fills("".to_string()).await;
-    println!("okx--获取成交明细（近三天）--{:?}", req_data);
-}
-
-//rest-撤单
-#[tokio::test]
-async fn rest_cancel_order_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.cancel_order("BTC-USD".to_string(), "1111".to_string(), "".to_string()).await;
-    println!("okx--撤单--{:?}", req_data);
-}
-
-//rest-设置杠杆倍数
-#[tokio::test]
-async fn rest_set_leverage_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.set_leverage("BTC-USDT".to_string(), "5".to_string()).await;
-    println!("okx--设置杠杆倍数--{:?}", req_data);
-}
-
-//rest-设置持仓模式
-#[tokio::test]
-async fn rest_set_position_mode_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.set_position_mode().await;
-    println!("okx--设置持仓模式--{:?}", req_data);
-}
-
-//rest-获取历史订单记录（近七天)
-#[tokio::test]
-async fn rest_get_orders_history_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_orders_history("".to_string(),
-                                          "".to_string(),
-                                          "filled".to_string(),
-                                          "".to_string(),
-                                          "".to_string(),
-                                          "".to_string(),
-    ).await;
-    println!("okx--获取历史订单记录--{:?}", req_data);
-}
-
-//rest-获取历史成交数据（近七天）
-#[tokio::test]
-async fn rest_get_trades_test() {
-    global::log_utils::init_log_with_trace();
-
-    let mut ret = get_rest();
-    let req_data = ret.get_trades("".to_string(),
-                                  "".to_string(),
-                                  "".to_string(),
-                                  "".to_string(),
-                                  "".to_string(),
-                                  "100".to_string(),
-    ).await;
-    println!("okx--获取历史成交数据--{:?}", req_data);
-}
-
-
-async fn get_ws(btree_map: Option<OkxSwapLogin>, type_v: OkxSwapWsType) -> OkxSwapWs {
-    let ku_ws = OkxSwapWs::new(false, btree_map, type_v);
-    ku_ws
-}
-
-fn get_rest() -> OkxSwapRest {
-    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-    btree_map.insert("access_key".to_string(), ACCESS_KEY.to_string());
-    btree_map.insert("secret_key".to_string(), SECRET_KEY.to_string());
-    btree_map.insert("pass_key".to_string(), PASS_KEY.to_string());
-
-    let okx_exc = OkxSwapRest::new(false, btree_map.clone());
-    okx_exc
-}

exchanges/tests/socket_tool_test.rs

@@ -1,67 +0,0 @@
-use std::collections::BTreeMap;
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-use std::time::Duration;
-use futures_channel::mpsc::{UnboundedReceiver, UnboundedSender};
-use futures_util::StreamExt;
-use tokio::sync::mpsc::{channel, Sender};
-use tokio::try_join;
-use tokio_tungstenite::client_async;
-use tokio_tungstenite::tungstenite::{Error, Message};
-use tracing::trace;
-use exchanges::binance_swap_rest::BinanceSwapRest;
-use exchanges::binance_swap_ws::{BinanceSwapSubscribeType, BinanceSwapWs, BinanceSwapWsType};
-use exchanges::response_base::ResponseData;
-use exchanges::socket_tool::{client, ws_connect_async};
-
-//ws-订阅公共频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 5)]
-async fn ws_custom_subscribe() {
-    global::log_utils::init_log_with_trace();
-
-    // // 币安订阅
-    let base_url = "wss://fstream.binance.com/stream?streams=btcusdt@depth20@100ms".to_string();
-    // // okx 公共订阅
-    // let str = serde_json::json!({
-    //             "op": "subscribe",
-    //             "args": [
-    //                     {
-    //                     "channel":"books5",
-    //                     "instId":"BTC-USDT"
-    //                     }
-    //                 ]
-    //         });
-    //
-    // //创建通道，发送指令通道， 与读取推送数据通道
-    // let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-    // let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded();
-    //
-    //
-    // //对象
-    // // let model = OkxSwapModel::new();
-    // let is_ok =  ws_connect_async(base_url).await;
-    // //写数据，订阅频道，有些是Url跟参数，有些是单独发送订阅字符串
-    // // write_tx.unbounded_send(Message::Text(str.to_string())).expect("发送失败");
-    // match is_ok {
-    //     Ok(_) => {
-    //         let t1 = tokio::spawn(async move {
-    //             loop {
-    //                 if let Some(message) = read_rx.next().await {
-    //
-    //                 }
-    //             }
-    //         });
-    //         try_join!(t1).unwrap();
-    //     }
-    //     _ => {}
-    // }
-    client(base_url).await;
-}
-
-//
-// fn get_ws(btree_map: BTreeMap<String, String>, tx: Sender<ResponseData>) -> BinanceSwapWs {
-//     let binance_ws = BinanceSwapWs::new(false,
-//                                         btree_map,
-//                                         BinanceSwapWsType::PublicAndPrivate);
-//     binance_ws
-// }

exchanges/tests/test.rs

@@ -1,547 +0,0 @@
-use exchanges::gate_swap_rest::GateSwapRest;
-use std::collections::BTreeMap;
-use tokio::io::{AsyncReadExt};
-use exchanges::kucoin_swap_rest::KucoinSwapRest;
-use exchanges::kucoin_swap_ws::{KucoinSwapSubscribeType, KucoinSwapWs, KucoinSwapWsType};
-use exchanges::{proxy};
-use exchanges::okx_swap_ws::{OkxSwapSubscribeType, OkxSwapWs, OkxSwapWsType};
-
-use std::io::{Read, Write};
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-use tokio::sync::mpsc::channel;
-use tokio::try_join;
-use tracing::{trace};
-use tracing::instrument::WithSubscriber;
-use exchanges::binance_swap_rest::BinanceSwapRest;
-use exchanges::binance_swap_ws::{BinanceSwapSubscribeType, BinanceSwapWs, BinanceSwapWsType};
-use exchanges::okx_swap_rest::OkxSwapRest;
-
-#[tokio::test]
-async fn test_import() {
-    global::log_utils::init_log_with_trace();
-
-
-    /*******走代理：根据环境变量配置来决定,如果配置了走代理，没有配置不走*******/
-    if proxy::ParsingDetail::http_enable_proxy() {
-        trace!("检测有代理配置，配置走代理");
-    }
-
-
-    //获取代理
-    // demo_get_http_proxy();
-
-    //币安---深度socket-公共频道订阅
-    // demo_pub_ws_ba().await;
-    // 币安-rest-获取账户信息
-    // demo_rest_ba().await;
-    //本次更新成功
-
-
-    //gate-rest -账户信息
-    // demo_rest_gate().await;
-    //gate-ws-public-private频道
-    // demo_ws_gate().await;
-
-
-    //kucoin_rest -账户信息
-    // demo_rest_kucoin().await;
-    //Kucoin-ws--公共频道
-    // demo_ws_kucoin_pu().await;
-    //Kucoin-ws--私有频道
-    // demo_ws_kucoin_pr().await;
-
-    //okx - Business 频道
-    // demo_ws_okx_bu().await;
-    //okx - public 频道
-    // demo_ws_okx_pu().await;
-    //okx - rest 频道
-    // demo_okx_rest().await;
-
-    // demo_so();
-
-
-    // let mut ku_ws = KucoinSwapWs::new(false, btree_map.clone(),
-    //                                   KucoinWsType::Private, tx).await;
-    // ku_ws.set_subscribe(vec![KucoinSubscribeType::PrContractMarketTradeOrdersSys]);
-    //
-    // let t1 = tokio::spawn(async move {
-    //     ku_ws.custom_subscribe(vec!["ACHUSDTM".to_string(), "ROSEUSDTM".to_string()]).await;
-    // });
-    //
-    // let t2 = tokio::spawn(async move {
-    //     let mut stdout = std::io::stdout();
-    //     loop {
-    //         if let Ok(received) = rx.try_recv() {
-    //             writeln!(stdout, "age: {:?}", received).unwrap();
-    //         }
-    //     }
-    // let t01 = tokio::spawn(async move {
-    //     loop {
-    //         tokio::time::sleep(Duration::from_secs(2)).await;
-    //         trace!( "发送-指令: ");
-    //     }
-    // });
-    // let t02 = tokio::spawn(async move {
-    //     loop {
-    //         tokio::time::sleep(Duration::from_secs(3)).await;
-    //         trace!( "接收 -指令: ");
-    //     }
-    // });
-    // try_join!(t01,t02).unwrap();
-
-
-    // let (mut tx_end, mut rx_end) = channel::<String>(1024);
-    // let (mut tx_read, mut rx_read) = channel::<String>(1024);
-    // let mut stream = tokio::net::TcpStream::connect("127.0.0.1:8080").await.unwrap();
-    // stream.write_all( b"Hello, server!").await.unwrap();
-    // stream.flush().await.unwrap();
-    // let mutex_stream = Arc::new(Mutex::new(stream));
-    //
-    // //捕捉用户的主动发送的订阅指令
-    // let stream_clone = Arc::clone(&mutex_stream);
-    // let t_1 = tokio::spawn(async move {
-    //     loop {
-    //         tokio::time::sleep(Duration::from_secs(1)).await;
-    //         if let Ok(received) = rx_end.try_recv() {
-    //             trace!("动态订阅内容： {:?}", received);
-    //             let mut stream_lock = stream_clone.lock().await;
-    //             // stream_lock.write_all( b"1111!").await.unwrap();
-    //             // stream_lock.flush().await.unwrap();
-    //
-    //             // stream_lock.write_all(b"Hello, server!").await.unwrap();
-    //         }
-    //     }
-    // });
-    //
-    //
-    // //socket数据获取，装入回显通道
-    // let stream_clone = Arc::clone(&mutex_stream);
-    // let t_2 = tokio::spawn(async move {
-    //     // 创建一个用于存储服务器响应的缓冲区
-    //     let mut buffer = [0; 512];
-    //     loop {
-    //         let mut stream_lock = stream_clone.lock().await;
-    //         tokio::time::sleep(Duration::from_secs(1)).await;
-    //
-    //         let _ = match stream_lock.read(&mut buffer).await {
-    //             Ok(n) => {
-    //                 tokio::time::sleep(Duration::from_secs(1)).await;
-    //                 if n == 0 {
-    //                     // 没有读取到数据
-    //                     trace!("没有数据,主动发送");
-    //                 } else {
-    //                     // 打印服务器的响应
-    //                     trace!("有数据: {}", String::from_utf8_lossy(&buffer[..n]));
-    //                     tx_read.send(format!("{}", String::from_utf8_lossy(&buffer[..n]))).await.unwrap()
-    //                 }
-    //             }
-    //             Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
-    //                 // 如果读取操作会阻塞，则等待一会儿再试
-    //                 trace!("Would block, sleeping会阻碍睡眠??");
-    //                 tokio::time::sleep(Duration::from_secs(3)).await;
-    //                 continue;
-    //             }
-    //             Err(e) => {
-    //                 trace!("Err:{:?}",e);
-    //                 break;
-    //             }
-    //         };
-    //     }
-    // });
-    //
-    //
-    // //socket 数据回显
-    // let t02 = tokio::spawn(async move {
-    //     loop {
-    //         tokio::time::sleep(Duration::from_secs(1)).await;
-    //         // tx.send("hai!!!".to_string()).await.unwrap();
-    //         if let Ok(received) = rx_read.try_recv() {
-    //             trace!("拿到 socket 的数据: {:?}", received);
-    //         }
-    //     }
-    // });
-    //
-    // //模拟用户动态发送
-    // let t03 = tokio::spawn(async move {
-    //     loop {
-    //         tokio::time::sleep(Duration::from_secs(1)).await;
-    //         tx_end.send("这里是 动态订阅".to_string()).await.unwrap();
-    //     }
-    // });
-    //
-    // try_join!(t_1,t_2,t02,t03).unwrap();
-}
-
-
-async fn demo_okx_rest() {
-    // let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-    // btree_map.insert("access_key".to_string(), "".to_string());
-    // btree_map.insert("secret_key".to_string(), "".to_string());
-    // btree_map.insert("pass_key".to_string(), "".to_string());
-    //
-    // let mut okx_rest = OkxSwapRest::new(false, btree_map);
-    // let res_data = okx_rest.get_account("BTC".to_string()).await;
-    // trace!("okx_rest-rest - get_account- {:?}", res_data);
-}
-
-async fn demo_ws_gate() {}
-
-
-fn demo_so() {
-    // 代理服务器地址和端口
-    // let proxy_address = "127.0.0.1:7890";
-    // // 目标服务器地址和端口
-    // let target_address = "wss://ws.okx.com:8443/ws/v5/public";
-    //
-    //   // 建立与代理服务器的连接
-    //   let mut proxy_stream = TcpStream::connect(proxy_address).expect("Failed to connect to proxy");
-    //
-    //   // 发送代理请求
-    //   let request = format!("CONNECT {}\r\n\r\n", target_address);
-    //   proxy_stream.write_all(request.as_bytes()).expect("Failed to send proxy request");
-    //
-    //   // 读取代理响应
-    //   let mut response = String::new();
-    //   proxy_stream.read_to_string(&mut response).expect("Failed to read proxy response");
-    //
-    //   // 检查代理响应是否成功
-    //   if !response.contains("200 Connection established") {
-    //       trace!("Proxy connection failed: {}", response);
-    //   }
-    //
-    //   // 从代理连接中获取原始 TCP 流
-    //   let mut tcp_stream = std::mem::ManuallyDrop::new(proxy_stream);
-    //
-    //   // 现在你可以使用 `tcp_stream` 来进行与目标服务器的通信
-    //   // 例如，发送和接收数据
-    //   // tcp_stream.write_all(b"Hello, server!").expect("Failed to send data");
-    //
-    //   thread::spawn(move || {
-    //       loop {
-    //           let mut buffer = [0u8; 1024]; // 用于存储读取的数据的缓冲区
-    //           let bytes_read = tcp_stream.read(&mut buffer).expect("Failed to read data");
-    //
-    //           // 将读取的数据转换为字符串并打印
-    //           if let Ok(data) = std::str::from_utf8(&buffer[..bytes_read]) {
-    //               trace!("Received data: {}", data);
-    //           } else {
-    //               trace!("Received data contains non-UTF8 characters");
-    //           }
-    //       }
-    //
-    //   });
-    //
-    //   // 最后记得手动释放套接字
-    //   // 注意：不要调用 `drop(tcp_stream)`，因为我们使用了 `ManuallyDrop` 来避免自动释放
-    //   unsafe {
-    //       std::mem::ManuallyDrop::drop(&mut tcp_stream);
-    //   }
-}
-
-
-async fn demo_ws_okx_pu() {
-
-    // let btree_map: BTreeMap<String, String> = BTreeMap::new();
-    // let (tx, mut rx) = channel(1024);
-    // let mut ku_ws = OkxSwapWs::new(false, btree_map, OkxWsType::Public, tx);
-    // ku_ws.set_subscribe(vec![OkxSubscribeType::PuIndexTickers]);
-    // let t1 = tokio::spawn(async move {
-    //     ku_ws.custom_subscribe(vec!["BTC-USD".to_string()]).await;
-    // });
-    // let t2 = tokio::spawn(async move {
-    //     let mut stdout = std::io::stdout();
-    //     loop {
-    //         if let Ok(received) = rx.try_recv() {
-    //             writeln!(stdout, "age: {:?}", received).unwrap();
-    //         }
-    //     }
-    // });
-    // try_join!(t1,t2).unwrap();
-}
-
-async fn demo_ws_okx_bu() {
-    // let btree_map: BTreeMap<String, String> = BTreeMap::new();
-    // let (tx, mut rx) = channel(1024);
-    // let mut ku_ws = OkxSwapWs::new(false, btree_map, OkxWsType::Business, tx);
-    // ku_ws.set_subscribe(vec![OkxSubscribeType::BuIndexCandle30m]);
-    // let t1 = tokio::spawn(async move {
-    //     ku_ws.custom_subscribe(vec!["BTC-USD".to_string()]).await;
-    // });
-    // let t2 = tokio::spawn(async move {
-    //     let mut stdout = std::io::stdout();
-    //     loop {
-    //         if let Ok(received) = rx.try_recv() {
-    //             writeln!(stdout, "age: {:?}", received).unwrap();
-    //         }
-    //     }
-    // });
-    // try_join!(t1,t2).unwrap();
-}
-
-async fn demo_ws_kucoin_pr() {
-    // let mut is_shutdown_arc = Arc::new(AtomicBool::new(true));
-    // let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-    // btree_map.insert("access_key".to_string(), "".to_string());
-    // btree_map.insert("secret_key".to_string(), "".to_string());
-    // btree_map.insert("pass_key".to_string(), "".to_string());
-    // trace!("----------------------btree_map{:?}", btree_map.clone());
-    // let (tx, mut rx) = channel(1024);
-    // let mut ku_ws = KucoinSwapWs::new(false, btree_map.clone(),
-    //                                   KucoinWsType::Private, tx).await;
-    // ku_ws.set_subscribe(vec![KucoinSubscribeType::PrContractMarketTradeOrdersSys]);
-    //
-    // let t1 = tokio::spawn(async move {
-    //     ku_ws.custom_subscribe(is_shutdown_arc, vec!["ACHUSDTM".to_string(), "ROSEUSDTM".to_string()]).await;
-    // });
-    //
-    // let t2 = tokio::spawn(async move {
-    //     loop {
-    //         if let Ok(received) = rx.try_recv() {
-    //             trace!( "age: {:?}", received);
-    //         }
-    //     }
-    // });
-    //
-    // try_join!(t1,t2).unwrap();
-}
-
-async fn demo_ws_kucoin_pu() {
-    // let mut is_shutdown_arc = Arc::new(AtomicBool::new(true));
-    // let btree_map: BTreeMap<String, String> = BTreeMap::new();
-    // let (tx, mut rx) = channel(1024);
-    // let mut ku_ws = KucoinSwapWs::new(false, btree_map, KucoinWsType::Public, tx).await;
-    // ku_ws.set_subscribe(vec![
-    //     KucoinSubscribeType::PuContractMarketLevel2Depth50,
-    //     KucoinSubscribeType::PuContractMarkettickerV2,
-    // ]);
-    //
-    // let t1 = tokio::spawn(async move {
-    //     ku_ws.custom_subscribe(is_shutdown_arc, vec!["ACHUSDTM".to_string(), "ROSEUSDTM".to_string()]).await;
-    // });
-    // let t2 = tokio::spawn(async move {
-    //     loop {
-    //         if let Ok(received) = rx.try_recv() {
-    //             trace!("age: {:?}", received);
-    //         }
-    //     }
-    // });
-    //
-    // try_join!(t1,t2).unwrap();
-}
-
-async fn demo_rest_kucoin() {
-    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-    btree_map.insert("access_key".to_string(), "".to_string());
-    btree_map.insert("secret_key".to_string(), "".to_string());
-    btree_map.insert("pass_key".to_string(), "".to_string());
-
-    let mut kucoin_exc = KucoinSwapRest::new(false, btree_map);
-    // let res_data = kucoin_exc.get_server_time().await;
-    // trace!("kucoin_exc-rest - get_server_time- {:?}", res_data);
-    // trace!("kucoin_exc-rest-get_delays{:?}", kucoin_exc.get_delays() );
-    // trace!("kucoin_exc-rest -get_avg_delay{:?}", kucoin_exc.get_avg_delay());
-    // let res_data = kucoin_exc.get_account("USDT".to_string()).await;
-    // trace!("kucoin_exc-rest - get_account- {:?}", res_data);
-    // let res_data = kucoin_exc.get_position("XBT1USDM".to_string()).await;
-    // trace!("kucoin_exc-rest - get_position- {:?}", res_data);
-    // let res_data = kucoin_exc.get_market_details().await;
-    // trace!("kucoin_exc-rest - get_market_details- {:?}", res_data);
-    // let res_data = kucoin_exc.get_ticker("ROSEUSDTM".to_string()).await;
-    // trace!("kucoin_exc-rest - get_ticker- {:?}", res_data);
-    let res_data = kucoin_exc.get_orders("".to_string(),
-                                         "".to_string()).await;
-    trace!("kucoin_exc-rest - get_orders- {:?}", res_data);
-    // let res_data = kucoin_exc.get_positions("USDT".to_string()).await;
-    // trace!("kucoin_exc-rest - get_positions- {:?}", res_data);
-    // let res_data = kucoin_exc.get_orders_details("111".to_string(), "".to_string()).await;
-    // trace!("kucoin_exc-rest - get_orders_details- {:?}", res_data);
-    // let res_data = kucoin_exc.swap_bazaar_order(
-    //     "cs_202309111808".to_string(),
-    //     "ROSEUSDTM".to_string(),
-    //     "pd".to_string(),
-    //     1,
-    //     "10".to_string(),
-    //     "0.03856".to_string(),
-    //     "limit".to_string(),
-    // ).await;
-    // trace!("kucoin_exc-rest - swap_bazaar_order- {:?}
-    // let res_data = kucoin_exc.cancel_order("".to_string(), "999999".to_string()).await;
-    // trace!("kucoin_exc-rest - cancel_order- {:?}", res_data);
-    // let res_data = kucoin_exc.get_public_token().await;
-    // trace!("kucoin_exc-rest - get_public_token- {:?}", res_data);
-}
-
-async fn demo_rest_gate() {
-    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-    btree_map.insert("access_key".to_string(), "".to_string());
-    btree_map.insert("secret_key".to_string(), "".to_string());
-
-    let mut gate_exc = GateSwapRest::new(false, btree_map);
-    let res_data = gate_exc.get_account("usdt".to_string()).await;
-    trace!("gate-rest -账户信息{:?}", res_data);
-    trace!("gate-rest -get_delays{:?}", gate_exc.get_delays() );
-    trace!("gate-rest -get_avg_delay{:?}", gate_exc.get_avg_delay());
-    // let res_data = gate_exc.get_position("usdt".to_string(), "CYBER_USDT".to_string()).await;
-    // trace!("gate-rest -持仓信息{:?}", res_data);
-    // let res_data = gate_exc.get_ticker("usdt".to_string()).await;
-    // trace!("gate-rest -ticker{:?}", res_data);
-    // let res_data = gate_exc.get_server_time().await;
-    // trace!("gate-rest -get_server_time{:?}", res_data);
-    // let res_data = gate_exc.get_user_position("usdt".to_string()).await;
-    // trace!("gate-rest -get_server_time{:?}", res_data);
-    // let res_data = gate_exc.get_order_details("usdt".to_string(), "11335522".to_string()).await;
-    // trace!("gate-rest -get_order_details{:?}", res_data);
-    // let res_data = gate_exc.get_orders("usd1t".to_string(), "open".to_string()).await;
-    // trace!("gate-rest -get_orders{:?}", res_data);
-    // let params = serde_json::json!({
-    //         "contract":"CYBER_USDT",
-    //         "size":-1,
-    //         "price":"0",
-    //         "tif":"ioc",
-    //      });
-    // let res_data = gate_exc.take_order("usdt".to_string(), params).await;
-    // trace!("gate-rest -get_orders{:?}", res_data);
-    // let res_data = gate_exc.setting_dual_mode("usdt".to_string(), true).await;
-    // trace!("gate-rest -setting_dual_mode{:?}", res_data);
-    // let res_data = gate_exc.setting_dual_leverage("usdt".to_string(),
-    //                                               "CYBER_USDT".to_string(),
-    //                                               "20".to_string(),
-    // ).await;
-    // trace!("gate-rest -setting_dual_mode{:?}", res_data);
-    // let res_data = gate_exc.wallet_transfers("usdt".to_string(),
-    //                                               "CYBER_USDT".to_string(),
-    //                                               "20".to_string(),
-    // ).await;
-    // trace!("gate-rest -setting_dual_mode{:?}", res_data);
-    // let res_data = gate_exc.cancel_order("usdt".to_string(),
-    //                                      "12345".to_string(),
-    // ).await;
-    // trace!("gate-rest -setting_dual_mode{:?}", res_data);
-    // let res_data = gate_exc.cancel_orders("usdt".to_string(),
-    //                                      "CYBER_USDT".to_string(),
-    // ).await;
-    // trace!("gate-rest -cancel_orders{:?}", res_data);
-    // let res_data = gate_exc.order(
-    //     "usdt".to_string(),
-    //     "long".to_string(),
-    //     "buy".to_string(),
-    //     "ROSE_USDT".to_string(),
-    //     1,
-    //     "0.03888".to_string(),
-    //     "t-my-custom-id-001".to_string(),
-    // ).await;
-    // trace!("gate-rest -order{:?}", res_data);
-
-
-    // let res_data = gate_exc.my_trades("usdt".to_string()).await;
-    // trace!("gate-rest -my_trades{:?}", res_data);
-    let res_data = gate_exc.account_book("usdt".to_string()).await;
-    trace!("gate-rest -account_book{:?}", res_data);
-}
-
-async fn demo_rest_ba() {
-    let mut btree_map: BTreeMap<String, String> = BTreeMap::new();
-    btree_map.insert("access_key".to_string(), "".to_string());
-    btree_map.insert("secret_key".to_string(), "".to_string());
-
-    // let ba_exc = BinanceUsdtSwapRest::new(false, btree_map);
-    // let res_data = ba_exc.get_account().await;
-    let mut ba_exc = BinanceSwapRest::new(false, btree_map);
-    // let res_data = ba_exc.get_server_time().await;
-    // trace!("币安-rest - get_server_time{:?}", res_data);
-    // let res_data = ba_exc.get_exchange_info().await;
-    // trace!("币安-restget_ get_exchange_info{:?}", res_data);
-
-
-    let res_data = ba_exc.get_account().await;
-    trace!("币安-rest-获取账户信息{:?}", res_data);
-    // trace!("币安-rest- -get_delays{:?}", ba_exc.get_delays() );
-    // trace!("币安-rest--get_avg_delay{:?}", ba_exc.get_avg_delay());
-
-    // let res_data = ba_exc.get_order("BTCUSDT".to_string(), 131, "".to_string()).await;
-    // trace!("币安-rest--get_order{:?}", res_data);
-    // let res_data = ba_exc.get_open_orders("BTCUSDT".to_string()).await;
-    // trace!("币安-rest--get_open_orders{:?}", res_data);
-    // let timestamp_start = chrono::Utc::now().timestamp_millis() - 60 * 100 * 1000;
-    // let timestamp_end = chrono::Utc::now().timestamp_millis() +  60 * 100 * 1000;
-    // let res_data = ba_exc.get_all_orders("BTCUSDT".to_string(), 1000, timestamp_start, timestamp_end).await;
-    // trace!("币安-rest--get_all_orders{:?}", res_data);
-    // let res_data = ba_exc.get_book_ticker("BTCUSDT".to_string()).await;
-    // trace!("币安-rest--get_book_ticker{:?}", res_data);
-    // let res_data = ba_exc.get_position_risk("BTCUS1DT".to_string()).await;
-    // trace!("币安-rest--get_position_risk{:?}", res_data);
-    // let res_data = ba_exc.change_pos_side(true).await;
-    // trace!("币安-rest--change_pos_side{:?}", res_data);
-    // let res_data = ba_exc.cancel_order("BTCUSDT".to_string(), 3312331, "".to_string()).await;
-    // trace!("币安-rest--cancel_order{:?}", res_data);
-}
-
-async fn demo_pub_ws_ba() {
-    // let mut is_shutdown_arc = Arc::new(AtomicBool::new(true));
-    // let btree_map: BTreeMap<String, String> = BTreeMap::new();
-    // let (tx, mut rx) = channel(1024);
-    // let mut binance_ws = BinanceSwapWs::new(false, btree_map, BinanceWsType::PublicAndPrivate, tx);
-    // binance_ws.set_subscribe(vec![
-    //     BinanceSubscribeType::PuAggTrade,
-    //     BinanceSubscribeType::PuDepth20levels100ms,
-    //     BinanceSubscribeType::PuBookTicker,
-    // ]);
-    // let t1 = tokio::spawn(async move {
-    //     binance_ws.custom_subscribe(is_shutdown_arc,vec!["BTCUSDT".to_string()]).await;
-    // });
-    // let t2 = tokio::spawn(async move {
-    //     loop {
-    //         if let Ok(received) = rx.try_recv() {
-    //             trace!( "age: {:?}", received);
-    //         }
-    //     }
-    // });
-    // try_join!(t1,t2).unwrap();
-}
-
-fn demo_get_http_proxy() {
-    //代理地址
-    let parsing_detail = proxy::ParsingDetail::parsing_environment_variables();
-    trace!("----代理信息：{:?}", parsing_detail);
-}
-
-
-// /*********************web服务*/
-// fn demo_http() {
-//     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-//     for stream in listener.incoming() {
-//         let stream = stream.unwrap();
-//
-//         handle_connection(TcpStream::try_from(stream).unwrap());
-//     }
-// }
-//
-//
-// fn handle_connection(mut stream: TcpStream) {
-//     let buf_reader = BufReader::new(&mut stream);
-//     let http_request: Vec<_> = buf_reader
-//         .lines()
-//         .map(|result| result.unwrap())
-//         .take_while(|line| !line.is_empty())
-//         .collect();
-//     trace!("Request: {:#?}", http_request);
-//     trace!("Request2: {:#?}", http_request[0]);
-//     trace!("Request3: {:#?}", http_request[1]);
-//
-//     let (status_line, filename) = if http_request[0] == "GET / HTTP/1.1" {
-//         ("HTTP/1.1 200 OK", "hello.html")
-//     } else {
-//         ("HTTP/1.1 404 NOT FOUND", "404.html")
-//     };
-//
-//     let status_line = "HTTP/1.1 200 OK";
-//     let contents = fs::read_to_string("src/404.html").unwrap();
-//     let length = contents.len();
-//
-//     let response =
-//         format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
-//     // let response = "HTTP/1.1 200 OK\r\n\r\nccccc";
-//
-//     stream.write_all(response.as_bytes()).unwrap();
-// }

exchanges/tests/xlsx_test.rs

@@ -1,229 +0,0 @@
-use std::collections::{BTreeMap, HashSet};
-use chrono::{DateTime, FixedOffset, NaiveDateTime, TimeZone, Utc};
-
-use tracing::{trace};
-
-use exchanges::gate_swap_rest::GateSwapRest;
-use exchanges::xlsx_utils::creation_xlsx;
-
-//ws-订阅公共频道信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 1)]
-async fn test_gate_creation_xlsx() {
-    global::log_utils::init_log_with_trace();
-
-    //获取不同账号的数据
-    let mut acc_array: Vec<BTreeMap<String, String>> = vec![];
-    let mut acc_all_data: BTreeMap<String, Vec<Vec<String>>> = BTreeMap::new();
-    let mut acc_all_data_clone: BTreeMap<String, Vec<Vec<String>>> = BTreeMap::new();
-    let mut data_array_all: Vec<Vec<String>> = vec![];
-    let mut time_all: Vec<i64> = vec![];
-    loop {
-        let mut gate60: BTreeMap<String, String> = BTreeMap::new();
-        gate60.insert("acc_name".to_string(), String::from("gate60"));
-        gate60.insert("access_key".to_string(), String::from("61e3a1b12c44c8ccfce1f32782b9922f"));
-        gate60.insert("secret_key".to_string(), String::from("f3f533fa685cbae44b3017f73b71e90eaa9aa8d4922a39426744721e4824a527"));
-        acc_array.push(gate60);
-
-        let mut gate59: BTreeMap<String, String> = BTreeMap::new();
-        gate59.insert("acc_name".to_string(), String::from("gate59"));
-        gate59.insert("access_key".to_string(), String::from("c691d4fcc5a5a98af459f993a3a0c653"));
-        gate59.insert("secret_key".to_string(), String::from("05e7f8640bffeacc146b6f9f08512955d00d89bbdb051c9427f31adf96adeb2f"));
-        acc_array.push(gate59);
-
-        let mut gate58: BTreeMap<String, String> = BTreeMap::new();
-        gate58.insert("acc_name".to_string(), String::from("gate58"));
-        gate58.insert("access_key".to_string(), String::from("dfdc30687ac71daefa2fb39c706b8afa"));
-        gate58.insert("secret_key".to_string(), String::from("31e8999f85d38f5dd174f8919d9a1611c24d4e35b4d6319d6b160005871bf8b6"));
-        acc_array.push(gate58);
-
-        let mut gate57: BTreeMap<String, String> = BTreeMap::new();
-        gate57.insert("acc_name".to_string(), String::from("gate57"));
-        gate57.insert("access_key".to_string(), String::from("ba11ea511f343763db7c92c685f20c12"));
-        gate57.insert("secret_key".to_string(), String::from("272d1d38ac4f0af3e6ed96e6a9a2c59dd905c3d7ad730507008604bba14edb3d"));
-        acc_array.push(gate57);
-
-        let mut gate56: BTreeMap<String, String> = BTreeMap::new();
-        gate56.insert("acc_name".to_string(), String::from("gate56"));
-        gate56.insert("access_key".to_string(), String::from("72f0c351a83b04808baad625f6085599"));
-        gate56.insert("secret_key".to_string(), String::from("8a8d482bcc31f184cce350531cb40ca70564f9c466698d025e16d8943257dc0f"));
-        acc_array.push(gate56);
-
-        let mut gate55: BTreeMap<String, String> = BTreeMap::new();
-        gate55.insert("acc_name".to_string(), String::from("gate55"));
-        gate55.insert("access_key".to_string(), String::from("036408d5cbd8ddf1c6e0baab61ee641a"));
-        gate55.insert("secret_key".to_string(), String::from("940414a37711e59848011e99e223fa11b0e69f8badd35347301e3f8e41957a60"));
-        acc_array.push(gate55);
-
-        let mut gate54: BTreeMap<String, String> = BTreeMap::new();
-        gate54.insert("acc_name".to_string(), String::from("gate54"));
-        gate54.insert("access_key".to_string(), String::from("fbe564e8bd4efaa0c3c023ca8c057b36"));
-        gate54.insert("secret_key".to_string(), String::from("0be3c0223fd021fdacacc03f183f467e988ceee6eb1b0e09ca96bb1eebd45f39"));
-        acc_array.push(gate54);
-
-        let mut gate53: BTreeMap<String, String> = BTreeMap::new();
-        gate53.insert("acc_name".to_string(), String::from("gate53"));
-        gate53.insert("access_key".to_string(), String::from("16d91ba0a3d79a2925d16ea01a615fa1"));
-        gate53.insert("secret_key".to_string(), String::from("607b07cf240466656c00beb0c6fff252839467583fd3f8b14782eb007b3d99ce"));
-        acc_array.push(gate53);
-
-        let mut gate52: BTreeMap<String, String> = BTreeMap::new();
-        gate52.insert("acc_name".to_string(), String::from("gate52"));
-        gate52.insert("access_key".to_string(), String::from("31054006c457a80a027e961cf3e5e3a4"));
-        gate52.insert("secret_key".to_string(), String::from("a43f8f5672b49bfcc304d0731100610de1c55e7d2b6c00199b267993f0b189d1"));
-        acc_array.push(gate52);
-
-        let mut gate51: BTreeMap<String, String> = BTreeMap::new();
-        gate51.insert("acc_name".to_string(), String::from("gate51"));
-        gate51.insert("access_key".to_string(), String::from("edcedefe7830dd5722c2c37704ae700f"));
-        gate51.insert("secret_key".to_string(), String::from("41db86a8463ac7c66023a8505e5fddd3448e551a11a52141bf57ca8478e2149b"));
-        acc_array.push(gate51);
-
-
-        for acc in acc_array {
-            let mut gate_exc = GateSwapRest::new(false, acc.clone());
-            let data = gate_exc.account_book("usdt".to_string()).await;
-            // trace!("data???????：{:?}",data.clone());
-            if data.code.as_str() == "200" {
-                let acc_name = acc.get("acc_name").clone();
-
-                //账号
-                let json_value: serde_json::Value = serde_json::from_str(&data.data).unwrap();
-                if let serde_json::Value::Array(array) = json_value {
-                    let mut name_data_all: Vec<Vec<String>> = vec![];
-                    let mut name_data_all_clone: Vec<Vec<String>> = vec![];
-                    for item in array {
-                        let time = item["time"].as_i64().unwrap();//秒级
-                        // 使用秒构建一个DateTime<Utc>对象
-                        // let datetime: DateTime<Utc> = Utc.timestamp(time, 0);
-                        //2023-12-10 00:00:00
-                        if 1702051200 > time {
-                            continue;
-                        }
-                        time_all.push(time);
-                        let time_str = NaiveDateTime::from_timestamp_millis((time + 8 * 3600) * 1000).unwrap().format("%Y-%m-%d %H:%M:%S%.3f").to_string();
-
-                        trace!("数据时间解析:{:?}---{:?}",time,time_str);
-                        let change = item["change"].as_str().unwrap();
-
-                        let balance = item["balance"].as_str().unwrap();
-                        let type_str = match item["type"].as_str().unwrap() {
-                            "dnw" => { "转入转出" }
-                            "pnl" => { "减仓盈亏" }
-                            "fee" => { "交易手续费" }
-                            "refr" => { "推荐人返佣" }
-                            "fund" => { "资金费用" }
-                            "point_dnw" => { "点卡转入转出" }
-                            "point_fee" => { "点卡交易手续费" }
-                            "point_refr" => { "点卡推荐人返佣" }
-                            _ => {
-                                "未知-变更类型"
-                            }
-                        };
-                        let text = item["text"].as_str().unwrap();
-                        let contract = item["contract"].as_str().unwrap();
-                        let trade_id = item["trade_id"].as_str().unwrap();
-
-                        let mut name_data_array: Vec<String> = vec![];
-                        name_data_array.push(time_str.to_string());
-                        name_data_array.push(trade_id.to_string());
-                        name_data_array.push(change.to_string());
-                        name_data_array.push(balance.to_string());
-                        name_data_array.push(type_str.to_string());
-                        name_data_array.push(contract.to_string());
-                        name_data_array.push(text.to_string());
-
-                        let mut name_data_array_clone: Vec<String> = vec![];
-                        name_data_array_clone.push(time.to_string());
-                        name_data_array_clone.push(trade_id.to_string());
-                        name_data_array_clone.push(change.to_string());
-                        name_data_array_clone.push(balance.to_string());
-                        name_data_array_clone.push(type_str.to_string());
-                        name_data_array_clone.push(contract.to_string());
-                        name_data_array_clone.push(text.to_string());
-
-                        name_data_all.push(name_data_array.clone());
-                        name_data_all_clone.push(name_data_array_clone.clone());
-                        let mut cp =  name_data_array.clone();
-                        cp.push(acc_name.clone().unwrap().to_string());
-                        data_array_all.push(cp);
-                    }
-                    acc_all_data.insert(acc_name.clone().unwrap().to_string(), name_data_all.clone());
-                    acc_all_data_clone.insert(acc_name.clone().unwrap().to_string(), name_data_all_clone.clone());
-                } else {
-                    trace!("不是数组 检查数据");
-                }
-            }
-            // break;
-        }
-        break;//这里是为了 代码收纳，用了loop来放置代码
-    }
-    trace!("数据如下：{:?}",acc_all_data);
-
-    //汇总
-    //1. 生成时间片
-    let mut unique = HashSet::new();
-    time_all.retain(|e| unique.insert(*e));
-    trace!("时间片：{:?}",time_all);
-
-    //2. 根据时间片 去求每个时间片的  总余额，
-    let mut sum_data_array_all: Vec<Vec<String>> = vec![];
-    for time in time_all.clone() {
-        let mut sum_data_array: Vec<String> = vec![];
-        let mut sum_balance: f64 = 0 as f64;
-        for (key, value) in acc_all_data_clone.clone() {
-            let acc_key = key;
-            trace!("读取value：{:?}",value);
-            let filter_arrya: Vec<Vec<String>> = value.clone().into_iter().filter(|s| {
-                trace!("读取time：{:?}",s);
-                let time_v = s[0].clone();
-                time_v < (time - 1).to_string()
-            }).collect();
-
-            let balance: f64 = if filter_arrya.len() > 0 {
-                let row = filter_arrya[filter_arrya.len() - 1].clone();
-                trace!("读取balance：{:?}",row);
-                let balance_clone = row[3].clone();
-                balance_clone.parse::<f64>().unwrap()
-            } else {
-                0 as f64
-            };
-            sum_balance = balance + sum_balance;
-        }
-
-        // 使用秒构建一个DateTime<Utc>对象
-        let time_str = NaiveDateTime::from_timestamp_millis((time + 8 * 3600) * 1000).unwrap().format("%Y-%m-%d %H:%M:%S%.3f").to_string();
-
-        sum_data_array.push(time_str.to_string());
-        sum_data_array.push("".to_string());
-        sum_data_array.push("".to_string());
-        sum_data_array.push(sum_balance.to_string());
-        sum_data_array.push("".to_string());
-        sum_data_array.push("".to_string());
-        sum_data_array.push("".to_string());
-
-        sum_data_array_all.push(sum_data_array);
-    }
-    if sum_data_array_all.len() > 0 {
-        acc_all_data.insert("total".to_string(), sum_data_array_all);
-    }
-    if data_array_all.len() > 0{
-        acc_all_data.insert("gather".to_string(), data_array_all);
-    }
-
-    //数据组装.
-    let noe_row_name = vec!["时间", "成交Id", "变更金额", "变更后余额", "变更类型", "合约标识", "注释"];
-    //创建表格
-    //提示。涉及到 需要转换的数据，请提前自行转换，工具只负责写入生成
-    // after - 之后的，时间戳> after 才是有效数据
-    match creation_xlsx(&noe_row_name, &acc_all_data,
-                        "okx".to_string(),
-    ) {
-        Ok(d) => {
-            trace!("完成");
-        }
-        Err(z) => {
-            eprint!("{:?}", z);
-            trace!("失败");
-        }
-    }
-}

global/tests/appender_test.rs

@@ -1,33 +0,0 @@
-use tracing::{info};
-use tracing_subscriber::{fmt};
-use tracing_subscriber::prelude::*;
-use std::io;
-
-#[tokio::test]
-async fn appender_test() {
-    let file_appender = tracing_appender::rolling::daily("./logs", "tracing.log");
-    let (non_blocking, _) = tracing_appender::non_blocking(file_appender);
-
-    let fmt_layer = fmt::layer()
-        .with_target(false)
-        .with_level(true)
-        .with_writer(io::stdout);
-
-    let file_layer = fmt::layer()
-        .with_target(true)
-        .with_ansi(false)
-        .with_level(true)
-        .with_writer(non_blocking.clone());
-
-    let subscriber = tracing_subscriber::Registry::default()
-        .with(fmt_layer)
-        .with(file_layer)
-        .with(tracing_subscriber::EnvFilter::new("info"));
-
-    let _ = tracing::subscriber::set_global_default(subscriber);
-    let number = 42;
-    info!(answer = number, "the answer to life, the universe, and everything");
-
-    // 使 main 函数“等待”一段时间，增大日志被正确写入的机会
-    tokio::time::sleep(std::time::Duration::from_secs(10)).await;
-}

global/tests/export_utils_test.rs

@@ -1,12 +0,0 @@
-use tracing::trace;
-use global::export_utils;
-
-#[tokio::test]
-async fn export_excel() {
-    global::log_utils::init_log_with_trace();
-
-    let header = vec!["标题1", "标题2"];
-    let data = vec![vec!["第一行数据1", "第一行数据2"], vec!["第二行数据1", "第二行数据2"]];
-    let file_name = export_utils::export_excel(header,data,"");
-    trace!(?file_name);
-}

standard/tests/binance_handle_test.rs

@@ -1,91 +0,0 @@
-mod exchange_test;
-use tracing::instrument;
-use exchanges::binance_swap_ws::BinanceSwapSubscribeType;
-use standard::exchange::ExchangeEnum;
-use crate::exchange_test::test_new_exchange_wss;
-
-const SYMBOL: &str = "BTC_USDT";
-
-// 测试订阅深度信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_depth() {
-    global::log_utils::init_log_with_trace();
-
-    let binance_subscribe_type = vec![
-        BinanceSwapSubscribeType::PuDepth20levels100ms,
-    ];
-    test_new_exchange_wss(ExchangeEnum::BinanceSwap, SYMBOL, binance_subscribe_type, "depth").await;
-}
-
-// 测试订阅Ticker信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_ticker() {
-    global::log_utils::init_log_with_trace();
-
-    let binance_subscribe_type = vec![
-        BinanceSwapSubscribeType::PuBookTicker,
-    ];
-    test_new_exchange_wss(ExchangeEnum::BinanceSwap, SYMBOL, binance_subscribe_type, "ticker").await;
-}
-
-// 测试订阅Trade信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_trade() {
-    global::log_utils::init_log_with_trace();
-
-    let binance_subscribe_type = vec![
-        BinanceSwapSubscribeType::PuAggTrade,
-    ];
-    test_new_exchange_wss(ExchangeEnum::BinanceSwap, SYMBOL, binance_subscribe_type, "trade").await;
-}
-
-// // 测试订阅Record信息
-// #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-// #[instrument(level = "TRACE")]
-// async fn test_get_wss_record() {
-//     global::log_utils::init_log_with_trace();
-//
-//     let binance_subscribe_type = vec![
-//         BinanceSwapSubscribeType::PuDepth20levels100ms,
-//     ];
-//     test_new_exchange_wss(ExchangeEnum::BinanceSwap, SYMBOL, binance_subscribe_type, "record").await;
-// }
-
-// 测试订阅Account信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_account() {
-    global::log_utils::init_log_with_trace();
-
-    let binance_subscribe_type = vec![
-        BinanceSwapSubscribeType::PrBalance,
-    ];
-    test_new_exchange_wss(ExchangeEnum::BinanceSwap, SYMBOL, binance_subscribe_type, "account").await;
-}
-
-// 测试订阅Order信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_order() {
-    global::log_utils::init_log_with_trace();
-
-    let binance_subscribe_type = vec![
-        BinanceSwapSubscribeType::PrAccount,
-    ];
-    test_new_exchange_wss(ExchangeEnum::BinanceSwap, SYMBOL, binance_subscribe_type, "order").await;
-}
-
-// 测试订阅Position信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_position() {
-    global::log_utils::init_log_with_trace();
-
-    let binance_subscribe_type = vec![
-        BinanceSwapSubscribeType::PrPosition,
-    ];
-    test_new_exchange_wss(ExchangeEnum::BinanceSwap, SYMBOL, binance_subscribe_type, "position").await;
-}

standard/tests/binance_spot_handle_test.rs

@@ -1,31 +0,0 @@
-mod exchange_test;
-use tracing::instrument;
-use exchanges::binance_spot_ws::BinanceSpotSubscribeType;
-use standard::exchange::ExchangeEnum;
-use crate::exchange_test::test_new_exchange_wss;
-
-const SYMBOL: &str = "BTC_USDT";
-
-// 测试订阅深度信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_depth() {
-    global::log_utils::init_log_with_trace();
-
-    let binance_subscribe_type = vec![
-        BinanceSpotSubscribeType::PuDepth20levels100ms,
-    ];
-    test_new_exchange_wss(ExchangeEnum::BinanceSpot, SYMBOL, binance_subscribe_type, "depth").await;
-}
-
-// 测试订阅Ticker信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_ticker() {
-    global::log_utils::init_log_with_trace();
-
-    let binance_subscribe_type = vec![
-        BinanceSpotSubscribeType::PuBookTicker,
-    ];
-    test_new_exchange_wss(ExchangeEnum::BinanceSpot, SYMBOL, binance_subscribe_type, "ticker").await;
-}

standard/tests/binance_swap_test.rs

@@ -1,228 +0,0 @@
-mod exchange_test;
-
-use rust_decimal_macros::dec;
-use tracing::{instrument, trace};
-use standard::exchange::{ExchangeEnum};
-use standard::{Platform};
-use crate::exchange_test::test_new_exchange;
-
-const SYMBOL: &str = "CFX_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);
-}
-// 测试获取订单详情信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_orders_list() {
-    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_orders_list = binance_swap_exchange.get_orders_list("open").await;
-    trace!(?binance_get_orders_list);
-}
-
-// 测试下单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_take_order() {
-    global::log_utils::init_log_with_trace();
-
-    let mut binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
-    let binance_take_order = binance_swap_exchange.take_order("999999", "kd", dec!(0.11), dec!(50)).await;
-    trace!(?binance_take_order);
-}
-
-// 测试撤销订单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_cancel_order() {
-    global::log_utils::init_log_with_trace();
-
-    let mut binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
-    let binance_cancel_order = binance_swap_exchange.cancel_order("", "999999").await;
-    trace!(?binance_cancel_order);
-}
-
-// 测试批量撤销订单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_cancel_orders() {
-    global::log_utils::init_log_with_trace();
-
-    let mut binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
-    let binance_cancel_orders = binance_swap_exchange.cancel_orders().await;
-    trace!(?binance_cancel_orders);
-}
-
-// 测试设置持仓模式
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_set_dual_mode() {
-    global::log_utils::init_log_with_trace();
-
-    let mut binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
-    let binance_set_dual_mode = binance_swap_exchange.set_dual_mode("usdt", true).await;
-    trace!(?binance_set_dual_mode);
-}
-
-// 测试设置杠杆
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_set_dual_leverage() {
-    global::log_utils::init_log_with_trace();
-
-    let mut binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap, SYMBOL).await;
-    let binance_set_dual_leverage = binance_swap_exchange.set_dual_leverage("1").await;
-    trace!(?binance_set_dual_leverage);
-}

standard/tests/bitget_spot_handle_test.rs

@@ -1,56 +0,0 @@
-mod exchange_test;
-
-use tracing::{instrument};
-use exchanges::bitget_spot_ws::{BitgetSpotSubscribeType};
-use standard::exchange::ExchangeEnum;
-use crate::exchange_test::test_new_exchange_wss;
-
-const SYMBOL: &str = "BLZ_USDT";
-
-// 测试订阅深度订阅
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_depth() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_subscribe_type = vec![
-        BitgetSpotSubscribeType::PuBooks5
-    ];
-    test_new_exchange_wss(ExchangeEnum::BitgetSpot, SYMBOL, bitget_subscribe_type, "depth").await;
-}
-
-// 测试订阅Ticker信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_ticker() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_subscribe_type = vec![
-        BitgetSpotSubscribeType::PuTicker
-    ];
-    test_new_exchange_wss(ExchangeEnum::BitgetSpot, SYMBOL, bitget_subscribe_type, "ticker").await;
-}
-
-// 测试订阅Account信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_account() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_subscribe_type = vec![
-        BitgetSpotSubscribeType::PrAccount
-    ];
-    test_new_exchange_wss(ExchangeEnum::BitgetSpot, SYMBOL, bitget_subscribe_type, "account").await;
-}
-
-// 测试订阅Orders信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_orders() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_subscribe_type = vec![
-        BitgetSpotSubscribeType::PrOrders
-    ];
-    test_new_exchange_wss(ExchangeEnum::BitgetSpot, SYMBOL, bitget_subscribe_type, "orders").await;
-}

standard/tests/bitget_spot_test.rs

@@ -1,195 +0,0 @@
-use rust_decimal_macros::dec;
-use tracing::{instrument, trace};
-use standard::exchange::ExchangeEnum;
-use standard::Platform;
-use crate::exchange_test::test_new_exchange;
-
-mod exchange_test;
-
-const SYMBOL: &str = "BLZ_USDT";
-
-// 测试获取Exchange实体
-#[tokio::test]
-async fn test_get_self_exchange() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_self_exchange = bitget_swap_exchange.get_self_exchange();
-    trace!(?bitget_get_self_exchange);
-}
-
-// 测试获取交易对信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_symbol() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_self_symbol = bitget_swap_exchange.get_self_symbol();
-    trace!(?bitget_get_self_symbol);
-}
-
-// 测试获取是否使用高速通道
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_is_colo() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_self_is_colo = bitget_swap_exchange.get_self_is_colo();
-    trace!(?bitget_get_self_is_colo);
-}
-
-// 测试获取登录params信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_params() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_self_params = bitget_swap_exchange.get_self_params();
-    trace!("bitget_get_self_params={:?}",bitget_get_self_params);
-}
-
-// 测试获取Market信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_market() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_self_market = bitget_swap_exchange.get_self_market();
-    trace!(?bitget_get_self_market);
-}
-
-// 测试获取请求时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_delays() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_request_delays = bitget_swap_exchange.get_request_delays();
-    trace!(?bitget_get_request_delays);
-}
-
-// 测试获取请求平均时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_avg_delay() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_request_avg_delay = bitget_swap_exchange.get_request_avg_delay();
-    trace!(?bitget_get_request_avg_delay);
-}
-
-// 测试获取最大请求时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_max_delay() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_request_max_delay = bitget_swap_exchange.get_request_max_delay();
-    trace!(?bitget_get_request_max_delay);
-}
-
-// 测试获取服务器时间
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_server_time() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_server_time = bitget_swap_exchange.get_server_time().await;
-    trace!(?bitget_get_server_time);
-}
-
-// 测试获取账号信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_spot_account() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_spot_account = bitget_swap_exchange.get_spot_account().await;
-    trace!(?bitget_get_spot_account);
-}
-
-// 测试获取Ticker信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_ticker() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_ticker = bitget_swap_exchange.get_ticker().await;
-    trace!(?bitget_get_ticker);
-}
-
-// 测试获取Market信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_market() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_market = bitget_swap_exchange.get_market().await;
-    trace!(?bitget_get_market);
-}
-
-// 测试获取Order详情信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_order_detail() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_order_detail = bitget_swap_exchange.get_order_detail("", "999998").await;
-    trace!(?bitget_get_order_detail);
-}
-
-// 测试获取Order列表信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_orders_list() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_get_orders_list = bitget_swap_exchange.get_orders_list("").await;
-    trace!(?bitget_get_orders_list);
-}
-
-// 测试下单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_take_order() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_take_order = bitget_swap_exchange.take_order("9999922", "kd", dec!(0.21), dec!(30)).await;
-    trace!(?bitget_take_order);
-}
-
-// 测试撤销订单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_cancel_order() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_cancel_order = bitget_swap_exchange.cancel_order("", "999997").await;
-    trace!(?bitget_cancel_order);
-}
-
-// 测试撤销订单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_cancel_orders() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSpot, SYMBOL).await;
-    let bitget_cancel_order = bitget_swap_exchange.cancel_orders().await;
-    trace!(?bitget_cancel_order);
-}

standard/tests/bitget_swap_test.rs

@@ -1,255 +0,0 @@
-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 = "XTZ_USDT";
-
-// 测试获取Exchange实体
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_exchange() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_self_exchange = bitget_swap_exchange.get_self_exchange();
-    trace!(?bitget_get_self_exchange);
-}
-
-// 测试获取交易对信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_symbol() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_self_symbol = bitget_swap_exchange.get_self_symbol();
-    trace!(?bitget_get_self_symbol);
-}
-
-// 测试获取是否使用高速通道
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_is_colo() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_self_is_colo = bitget_swap_exchange.get_self_is_colo();
-    trace!(?bitget_get_self_is_colo);
-}
-
-// 测试获取登录params信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_params() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_self_params = bitget_swap_exchange.get_self_params();
-    trace!("bitget_get_self_params={:?}",bitget_get_self_params);
-}
-
-// 测试获取Market信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_market() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_self_market = bitget_swap_exchange.get_self_market();
-    trace!(?bitget_get_self_market);
-}
-
-// 测试获取请求时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_delays() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_request_delays = bitget_swap_exchange.get_request_delays();
-    trace!(?bitget_get_request_delays);
-}
-
-// 测试获取请求平均时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_avg_delay() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_request_avg_delay = bitget_swap_exchange.get_request_avg_delay();
-    trace!(?bitget_get_request_avg_delay);
-}
-
-// 测试获取最大请求时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_max_delay() {
-    global::log_utils::init_log_with_trace();
-
-    let bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_request_max_delay = bitget_swap_exchange.get_request_max_delay();
-    trace!(?bitget_get_request_max_delay);
-}
-
-// 测试获取服务器时间
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_server_time() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_server_time = bitget_swap_exchange.get_server_time().await;
-    trace!(?bitget_get_server_time);
-}
-
-// 测试获取账号信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_account() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_account = bitget_swap_exchange.get_account().await;
-    trace!(?bitget_get_account);
-}
-
-// 测试获取持仓信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_position() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_position = bitget_swap_exchange.get_position().await;
-    trace!(?bitget_get_position);
-}
-
-// 测试获取所有持仓信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_positions() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_positions = bitget_swap_exchange.get_positions().await;
-    trace!(?bitget_get_positions);
-}
-
-// 测试获取Ticker信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_ticker() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_ticker = bitget_swap_exchange.get_ticker().await;
-    trace!(?bitget_get_ticker);
-}
-
-// 测试获取Market信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_market() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_market = bitget_swap_exchange.get_market().await;
-    trace!(?bitget_get_market);
-}
-
-// 测试获取Kline信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_record() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_market = bitget_swap_exchange.get_record("3".to_string()).await;
-    trace!(?bitget_get_market);
-}
-
-// 测试获取Order详情信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_order_detail() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_order_detail = bitget_swap_exchange.get_order_detail("", "999993").await;
-    trace!(?bitget_get_order_detail);
-}
-
-// 测试获取Order列表信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_orders_list() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_get_orders_list = bitget_swap_exchange.get_orders_list("finished").await;
-    trace!(?bitget_get_orders_list);
-}
-
-// 测试下单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_take_order() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_take_order = bitget_swap_exchange.take_order("999994", "pd", dec!(0), dec!(7)).await;
-    trace!(?bitget_take_order);
-}
-
-// 测试撤销订单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_cancel_order() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_cancel_order = bitget_swap_exchange.cancel_order("", "999992").await;
-    trace!(?bitget_cancel_order);
-}
-
-// 测试批量撤销订单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_cancel_orders() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_cancel_orders = bitget_swap_exchange.cancel_orders().await;
-    trace!(?bitget_cancel_orders);
-}
-
-// 测试设置持仓模式
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_set_dual_mode() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_set_dual_mode = bitget_swap_exchange.set_dual_mode("usdt", true).await;
-    trace!(?bitget_set_dual_mode);
-}
-
-// 测试设置杠杆
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_set_dual_leverage() {
-    global::log_utils::init_log_with_trace();
-
-    let mut bitget_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BitgetSwap, SYMBOL).await;
-    let bitget_set_dual_leverage = bitget_swap_exchange.set_dual_leverage("1").await;
-    trace!(?bitget_set_dual_leverage);
-}

standard/tests/exchange_test.rs

@@ -1,715 +0,0 @@
-use std::collections::{BTreeMap};
-use std::io::{Error};
-use std::sync::Arc;
-use std::sync::atomic::AtomicBool;
-use rust_decimal::Decimal;
-use tokio::sync::mpsc::{channel, Receiver, Sender};
-use tokio::sync::Mutex;
-use tracing::{error, trace};
-// use exchanges::binance_spot_ws::{BinanceSpotLogin, BinanceSpotSubscribeType, BinanceSpotWs, BinanceSpotWsType};
-use exchanges::binance_swap_ws::{BinanceSwapLogin, BinanceSwapSubscribeType, BinanceSwapWs, BinanceSwapWsType};
-// use exchanges::kucoin_swap_ws::{KucoinSwapLogin, KucoinSwapSubscribeType, KucoinSwapWs, KucoinSwapWsType};
-// use exchanges::kucoin_spot_ws::{KucoinSpotLogin, KucoinSpotSubscribeType, KucoinSpotWs, KucoinSpotWsType};
-// use exchanges::gate_swap_ws::{GateSwapLogin, GateSwapSubscribeType, GateSwapWs, GateSwapWsType};
-// use exchanges::bitget_spot_ws::{BitgetSpotLogin, BitgetSpotSubscribeType, BitgetSpotWs, BitgetSpotWsType};
-// use exchanges::okx_swap_ws::{OkxSwapLogin, OkxSwapSubscribeType, OkxSwapWs, OkxSwapWsType};
-// use exchanges::htx_swap_ws::{HtxSwapLogin, HtxSwapSubscribeType, HtxSwapWs, HtxSwapWsType};
-use exchanges::response_base::ResponseData;
-use standard::exchange::{Exchange, ExchangeEnum};
-// use standard::{binance_spot_handle, Order, Platform, utils};
-use standard::{Order, Platform, utils};
-use standard::exchange_struct_handler::ExchangeStructHandler;
-// use standard::{kucoin_handle, Order, Platform, utils};
-// use standard::{kucoin_spot_handle, Order, Platform, utils};
-// use standard::{gate_swap_handle, handle_info, Order, Platform, utils};
-// use standard::{bitget_spot_handle, Order, Platform, utils};
-// use standard::{okx_handle, Order, Platform, utils};
-// use standard::{htx_swap_handle, handle_info, Order, Platform, utils};
-
-// 创建实体
-#[allow(dead_code)]
-pub async fn test_new_exchange(exchange: ExchangeEnum, symbol: &str) -> Box<dyn Platform> {
-    utils::proxy_handle(None);
-    let (order_sender, _order_receiver): (Sender<Order>, Receiver<Order>) = channel(1024);
-    let (error_sender, _error_receiver): (Sender<Error>, Receiver<Error>) = channel(1024);
-
-    let account_info = global::account_info::get_account_info("../test_account.toml");
-    match exchange {
-        ExchangeEnum::BinanceSwap => {
-            let mut params: BTreeMap<String, String> = BTreeMap::new();
-            let access_key = account_info.binance_access_key;
-            let secret_key = account_info.binance_secret_key;
-            params.insert("access_key".to_string(), access_key);
-            params.insert("secret_key".to_string(), secret_key);
-            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
-        }
-        // ExchangeEnum::BinanceSpot => {
-        //     let mut params: BTreeMap<String, String> = BTreeMap::new();
-        //     let access_key = account_info.binance_access_key;
-        //     let secret_key = account_info.binance_secret_key;
-        //     params.insert("access_key".to_string(), access_key);
-        //     params.insert("secret_key".to_string(), secret_key);
-        //     Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
-        // }
-        ExchangeEnum::GateSwap => {
-            let mut params: BTreeMap<String, String> = BTreeMap::new();
-            let access_key = account_info.gate_access_key;
-            let secret_key = account_info.gate_secret_key;
-            params.insert("access_key".to_string(), access_key);
-            params.insert("secret_key".to_string(), secret_key);
-            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
-        }
-        // ExchangeEnum::GateSpot => {
-        //     let mut params: BTreeMap<String, String> = BTreeMap::new();
-        //     let access_key = account_info.gate_access_key;
-        //     let secret_key = account_info.gate_secret_key;
-        //     params.insert("access_key".to_string(), access_key);
-        //     params.insert("secret_key".to_string(), secret_key);
-        //     Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
-        // }
-        // ExchangeEnum::KucoinSwap => {
-        //     let mut params: BTreeMap<String, String> = BTreeMap::new();
-        //     let access_key = account_info.kucoin_access_key;
-        //     let secret_key = account_info.kucoin_secret_key;
-        //     let pass_key = account_info.kucoin_pass;
-        //     params.insert("access_key".to_string(), access_key);
-        //     params.insert("secret_key".to_string(), secret_key);
-        //     params.insert("pass_key".to_string(), pass_key);
-        //     Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
-        // }
-        // ExchangeEnum::KucoinSpot => {
-        //     let mut params: BTreeMap<String, String> = BTreeMap::new();
-        //     let access_key = account_info.kucoin_access_key;
-        //     let secret_key = account_info.kucoin_secret_key;
-        //     let pass_key = account_info.kucoin_pass;
-        //     params.insert("access_key".to_string(), access_key);
-        //     params.insert("secret_key".to_string(), secret_key);
-        //     params.insert("pass_key".to_string(), pass_key);
-        //     Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
-        // }
-        // ExchangeEnum::OkxSwap => {
-        //     let mut params: BTreeMap<String, String> = BTreeMap::new();
-        //     let access_key = account_info.okx_access_key;
-        //     let secret_key = account_info.okx_secret_key;
-        //     let pass_key = account_info.okx_pass;
-        //     params.insert("access_key".to_string(), access_key);
-        //     params.insert("secret_key".to_string(), secret_key);
-        //     params.insert("pass_key".to_string(), pass_key);
-        //     Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
-        // }
-        // ExchangeEnum::BitgetSpot => {
-        //     let mut params: BTreeMap<String, String> = BTreeMap::new();
-        //     let access_key = account_info.bitget_access_key;
-        //     let secret_key = account_info.bitget_secret_key;
-        //     let pass_key = account_info.bitget_pass;
-        //     params.insert("access_key".to_string(), access_key);
-        //     params.insert("secret_key".to_string(), secret_key);
-        //     params.insert("pass_key".to_string(), pass_key);
-        //     Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
-        // }
-        ExchangeEnum::BitgetSwap => {
-            let mut params: BTreeMap<String, String> = BTreeMap::new();
-            let access_key = account_info.bitget_access_key;
-            let secret_key = account_info.bitget_secret_key;
-            let pass_key = account_info.bitget_pass;
-            params.insert("access_key".to_string(), access_key);
-            params.insert("secret_key".to_string(), secret_key);
-            params.insert("pass_key".to_string(), pass_key);
-            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
-        }
-        ExchangeEnum::BybitSwap => {
-            let mut params: BTreeMap<String, String> = BTreeMap::new();
-            let access_key = account_info.bybit_access_key;
-            let secret_key = account_info.bybit_secret_key;
-            params.insert("access_key".to_string(), access_key);
-            params.insert("secret_key".to_string(), secret_key);
-            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
-        }
-        // ExchangeEnum::HtxSwap => {
-        //     let mut params: BTreeMap<String, String> = BTreeMap::new();
-        //     let access_key = account_info.htx_access_key;
-        //     let secret_key = account_info.htx_secret_key;
-        //     let pass_key = account_info.htx_pass;
-        //     params.insert("access_key".to_string(), access_key);
-        //     params.insert("secret_key".to_string(), secret_key);
-        //     params.insert("pass_key".to_string(), pass_key);
-        //     Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
-        // }
-        _ => {
-            panic!("该交易所未实现！")
-        }
-    }
-}
-
-#[allow(dead_code)]
-pub async fn test_new_exchange_wss<T>(exchange: ExchangeEnum, symbol: &str, subscriber_type: T, mold: &str)
-where
-    Vec<BinanceSwapSubscribeType>: From<T>,
-{
-    utils::proxy_handle(None);
-    let account_info = global::account_info::get_account_info("../test_account.toml");
-    match exchange {
-        // ExchangeEnum::BinanceSpot => {
-        // let symbol_format = utils::format_symbol(symbol.to_string(), "").to_uppercase();
-        // trace!(symbol_format);
-        // let name = format!("binance_spot@{}", symbol.to_string().to_lowercase());
-        // let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-        // let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded::<ResponseData>();
-        // let write_tx_am = Arc::new(Mutex::new(write_tx));
-        // let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-        //
-        // let params = BinanceSpotLogin {
-        //     api_key: account_info.binance_access_key,
-        //     api_secret: account_info.binance_secret_key,
-        // };
-        // let mut exchange_wss;
-        // exchange_wss = BinanceSpotWs::new_label(name, false, Option::from(params), BinanceSpotWsType::PublicAndPrivate);
-        // exchange_wss.set_symbols(vec![symbol_format]);
-        // exchange_wss.set_subscribe(subscriber_type.into());
-        //
-        //
-        // let mold_arc = Arc::new(mold.to_string());
-        // //读取
-        // tokio::spawn(async move {
-        //     let mold_clone = Arc::clone(&mold_arc);
-        //     loop {
-        //         if let Some(data) = read_rx.next().await {
-        //             trace!("原始数据 data:{:?}",data);
-        //             match mold_clone.as_str() {
-        //                 "depth" => {
-        //                     if data.data != "" {
-        //                         let result = binance_spot_handle::handle_special_depth(data);
-        //                         trace!(?result)
-        //                     }
-        //                 }
-        //                 "ticker" => {
-        //                     if data.data != "" {
-        //                         let result = binance_spot_handle::handle_special_ticker(data);
-        //                         trace!(?result)
-        //                     }
-        //                 }
-        //                 _ => {
-        //                     error!("没有该命令！mode={}", mold_clone);
-        //                     panic!("没有该命令！mode={}", mold_clone)
-        //                 }
-        //             }
-        //         }
-        //     };
-        // });
-        //
-        // let t1 = tokio::spawn(async move {
-        //     //链接
-        //     let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        //     exchange_wss.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        // });
-        // try_join!(t1).unwrap();
-        // }
-        ExchangeEnum::BinanceSwap => {
-            let symbol_format = utils::format_symbol(symbol.to_string(), "").to_uppercase();
-            trace!(symbol_format);
-            let name = format!("binance_swap@{}", symbol.to_string().to_lowercase());
-            let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-            let write_tx_am = Arc::new(Mutex::new(write_tx));
-            let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-
-            let params = BinanceSwapLogin {
-                api_key: account_info.binance_access_key,
-                api_secret: account_info.binance_secret_key
-            };
-
-
-            let mut exchange_wss = if ["depth", "ticker","trade","record"].contains(&mold) {
-                BinanceSwapWs::new_label(name, false, Option::from(params), BinanceSwapWsType::Public).await
-            } else {
-                BinanceSwapWs::new_label(name, false, Option::from(params), BinanceSwapWsType::Private).await
-            };
-            exchange_wss.set_symbols(vec![symbol_format.clone()]);
-            exchange_wss.set_subscribe(subscriber_type.into());
-            let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-            let mold_clone = mold.to_string().clone();
-            let fun = move |data: ResponseData| {
-                let symbol_format_c = symbol_format.clone();
-                let mold_cc = mold_clone.clone();
-
-                async move {
-                    trace!("原始数据 data:{:?}",data);
-                    match mold_cc.as_str() {
-                        "depth" => {
-                            if data.data != "" {
-                                let result = ExchangeStructHandler::order_book_handle(ExchangeEnum::BinanceSwap, &data, &Decimal::ONE);
-                                trace!("-------------------------------");
-                                trace!(?result)
-                            }
-                        }
-                        "ticker" => {
-                            if data.data != "" {
-                                let result = ExchangeStructHandler::book_ticker_handle(ExchangeEnum::BinanceSwap, &data, &Decimal::ONE);
-                                trace!("-------------------------------");
-                                trace!(?result)
-                            }
-                        }
-                        "trade" => {
-                            if data.data != "" {
-                                let result = ExchangeStructHandler::trades_handle(ExchangeEnum::BinanceSwap, &data, &Decimal::ONE);
-                                trace!("-------------------------------");
-                                trace!(?result)
-                            }
-                        }
-                        "record" => {
-                            if data.data != "" {
-                                let result = ExchangeStructHandler::records_handle(ExchangeEnum::BinanceSwap, &data);
-                                trace!("-------------------------------");
-                                trace!(?result)
-                            }
-                        }
-                        "account" => {
-                            if data.data != "" {
-                                if data.channel != "ACCOUNT_UPDATE" { return; };
-                                let result = ExchangeStructHandler::account_info_handle(ExchangeEnum::BinanceSwap, &data, &symbol_format_c);
-                                trace!("-------------------------------");
-                                trace!(?result)
-                            }
-                        }
-                        "order" => {
-                            if data.data != "" {
-                                if data.channel != "ORDER_TRADE_UPDATE" { return; };
-                                let result = ExchangeStructHandler::order_handle(ExchangeEnum::BinanceSwap, &data, &Decimal::ONE);
-                                trace!("-------------------------------");
-                                trace!(?result)
-                            }
-                        }
-                        "position" => {
-                            if data.data != "" {
-                                if data.channel != "ACCOUNT_UPDATE" { return; };
-                                let result = ExchangeStructHandler::position_handle(ExchangeEnum::BinanceSwap, &data, &Decimal::ONE);
-                                trace!("-------------------------------");
-                                trace!(?result)
-                            }
-                        }
-                        _ => {
-                            error!("没有该命令！mode={}", mold_cc);
-                            panic!("没有该命令！mode={}", mold_cc)
-                        }
-                    };
-                }
-            };
-            exchange_wss.ws_connect_async(bool_v3_clone, fun, &write_tx_am, write_rx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        }
-        // ExchangeEnum::KucoinSwap => {
-        // let symbol_format = format!("{}M", utils::format_symbol(symbol.to_string(), ""));
-        // let symbol_back = utils::format_symbol(symbol.to_string(), "_");
-        //
-        // let name = format!("kucoin_swap@{}", symbol.to_string().to_lowercase());
-        // let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-        // let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded::<ResponseData>();
-        // let write_tx_am = Arc::new(Mutex::new(write_tx));
-        // let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-        //
-        // let params = KucoinSwapLogin {
-        //     access_key: account_info.kucoin_access_key,
-        //     secret_key: account_info.kucoin_secret_key,
-        //     pass_key: account_info.kucoin_pass,
-        // };
-        // let mut exchange_wss;
-        // if ["depth", "ticker"].contains(&mold) {
-        //     exchange_wss = KucoinSwapWs::new_label(name, false, Option::from(params), KucoinSwapWsType::Public).await;
-        // } else {
-        //     exchange_wss = KucoinSwapWs::new_label(name, false, Option::from(params), KucoinSwapWsType::Private).await;
-        // }
-        // exchange_wss.set_symbols(vec![symbol_format]);
-        // exchange_wss.set_subscribe(subscriber_type.into());
-        //
-        // let mold_arc = Arc::new(mold.to_string());
-        // tokio::spawn(async move {
-        //     let mold_clone = Arc::clone(&mold_arc);
-        //     loop {
-        //         if let Some(data) = read_rx.next().await {
-        //             trace!("原始数据 data:{:?}",data);
-        //             match mold_clone.as_str() {
-        //                 "depth" => {
-        //                     let result = kucoin_handle::handle_special_depth(data);
-        //                     trace!(?result)
-        //                 }
-        //                 "ticker" => {
-        //                     let result = kucoin_handle::handle_special_ticker(data);
-        //                     trace!(?result)
-        //                 }
-        //                 "account" => {
-        //                     let result = kucoin_handle::handle_account_info(data, symbol_back.clone());
-        //                     trace!(?result)
-        //                 }
-        //                 "position" => {
-        //                     let result = kucoin_handle::handle_position(data, dec!(1));
-        //                     trace!(?result)
-        //                 }
-        //                 "orders" => {
-        //                     let result = kucoin_handle::handle_order(data, dec!(0.001));
-        //                     trace!(?result)
-        //                 }
-        //                 _ => {
-        //                     error!("没有该命令！mode={}", mold_clone);
-        //                     panic!("没有该命令！mode={}", mold_clone)
-        //                 }
-        //             }
-        //         }
-        //     }
-        // });
-        //
-        // let t1 = tokio::spawn(async move {
-        //     //链接
-        //     let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        //     exchange_wss.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        // });
-        // try_join!(t1).unwrap();
-        // }
-        // ExchangeEnum::KucoinSpot => {
-        // let symbol_format = utils::format_symbol(symbol.to_string(), "-").to_uppercase();
-        // let symbol_back = utils::format_symbol(symbol.to_string(), "_");
-        // trace!(symbol_format);
-        // let name = format!("kucoin_spot@{}", symbol.to_string().to_lowercase());
-        // let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-        // let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded::<ResponseData>();
-        // let write_tx_am = Arc::new(Mutex::new(write_tx));
-        // let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-        //
-        // let params = KucoinSpotLogin {
-        //     access_key: account_info.kucoin_access_key,
-        //     secret_key: account_info.kucoin_secret_key,
-        //     pass_key: account_info.kucoin_pass,
-        // };
-        // let mut exchange_wss = if ["depth", "ticker"].contains(&mold) {
-        //     KucoinSpotWs::new_label(name, false, Option::from(params), KucoinSpotWsType::Public).await
-        // } else {
-        //     KucoinSpotWs::new_label(name, false, Option::from(params), KucoinSpotWsType::Private).await
-        // };
-        // exchange_wss.set_symbols(vec![symbol_format]);
-        // exchange_wss.set_subscribe(subscriber_type.into());
-        //
-        // let mold_arc = Arc::new(mold.to_string());
-        // tokio::spawn(async move {
-        //     let mold_clone = Arc::clone(&mold_arc);
-        //     loop {
-        //         if let Some(data) = read_rx.next().await {
-        //             trace!("原始数据 data:{:?}",data);
-        //             match mold_clone.as_str() {
-        //                 "depth" => {
-        //                     if data.data != "" {
-        //                         let result = kucoin_spot_handle::handle_special_depth(data);
-        //                         trace!(?result)
-        //                     }
-        //                 }
-        //                 "ticker" => {
-        //                     if data.data != "" {
-        //                         let result = kucoin_spot_handle::handle_special_ticker(data);
-        //                         trace!(?result)
-        //                     }
-        //                 }
-        //                 "account" => {
-        //                     if data.data != "" {
-        //                         let result = kucoin_spot_handle::handle_account_info(data, symbol_back.clone());
-        //                         trace!(?result)
-        //                     }
-        //                 }
-        //                 "orders" => {
-        //                     if data.data != "" {
-        //                         let result = kucoin_spot_handle::handle_order(data, dec!(1));
-        //                         trace!(?result)
-        //                     }
-        //                 }
-        //                 _ => {
-        //                     error!("没有该命令！mode={}", mold_clone);
-        //                     panic!("没有该命令！mode={}", mold_clone)
-        //                 }
-        //             }
-        //         }
-        //     }
-        // });
-        // let t1 = tokio::spawn(async move {
-        //     //链接
-        //     let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        //     exchange_wss.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        // });
-        // try_join!(t1).unwrap();
-        // }
-        ExchangeEnum::GateSwap => {
-            // let symbol_format = utils::format_symbol(symbol.to_string(), "_").to_uppercase();
-            // trace!(symbol_format);
-            // let name = format!("gate_swap@{}", symbol.to_string().to_lowercase());
-            // let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-            // let write_tx_am = Arc::new(Mutex::new(write_tx));
-            // let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-            //
-            // let params = GateSwapLogin {
-            //     api_key: account_info.gate_access_key,
-            //     secret: account_info.gate_secret_key,
-            // };
-            // let mut exchange_wss = GateSwapWs::new_label(name, false, Option::from(params), GateSwapWsType::PublicAndPrivate("usdt".to_string()));
-            // exchange_wss.set_symbols(vec![symbol_format.clone()]);
-            // exchange_wss.set_subscribe(subscriber_type.into());
-            //
-            // let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-            // let mold_clone = mold.to_string().clone();
-            // let fun = move |data: ResponseData| {
-            //     let symbol_format_c = symbol_format.clone();
-            //     let mold_cc = mold_clone.clone();
-            //
-            //     async move {
-            //         trace!("原始数据 data:{:?}",data);
-            //         match mold_cc.as_str() {
-            //             "depth" => {
-            //                 if data.data != "" {
-            //                     let result = handle_info::format_depth(ExchangeEnum::GateSwap, &data);
-            //                     trace!(?result)
-            //                 }
-            //             }
-            //             "ticker" => {
-            //                 if data.data != "" {
-            //                     let result = gate_swap_handle::handle_book_ticker(&data);
-            //                     trace!(?result)
-            //                 }
-            //             }
-            //             "account" => {
-            //                 if data.data != "" {
-            //                     let result = gate_swap_handle::handle_account_info(&data, &symbol_format_c);
-            //                     trace!(?result)
-            //                 }
-            //             }
-            //             "orders" => {
-            //                 if data.data != "" {
-            //                     let result = gate_swap_handle::handle_order(data, dec!(1));
-            //                     trace!(?result)
-            //                 }
-            //             }
-            //             _ => {
-            //                 error!("没有该命令！mode={}", mold_cc);
-            //                 panic!("没有该命令！mode={}", mold_cc)
-            //             }
-            //         };
-            //     }
-            // };
-            // exchange_wss.ws_connect_async(bool_v3_clone, fun, &write_tx_am, write_rx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        }
-        // ExchangeEnum::BitgetSpot => {
-        // let symbol_format = utils::format_symbol(symbol.to_string(), "-").to_uppercase();
-        // let symbol_back = utils::format_symbol(symbol.to_string(), "_");
-        // trace!(symbol_format);
-        // let name = format!("bitget_spot@{}", symbol.to_string().to_lowercase());
-        // let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-        // let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded::<ResponseData>();
-        // let write_tx_am = Arc::new(Mutex::new(write_tx));
-        // let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-        //
-        // let params = BitgetSpotLogin {
-        //     api_key: account_info.bitget_access_key,
-        //     secret_key: account_info.bitget_secret_key,
-        //     passphrase_key: account_info.bitget_pass,
-        // };
-        //
-        // let mut exchange_wss = if ["depth", "ticker"].contains(&mold) {
-        //     BitgetSpotWs::new_label(name, false, Option::from(params), BitgetSpotWsType::Public)
-        // } else {
-        //     BitgetSpotWs::new_label(name, false, Option::from(params), BitgetSpotWsType::Private)
-        // };
-        // exchange_wss.set_symbols(vec![symbol_format]);
-        // exchange_wss.set_subscribe(subscriber_type.into());
-        //
-        // let mold_arc = Arc::new(mold.to_string());
-        // //读取
-        // tokio::spawn(async move {
-        //     loop {
-        //         let mold_clone = Arc::clone(&mold_arc);
-        //         if let Some(data) = read_rx.next().await {
-        //             trace!("原始数据 data:{:?}",data);
-        //             match mold_clone.as_str() {
-        //                 "depth" => {
-        //                     if data.data != "" {
-        //                         let result = bitget_spot_handle::handle_special_depth(data);
-        //                         trace!(?result)
-        //                     }
-        //                 }
-        //                 "ticker" => {
-        //                     if data.data != "" {
-        //                         let result = bitget_spot_handle::handle_special_ticker(data);
-        //                         trace!(?result)
-        //                     }
-        //                 }
-        //                 "account" => {
-        //                     if data.data != "" {
-        //                         let result = bitget_spot_handle::handle_account_info(data, symbol_back.clone());
-        //                         trace!(?result)
-        //                     }
-        //                 }
-        //                 "orders" => {
-        //                     if data.data != "" {
-        //                         let result = bitget_spot_handle::handle_order(data, dec!(1));
-        //                         trace!(?result)
-        //                     }
-        //                 }
-        //                 _ => {
-        //                     error!("没有该命令！mode={}", mold_clone);
-        //                     panic!("没有该命令！mode={}", mold_clone)
-        //                 }
-        //             }
-        //         }
-        //     }
-        // });
-        // let t1 = tokio::spawn(async move {
-        //     //链接
-        //     let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        //     exchange_wss.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        // });
-        // try_join!(t1).unwrap();
-        // }
-        // ExchangeEnum::OkxSwap => {
-        //     let symbol_format = utils::format_symbol(symbol.to_string(), "-").to_uppercase();
-        //     trace!(symbol_format);
-        //     let name = format!("okx_swap@{}", symbol.to_string().to_lowercase());
-        //     let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-        //     let (read_tx, mut read_rx) = futures_channel::mpsc::unbounded::<ResponseData>();
-        //     let write_tx_am = Arc::new(Mutex::new(write_tx));
-        //     let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-        //
-        //     let params = OkxSwapLogin {
-        //         api_key: account_info.okx_access_key,
-        //         secret_key: account_info.okx_secret_key,
-        //         passphrase: account_info.okx_pass,
-        //     };
-        //
-        //     let mut exchange_wss = if ["depth", "ticker"].contains(&mold) {
-        //         OkxSwapWs::new_label(name, false, Option::from(params), OkxSwapWsType::Public)
-        //     } else if ["account", "orders", "position"].contains(&mold) {
-        //         OkxSwapWs::new_label(name, false, Option::from(params), OkxSwapWsType::Private)
-        //     } else {
-        //         OkxSwapWs::new_label(name, false, Option::from(params), OkxSwapWsType::Business)
-        //     };
-        //
-        //     exchange_wss.set_symbols(vec![symbol_format.clone()]);
-        //     exchange_wss.set_subscribe(subscriber_type.into());
-        //
-        //     let mold_arc = Arc::new(mold.to_string());
-        //     tokio::spawn(async move {
-        //         let mold_clone = Arc::clone(&mold_arc);
-        //         loop {
-        //             if let Some(data) = read_rx.next().await {
-        //                 trace!("原始数据 data:{:?}",data);
-        //                 match mold_clone.as_str() {
-        //                     "depth" => {
-        //                         if data.data != "" {
-        //                             let result = okx_handle::handle_special_depth(data);
-        //                             trace!(?result)
-        //                         }
-        //                     }
-        //                     "ticker" => {
-        //                         if data.data != "" {
-        //                             let result = okx_handle::handle_special_ticker(data);
-        //                             trace!(?result)
-        //                         }
-        //                     }
-        //                     "account" => {
-        //                         if data.data != "" {
-        //                             let result = okx_handle::handle_account_info(data, symbol_format.clone());
-        //                             trace!(?result)
-        //                         }
-        //                     }
-        //                     "position" => {
-        //                         if data.data != "" {
-        //                             let result = okx_handle::handle_position(data, dec!(10));
-        //                             trace!(?result)
-        //                         }
-        //                     }
-        //                     "orders" => {
-        //                         if data.data != "" {
-        //                             let result = okx_handle::handle_order(data, dec!(10));
-        //                             trace!(?result)
-        //                         }
-        //                     }
-        //                     _ => {
-        //                         error!("没有该命令！mode={}", mold_clone);
-        //                         panic!("没有该命令！mode={}", mold_clone)
-        //                     }
-        //                 }
-        //             }
-        //         }
-        //     });
-        //
-        //     let t1 = tokio::spawn(async move {
-        //         //链接
-        //         let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        //         exchange_wss.ws_connect_async(bool_v3_clone, &write_tx_am, write_rx, read_tx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        //     });
-        //     try_join!(t1).unwrap();
-        // }
-        // ExchangeEnum::HtxSwap => {
-        //     let symbol_format = utils::format_symbol(symbol.to_string(), "-").to_uppercase();
-        //     trace!(symbol_format);
-        //     let name = format!("htx_swap@{}", symbol.to_string().to_lowercase());
-        //     let (write_tx, write_rx) = futures_channel::mpsc::unbounded();
-        //     let write_tx_am = Arc::new(Mutex::new(write_tx));
-        //     let is_shutdown_arc = Arc::new(AtomicBool::new(true));
-        //
-        //     let params = HtxSwapLogin {
-        //         api_key: account_info.htx_access_key,
-        //         secret: account_info.htx_secret_key,
-        //     };
-        //
-        //     let htx_wss_type = match mold.to_string().clone().as_str() {
-        //         "depth" => HtxSwapWsType::Public,
-        //         _ => HtxSwapWsType::Private
-        //     };
-        //
-        //     let mut exchange_wss = HtxSwapWs::new_label(name, Option::from(params), htx_wss_type);
-        //     exchange_wss.set_symbols(vec![symbol_format.clone()]);
-        //     exchange_wss.set_subscribe(subscriber_type.into());
-        //     let bool_v3_clone = Arc::clone(&is_shutdown_arc);
-        //     let mold_clone = mold.to_string().clone();
-        //     let fun = move |data: ResponseData| {
-        //         let symbol_format_c = symbol_format.clone();
-        //         let mold_cc = mold_clone.clone();
-        //
-        //         async move {
-        //             trace!("原始数据 data:{:?}",data);
-        //             match mold_cc.as_str() {
-        //                 "depth" => {
-        //                     if data.data != "" {
-        //                         let result = handle_info::format_depth(ExchangeEnum::HtxSwap, &data);
-        //                         trace!("-------------------------------");
-        //                         trace!(?result)
-        //                     }
-        //                 }
-        //                 "position" => {
-        //                     if data.data != "" {
-        //                         let result = htx_swap_handle::handle_position(&data, &dec!(10));
-        //                         trace!("-------------------------------");
-        //                         trace!(?result)
-        //                     }
-        //                 }
-        //                 "account" => {
-        //                     if data.data != "" {
-        //                         let result = htx_swap_handle::handle_account_info(&data, &symbol_format_c);
-        //                         trace!("-------------------------------");
-        //                         trace!(?result)
-        //                     }
-        //                 }
-        //                 "orders" => {
-        //                     println!("{:?}", data);
-        //                     if data.data != "" {
-        //                         let result = htx_swap_handle::handle_order(data, dec!(10));
-        //                         trace!("-------------------------------");
-        //                         trace!(?result)
-        //                     }
-        //                 }
-        //                 _ => {
-        //                     error!("没有该命令！mode={}", mold_cc);
-        //                     panic!("没有该命令！mode={}", mold_cc)
-        //                 }
-        //             };
-        //         }
-        //     };
-        //     exchange_wss.ws_connect_async(bool_v3_clone, fun, &write_tx_am, write_rx).await.expect("链接失败(内部一个心跳线程应该已经关闭了)");
-        // }
-        _ => {
-            error!("该交易所不支持！test_new_exchange_wss：{:?}", exchange);
-            panic!("该交易所不支持！test_new_exchange_wss：{:?}", exchange)
-        }
-    }
-}

standard/tests/gate_handle_test.rs

@@ -1,92 +0,0 @@
-mod exchange_test;
-
-use std::collections::BTreeMap;
-use tracing::{instrument, trace};
-use exchanges::gate_swap_rest::GateSwapRest;
-use exchanges::gate_swap_ws::GateSwapSubscribeType;
-use standard::exchange::ExchangeEnum;
-use crate::exchange_test::{test_new_exchange_wss};
-
-const SYMBOL: &str = "BTC_USDT";
-
-async fn get_user_id() -> String {
-    let account_info = global::account_info::get_account_info("../test_account.toml");
-    let mut params: BTreeMap<String, String> = BTreeMap::new();
-    let access_key = account_info.gate_access_key;
-    let secret_key = account_info.gate_secret_key;
-    params.insert("access_key".to_string(), access_key);
-    params.insert("secret_key".to_string(), secret_key);
-
-    let mut gate_request = GateSwapRest::new(false, params);
-    let res_data = gate_request.wallet_fee().await;
-    if res_data.code == "200" {
-        let res_data_json: serde_json::Value = serde_json::from_str(&res_data.data).unwrap();
-        res_data_json["user_id"].to_string()
-    } else {
-        "".to_string()
-    }
-}
-
-// 测试订阅深度订阅
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_depth() {
-    global::log_utils::init_log_with_trace();
-
-    let gate_subscribe_type = vec![
-        GateSwapSubscribeType::PuFuturesOrderBook
-    ];
-    test_new_exchange_wss(ExchangeEnum::GateSwap, SYMBOL, gate_subscribe_type, "depth").await;
-}
-
-// 测试订阅Ticker信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_ticker() {
-    global::log_utils::init_log_with_trace();
-
-    let gate_subscribe_type = vec![
-        GateSwapSubscribeType::PuFuturesOrderBook
-    ];
-    test_new_exchange_wss(ExchangeEnum::GateSwap, SYMBOL, gate_subscribe_type, "ticker").await;
-}
-
-// 测试订阅Account信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_account() {
-    global::log_utils::init_log_with_trace();
-
-    let user_id = get_user_id().await;
-    trace!(?user_id);
-    let gate_subscribe_type = vec![
-        GateSwapSubscribeType::PrFuturesBalances(user_id)
-    ];
-    test_new_exchange_wss(ExchangeEnum::GateSwap, SYMBOL, gate_subscribe_type, "account").await;
-}
-
-// 测试订阅Position信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_position() {
-    global::log_utils::init_log_with_trace();
-
-    let user_id = get_user_id().await;
-    let gate_subscribe_type = vec![
-        GateSwapSubscribeType::PrFuturesPositions(user_id)
-    ];
-    test_new_exchange_wss(ExchangeEnum::GateSwap, SYMBOL, gate_subscribe_type, "position").await;
-}
-
-// 测试订阅Orders信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_orders() {
-    global::log_utils::init_log_with_trace();
-
-    let user_id = get_user_id().await;
-    let gate_subscribe_type = vec![
-        GateSwapSubscribeType::PrFuturesOrders(user_id)
-    ];
-    test_new_exchange_wss(ExchangeEnum::GateSwap, SYMBOL, gate_subscribe_type, "orders").await;
-}

standard/tests/gate_swap_test.rs

@@ -1,279 +0,0 @@
-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 gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_self_exchange = gate_swap_exchange.get_self_exchange();
-    trace!(?gate_get_self_exchange);
-}
-
-// 测试获取交易对信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_symbol() {
-    global::log_utils::init_log_with_trace();
-
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_self_symbol = gate_swap_exchange.get_self_symbol();
-    trace!(?gate_get_self_symbol);
-}
-
-// 测试获取是否使用高速通道
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_is_colo() {
-    global::log_utils::init_log_with_trace();
-
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_self_is_colo = gate_swap_exchange.get_self_is_colo();
-    trace!(?gate_get_self_is_colo);
-}
-
-// 测试获取登录params信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_params() {
-    global::log_utils::init_log_with_trace();
-
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_self_params = gate_swap_exchange.get_self_params();
-    trace!("gate_get_self_params={:?}",gate_get_self_params);
-}
-
-// 测试获取Market信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_market() {
-    global::log_utils::init_log_with_trace();
-
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_self_market = gate_swap_exchange.get_self_market();
-    trace!(?gate_get_self_market);
-}
-
-// 测试获取请求时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_delays() {
-    global::log_utils::init_log_with_trace();
-
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_request_delays = gate_swap_exchange.get_request_delays();
-    trace!(?gate_get_request_delays);
-}
-
-// 测试获取请求平均时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_avg_delay() {
-    global::log_utils::init_log_with_trace();
-
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_request_avg_delay = gate_swap_exchange.get_request_avg_delay();
-    trace!(?gate_get_request_avg_delay);
-}
-
-// 测试获取最大请求时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_max_delay() {
-    global::log_utils::init_log_with_trace();
-
-    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_request_max_delay = gate_swap_exchange.get_request_max_delay();
-    trace!(?gate_get_request_max_delay);
-}
-
-// 测试获取服务器时间
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_server_time() {
-    global::log_utils::init_log_with_trace();
-
-    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_server_time = gate_swap_exchange.get_server_time().await;
-    trace!(?gate_get_server_time);
-}
-
-// 测试获取账号信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_account() {
-    global::log_utils::init_log_with_trace();
-
-    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_account = gate_swap_exchange.get_account().await;
-    trace!(?gate_get_account);
-}
-
-// 测试获取持仓信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_position() {
-    global::log_utils::init_log_with_trace();
-
-    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_position = gate_swap_exchange.get_position().await;
-    trace!(?gate_get_position);
-}
-
-// 测试获取所有持仓信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_positions() {
-    global::log_utils::init_log_with_trace();
-
-    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_positions = gate_swap_exchange.get_positions().await;
-    trace!(?gate_get_positions);
-}
-
-// 测试获取Ticker信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_ticker() {
-    global::log_utils::init_log_with_trace();
-
-    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_ticker = gate_swap_exchange.get_ticker().await;
-    trace!(?gate_get_ticker);
-}
-
-// 测试获取Market信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_market() {
-    global::log_utils::init_log_with_trace();
-
-    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_market = gate_swap_exchange.get_market().await;
-    trace!(?gate_get_market);
-}
-
-// 测试获取Order详情信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_order_detail() {
-    global::log_utils::init_log_with_trace();
-
-    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_order_detail = gate_swap_exchange.get_order_detail("", "999999").await;
-    trace!(?gate_get_order_detail);
-}
-
-// 测试获取Order列表信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_orders_list() {
-    global::log_utils::init_log_with_trace();
-
-    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_get_orders_list = gate_swap_exchange.get_orders_list("finished").await;
-    trace!(?gate_get_orders_list);
-}
-
-// 测试下单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_take_order() {
-    global::log_utils::init_log_with_trace();
-
-    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_take_order = gate_swap_exchange.take_order("999999", "kk", dec!(0.27), dec!(100)).await;
-    trace!(?gate_take_order);
-}
-
-// 测试撤销订单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_cancel_order() {
-    global::log_utils::init_log_with_trace();
-
-    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_cancel_order = gate_swap_exchange.cancel_order("", "999999").await;
-    trace!(?gate_cancel_order);
-}
-
-// 测试批量撤销订单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_cancel_orders() {
-    global::log_utils::init_log_with_trace();
-
-    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_cancel_orders = gate_swap_exchange.cancel_orders().await;
-    trace!(?gate_cancel_orders);
-}
-
-// 测试设置持仓模式
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_set_dual_mode() {
-    global::log_utils::init_log_with_trace();
-
-    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_set_dual_mode = gate_swap_exchange.set_dual_mode("usdt", true).await;
-    trace!(?gate_set_dual_mode);
-}
-
-// 测试设置杠杆
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_set_dual_leverage() {
-    global::log_utils::init_log_with_trace();
-
-    let mut gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap, SYMBOL).await;
-    let gate_set_dual_leverage = gate_swap_exchange.set_dual_leverage("10").await;
-    trace!(?gate_set_dual_leverage);
-}
-
-// 测试指令下单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_command_order() {
-    global::log_utils::init_log_with_trace();
-    utils::proxy_handle(None);
-
-    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("gate_access_key").unwrap_or("".to_string());
-    let secret_key = env::var("gate_secret_key").unwrap_or("".to_string());
-    params.insert("access_key".to_string(), access_key);
-    params.insert("secret_key".to_string(), secret_key);
-
-    let mut gate_swap_exchange: Box<dyn Platform> = Exchange::new(ExchangeEnum::GateSwap, 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(), "".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(), "".to_string()]);
-    gate_swap_exchange.command_order(command, Default::default()).await;
-
-    loop {
-        if let Ok(order) = order_receiver.try_recv() {
-            trace!(?order);
-        }
-        if let Ok(error) = error_receiver.try_recv() {
-            trace!(?error);
-        }
-    }
-}

standard/tests/htx_handle_test.rs

@@ -1,56 +0,0 @@
-mod exchange_test;
-
-use tracing::{instrument};
-use exchanges::htx_swap_ws::HtxSwapSubscribeType;
-use standard::exchange::ExchangeEnum;
-use crate::exchange_test::{test_new_exchange_wss};
-
-const SYMBOL: &str = "USTC_USDT";
-
-// 测试订阅深度订阅
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_depth() {
-    global::log_utils::init_log_with_trace();
-
-    let htx_subscribe_type = vec![
-        HtxSwapSubscribeType::PuFuturesDepth
-    ];
-    test_new_exchange_wss(ExchangeEnum::HtxSwap, SYMBOL, htx_subscribe_type, "depth").await;
-}
-
-// 测试订阅Account信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_account() {
-    global::log_utils::init_log_with_trace();
-
-    let htx_subscribe_type = vec![
-        HtxSwapSubscribeType::PrFuturesBalances
-    ];
-    test_new_exchange_wss(ExchangeEnum::HtxSwap, SYMBOL, htx_subscribe_type, "account").await;
-}
-
-// 测试订阅Position信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_position() {
-    global::log_utils::init_log_with_trace();
-
-    let htx_subscribe_type = vec![
-        HtxSwapSubscribeType::PrFuturesPositions
-    ];
-    test_new_exchange_wss(ExchangeEnum::HtxSwap, SYMBOL, htx_subscribe_type, "position").await;
-}
-
-// 测试订阅Orders信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_orders() {
-    global::log_utils::init_log_with_trace();
-
-    let htx_subscribe_type = vec![
-        HtxSwapSubscribeType::PrFuturesOrders
-    ];
-    test_new_exchange_wss(ExchangeEnum::HtxSwap, SYMBOL, htx_subscribe_type, "orders").await;
-}

standard/tests/htx_swap_test.rs

@@ -1,282 +0,0 @@
-mod exchange_test;
-
-use std::collections::BTreeMap;
-use std::env;
-use std::io::Error;
-use chrono::Utc;
-use rust_decimal_macros::dec;
-use tokio::sync::mpsc;
-use tokio::time::Instant;
-use tracing::{instrument, trace};
-use global::trace_stack::TraceStack;
-use standard::exchange::{Exchange, ExchangeEnum};
-use standard::{Order, OrderCommand, Platform, utils};
-use crate::exchange_test::{test_new_exchange};
-
-const SYMBOL: &str = "USTC_USDT";
-
-// 测试获取Exchange实体
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_exchange() {
-    global::log_utils::init_log_with_trace();
-
-    let htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_self_exchange = htx_swap_exchange.get_self_exchange();
-    trace!(?htx_get_self_exchange);
-}
-
-// 测试获取交易对信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_symbol() {
-    global::log_utils::init_log_with_trace();
-
-    let htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_self_symbol = htx_swap_exchange.get_self_symbol();
-    trace!(?htx_get_self_symbol);
-}
-
-// 测试获取是否使用高速通道
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_is_colo() {
-    global::log_utils::init_log_with_trace();
-
-    let htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_self_is_colo = htx_swap_exchange.get_self_is_colo();
-    trace!(?htx_get_self_is_colo);
-}
-
-// 测试获取登录params信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_params() {
-    global::log_utils::init_log_with_trace();
-
-    let htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_self_params = htx_swap_exchange.get_self_params();
-    trace!("htx_get_self_params={:?}",htx_get_self_params);
-}
-
-// 测试获取Market信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_market() {
-    global::log_utils::init_log_with_trace();
-
-    let htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_self_market = htx_swap_exchange.get_self_market();
-    trace!(?htx_get_self_market);
-}
-
-// 测试获取请求时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_delays() {
-    global::log_utils::init_log_with_trace();
-
-    let htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_request_delays = htx_swap_exchange.get_request_delays();
-    trace!(?htx_get_request_delays);
-}
-
-// 测试获取请求平均时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_avg_delay() {
-    global::log_utils::init_log_with_trace();
-
-    let htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_request_avg_delay = htx_swap_exchange.get_request_avg_delay();
-    trace!(?htx_get_request_avg_delay);
-}
-
-// 测试获取最大请求时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_max_delay() {
-    global::log_utils::init_log_with_trace();
-
-    let htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_request_max_delay = htx_swap_exchange.get_request_max_delay();
-    trace!(?htx_get_request_max_delay);
-}
-
-// 测试获取服务器时间
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_server_time() {
-    global::log_utils::init_log_with_trace();
-
-    let mut htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_server_time = htx_swap_exchange.get_server_time().await;
-    trace!(?htx_get_server_time);
-}
-
-// 测试获取账号信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_account() {
-    global::log_utils::init_log_with_trace();
-
-    let mut htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_account = htx_swap_exchange.get_account().await;
-    trace!(?htx_get_account);
-}
-
-// 测试获取持仓信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_position() {
-    global::log_utils::init_log_with_trace();
-
-    let mut htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_position = htx_swap_exchange.get_position().await;
-    trace!(?htx_get_position);
-}
-
-// 测试获取所有持仓信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_positions() {
-    global::log_utils::init_log_with_trace();
-
-    let mut htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_positions = htx_swap_exchange.get_positions().await;
-    trace!(?htx_get_positions);
-}
-
-// 测试获取Ticker信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_ticker() {
-    global::log_utils::init_log_with_trace();
-
-    let mut htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_ticker = htx_swap_exchange.get_ticker().await;
-    trace!(?htx_get_ticker);
-}
-
-// 测试获取Market信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_market() {
-    global::log_utils::init_log_with_trace();
-
-    let mut htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_market = htx_swap_exchange.get_market().await;
-    trace!(?htx_get_market);
-}
-
-// 测试获取Order详情信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_order_detail() {
-    global::log_utils::init_log_with_trace();
-
-    let mut htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_order_detail = htx_swap_exchange.get_order_detail("1234925996822429696", "9999992").await;
-    trace!(?htx_get_order_detail);
-}
-
-// 测试获取Order列表信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_orders_list() {
-    global::log_utils::init_log_with_trace();
-
-    let mut htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_get_orders_list = htx_swap_exchange.get_orders_list("finished").await;
-    trace!(?htx_get_orders_list);
-}
-
-// 测试下单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_take_order() {
-    global::log_utils::init_log_with_trace();
-
-    let mut htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_take_order = htx_swap_exchange.take_order("999999914", "kd", dec!(0.02320), dec!(20)).await;
-    trace!(?htx_take_order);
-}
-
-// 测试撤销订单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_cancel_order() {
-    global::log_utils::init_log_with_trace();
-
-    let mut htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_cancel_order = htx_swap_exchange.cancel_order("", "999999900").await;
-    trace!(?htx_cancel_order);
-}
-
-// 测试批量撤销订单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_cancel_orders() {
-    global::log_utils::init_log_with_trace();
-
-    let mut htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_cancel_orders = htx_swap_exchange.cancel_orders_all().await;
-    trace!(?htx_cancel_orders);
-}
-
-// 测试设置持仓模式
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_set_dual_mode() {
-    global::log_utils::init_log_with_trace();
-
-    let mut htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_set_dual_mode = htx_swap_exchange.set_dual_mode("usdt", true).await;
-    trace!(?htx_set_dual_mode);
-}
-
-// 测试设置杠杆
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_set_dual_leverage() {
-    global::log_utils::init_log_with_trace();
-
-    let mut htx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::HtxSwap, SYMBOL).await;
-    let htx_set_dual_leverage = htx_swap_exchange.set_dual_leverage("10").await;
-    trace!(?htx_set_dual_leverage);
-}
-
-// 测试指令下单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_command_order() {
-    global::log_utils::init_log_with_trace();
-    utils::proxy_handle(None);
-
-    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("htx_access_key").unwrap_or("".to_string());
-    let secret_key = env::var("htx_secret_key").unwrap_or("".to_string());
-    params.insert("access_key".to_string(), access_key);
-    params.insert("secret_key".to_string(), secret_key);
-
-    let mut htx_swap_exchange: Box<dyn Platform> = Exchange::new(ExchangeEnum::HtxSwap, 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(), "".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(), "".to_string()]);
-    htx_swap_exchange.command_order(&mut command, &TraceStack::new(Utc::now().timestamp_micros(), Instant::now())).await;
-
-    loop {
-        if let Ok(order) = order_receiver.try_recv() {
-            trace!(?order);
-        }
-        if let Ok(error) = error_receiver.try_recv() {
-            trace!(?error);
-        }
-    }
-}

standard/tests/kucoin_handle_test.rs

@@ -1,68 +0,0 @@
-mod exchange_test;
-
-use tracing::{instrument};
-use exchanges::kucoin_swap_ws::{KucoinSwapSubscribeType};
-use standard::exchange::ExchangeEnum;
-use crate::exchange_test::test_new_exchange_wss;
-
-const SYMBOL: &str = "BLZ_USDT";
-
-// 测试订阅深度订阅
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_depth() {
-    global::log_utils::init_log_with_trace();
-
-    let kucoin_subscribe_type = vec![
-        KucoinSwapSubscribeType::PuContractMarketLevel2Depth50
-    ];
-    test_new_exchange_wss(ExchangeEnum::KucoinSwap, SYMBOL, kucoin_subscribe_type, "depth").await;
-}
-
-// 测试订阅Ticker信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_ticker() {
-    global::log_utils::init_log_with_trace();
-
-    let kucoin_subscribe_type = vec![
-        KucoinSwapSubscribeType::PuContractMarkettickerV2
-    ];
-    test_new_exchange_wss(ExchangeEnum::KucoinSwap, SYMBOL, kucoin_subscribe_type, "ticker").await;
-}
-
-// 测试订阅Account信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_account() {
-    global::log_utils::init_log_with_trace();
-
-    let kucoin_subscribe_type = vec![
-        KucoinSwapSubscribeType::PrContractAccountWallet
-    ];
-    test_new_exchange_wss(ExchangeEnum::KucoinSwap, SYMBOL, kucoin_subscribe_type, "account").await;
-}
-
-// 测试订阅Position信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_position() {
-    global::log_utils::init_log_with_trace();
-
-    let kucoin_subscribe_type = vec![
-        KucoinSwapSubscribeType::PrContractPosition
-    ];
-    test_new_exchange_wss(ExchangeEnum::KucoinSwap, SYMBOL, kucoin_subscribe_type, "position").await;
-}
-
-// 测试订阅Orders信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_orders() {
-    global::log_utils::init_log_with_trace();
-
-    let kucoin_subscribe_type = vec![
-        KucoinSwapSubscribeType::PrContractMarketTradeOrders
-    ];
-    test_new_exchange_wss(ExchangeEnum::KucoinSwap, SYMBOL, kucoin_subscribe_type, "orders").await;
-}

standard/tests/kucoin_spot_handle_test.rs

@@ -1,56 +0,0 @@
-mod exchange_test;
-
-use tracing::{instrument};
-use exchanges::kucoin_spot_ws::{KucoinSpotSubscribeType};
-use standard::exchange::ExchangeEnum;
-use crate::exchange_test::test_new_exchange_wss;
-
-const SYMBOL: &str = "BTC_USDT";
-
-// 测试订阅深度订阅
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_depth() {
-    global::log_utils::init_log_with_trace();
-
-    let kucoin_subscribe_type = vec![
-        KucoinSpotSubscribeType::PuSpotMarketLevel2Depth50
-    ];
-    test_new_exchange_wss(ExchangeEnum::KucoinSpot, SYMBOL, kucoin_subscribe_type, "depth").await;
-}
-
-// 测试订阅Ticker信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_ticker() {
-    global::log_utils::init_log_with_trace();
-
-    let kucoin_subscribe_type = vec![
-        KucoinSpotSubscribeType::PuMarketTicker
-    ];
-    test_new_exchange_wss(ExchangeEnum::KucoinSpot, SYMBOL, kucoin_subscribe_type, "ticker").await;
-}
-
-// 测试订阅Account信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_account() {
-    global::log_utils::init_log_with_trace();
-
-    let kucoin_subscribe_type = vec![
-        KucoinSpotSubscribeType::PrAccountBalance
-    ];
-    test_new_exchange_wss(ExchangeEnum::KucoinSpot, SYMBOL, kucoin_subscribe_type, "account").await;
-}
-
-// 测试订阅Orders信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_orders() {
-    global::log_utils::init_log_with_trace();
-
-    let kucoin_subscribe_type = vec![
-        KucoinSpotSubscribeType::PrSpotMarketTradeOrders
-    ];
-    test_new_exchange_wss(ExchangeEnum::KucoinSpot, SYMBOL, kucoin_subscribe_type, "orders").await;
-}

standard/tests/kucoin_spot_test.rs

@@ -1,145 +0,0 @@
-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_spot_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSpot, SYMBOL).await;
-    let kucoin_get_self_exchange = kucoin_spot_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_spot_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSpot, SYMBOL).await;
-    let kucoin_get_self_symbol = kucoin_spot_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_spot_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSpot, SYMBOL).await;
-    let kucoin_get_self_is_colo = kucoin_spot_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_spot_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSpot, SYMBOL).await;
-    let kucoin_get_self_params = kucoin_spot_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_spot_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSpot, SYMBOL).await;
-    let kucoin_get_self_market = kucoin_spot_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_spot_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSpot, SYMBOL).await;
-    let kucoin_get_request_delays = kucoin_spot_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_spot_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSpot, SYMBOL).await;
-    let kucoin_get_request_avg_delay = kucoin_spot_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_spot_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSpot, SYMBOL).await;
-    let kucoin_get_request_max_delay = kucoin_spot_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_spot_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSpot, SYMBOL).await;
-    let kucoin_get_server_time = kucoin_spot_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_spot_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSpot, SYMBOL).await;
-    let kucoin_get_account = kucoin_spot_exchange.get_account().await;
-    trace!(?kucoin_get_account);
-}
-
-// 测试获取Ticker信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_ticker() {
-    global::log_utils::init_log_with_trace();
-
-    let mut kucoin_spot_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSpot, SYMBOL).await;
-    let kucoin_get_ticker = kucoin_spot_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_spot_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSpot, SYMBOL).await;
-    let kucoin_get_market = kucoin_spot_exchange.get_market().await;
-    trace!(?kucoin_get_market);
-}

standard/tests/kucoin_swap_test.rs

@@ -1,271 +0,0 @@
-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 = "BTC_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), 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("108721685804371970", "").await;
-    trace!(?kucoin_cancel_order);
-}
-
-// 测试撤销订单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_cancel_orders() {
-    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_orders = kucoin_swap_exchange.cancel_orders().await;
-    trace!(?kucoin_cancel_orders);
-}
-
-
-// 测试设置自动追加保证金
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_set_auto_deposit_status() {
-    global::log_utils::init_log_with_trace();
-
-    let mut kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap, SYMBOL).await;
-    let kucoin_set_auto_deposit_status = kucoin_swap_exchange.set_auto_deposit_status(true).await;
-    trace!(?kucoin_set_auto_deposit_status);
-}
-
-// 测试指令下单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_command_order() {
-    global::log_utils::init_log_with_trace();
-    utils::proxy_handle(None);
-
-    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, Default::default()).await;
-
-
-    loop {
-        if let Ok(order) = order_receiver.try_recv() {
-            trace!(?order);
-        }
-        if let Ok(error) = error_receiver.try_recv() {
-            trace!(?error);
-        }
-    }
-}

standard/tests/okx_handle_test.rs

@@ -1,68 +0,0 @@
-mod exchange_test;
-
-use tracing::{instrument};
-use exchanges::okx_swap_ws::OkxSwapSubscribeType;
-use standard::exchange::ExchangeEnum;
-use crate::exchange_test::test_new_exchange_wss;
-
-const SYMBOL: &str = "BTC_USDT";
-
-// 测试订阅深度订阅
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_depth() {
-    global::log_utils::init_log_with_trace();
-
-    let okx_subscribe_type = vec![
-        OkxSwapSubscribeType::PuBooks5
-    ];
-    test_new_exchange_wss(ExchangeEnum::OkxSwap, SYMBOL, okx_subscribe_type, "depth").await;
-}
-
-// 测试订阅Ticker信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_ticker() {
-    global::log_utils::init_log_with_trace();
-
-    let okx_subscribe_type = vec![
-        OkxSwapSubscribeType::PuBooks5
-    ];
-    test_new_exchange_wss(ExchangeEnum::OkxSwap, SYMBOL, okx_subscribe_type, "ticker").await;
-}
-
-// 测试订阅Account信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_account() {
-    global::log_utils::init_log_with_trace();
-
-    let okx_subscribe_type = vec![
-        OkxSwapSubscribeType::PrAccount("USDT".to_string())
-    ];
-    test_new_exchange_wss(ExchangeEnum::OkxSwap, SYMBOL, okx_subscribe_type, "account").await;
-}
-
-// 测试订阅Position信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_position() {
-    global::log_utils::init_log_with_trace();
-
-    let okx_subscribe_type = vec![
-        OkxSwapSubscribeType::PrPositions
-    ];
-    test_new_exchange_wss(ExchangeEnum::OkxSwap, SYMBOL, okx_subscribe_type, "position").await;
-}
-
-// 测试订阅Orders信息
-#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
-#[instrument(level = "TRACE")]
-async fn test_get_wss_orders() {
-    global::log_utils::init_log_with_trace();
-
-    let okx_subscribe_type = vec![
-        OkxSwapSubscribeType::PrOrders
-    ];
-    test_new_exchange_wss(ExchangeEnum::OkxSwap, SYMBOL, okx_subscribe_type, "orders").await;
-}

standard/tests/okx_swap_test.rs

@@ -1,229 +0,0 @@
-use rust_decimal_macros::dec;
-use tracing::{instrument, trace};
-use standard::exchange::ExchangeEnum;
-use standard::Platform;
-use crate::exchange_test::test_new_exchange;
-
-mod exchange_test;
-
-const SYMBOL: &str = "CRO_USDT";
-
-// 测试获取Exchange实体
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_exchange() {
-    global::log_utils::init_log_with_trace();
-
-    let okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_self_exchange = okx_swap_exchange.get_self_exchange();
-    trace!(?okx_get_self_exchange);
-}
-
-// 测试获取交易对信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_symbol() {
-    global::log_utils::init_log_with_trace();
-
-    let okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_self_symbol = okx_swap_exchange.get_self_symbol();
-    trace!(?okx_get_self_symbol);
-}
-
-// 测试获取是否使用高速通道
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_is_colo() {
-    global::log_utils::init_log_with_trace();
-
-    let okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_self_is_colo = okx_swap_exchange.get_self_is_colo();
-    trace!(?okx_get_self_is_colo);
-}
-
-// 测试获取登录params信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_params() {
-    global::log_utils::init_log_with_trace();
-
-    let okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_self_params = okx_swap_exchange.get_self_params();
-    trace!("okx_get_self_params={:?}",okx_get_self_params);
-}
-
-// 测试获取Market信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_self_market() {
-    global::log_utils::init_log_with_trace();
-
-    let okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_self_market = okx_swap_exchange.get_self_market();
-    trace!(?okx_get_self_market);
-}
-
-// 测试获取请求时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_delays() {
-    global::log_utils::init_log_with_trace();
-
-    let okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_request_delays = okx_swap_exchange.get_request_delays();
-    trace!(?okx_get_request_delays);
-}
-
-// 测试获取请求平均时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_avg_delay() {
-    global::log_utils::init_log_with_trace();
-
-    let okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_request_avg_delay = okx_swap_exchange.get_request_avg_delay();
-    trace!(?okx_get_request_avg_delay);
-}
-
-// 测试获取最大请求时间信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_request_max_delay() {
-    global::log_utils::init_log_with_trace();
-
-    let okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_request_max_delay = okx_swap_exchange.get_request_max_delay();
-    trace!(?okx_get_request_max_delay);
-}
-
-// 测试获取服务器时间
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_server_time() {
-    global::log_utils::init_log_with_trace();
-
-    let mut okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_server_time = okx_swap_exchange.get_server_time().await;
-    trace!(?okx_get_server_time);
-}
-
-// 测试获取账号信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_account() {
-    global::log_utils::init_log_with_trace();
-
-    let mut okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_account = okx_swap_exchange.get_account().await;
-    trace!(?okx_get_account);
-}
-
-// 测试获取仓位信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_position() {
-    global::log_utils::init_log_with_trace();
-
-    let mut okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_position = okx_swap_exchange.get_position().await;
-    trace!(?okx_get_position);
-}
-
-// 测试获取Ticker信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_ticker() {
-    global::log_utils::init_log_with_trace();
-
-    let mut okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_ticker = okx_swap_exchange.get_ticker().await;
-    trace!(?okx_get_ticker);
-}
-
-// 测试获取Market信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_market() {
-    global::log_utils::init_log_with_trace();
-
-    let mut okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_market = okx_swap_exchange.get_market().await;
-    trace!(?okx_get_market);
-}
-
-// 测试获取Order详情信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_order_detail() {
-    global::log_utils::init_log_with_trace();
-
-    let mut okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_order_detail = okx_swap_exchange.get_order_detail("", "999997").await;
-    trace!(?okx_get_order_detail);
-}
-
-// 测试获取Order列表信息
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_get_orders_list() {
-    global::log_utils::init_log_with_trace();
-
-    let mut okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_get_orders_list = okx_swap_exchange.get_orders_list("active").await;
-    trace!(?okx_get_orders_list);
-}
-
-// 测试下单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_take_order() {
-    global::log_utils::init_log_with_trace();
-
-    let mut okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_take_order = okx_swap_exchange.take_order("999997", "kk", dec!(0.0901), dec!(100)).await;
-    trace!(?okx_take_order);
-}
-
-// 测试撤销订单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_cancel_order() {
-    global::log_utils::init_log_with_trace();
-
-    let mut okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_cancel_order = okx_swap_exchange.cancel_order("", "999998").await;
-    trace!(?okx_cancel_order);
-}
-
-// 测试撤销订单
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_cancel_orders() {
-    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_orders = kucoin_swap_exchange.cancel_orders().await;
-    trace!(?kucoin_cancel_orders);
-}
-
-// 测试设置持仓模式
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_set_dual_mode() {
-    global::log_utils::init_log_with_trace();
-
-    let mut okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_set_dual_mode = okx_swap_exchange.set_dual_mode("usdt", true).await;
-    trace!(?okx_set_dual_mode);
-}
-
-// 测试设置杠杆
-#[tokio::test]
-#[instrument(level = "TRACE")]
-async fn test_set_dual_leverage() {
-    global::log_utils::init_log_with_trace();
-
-    let mut okx_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::OkxSwap, SYMBOL).await;
-    let okx_set_dual_leverage = okx_swap_exchange.set_dual_leverage("10").await;
-    trace!(?okx_set_dual_leverage);
-}

strategy/src/utils.rs

@@ -394,8 +394,8 @@ pub fn build_html_file(data_c: &Vec<VecDeque<Option<Decimal>>>) -> String {
             name: "optimal_ask_price",
             type: "line",
             showSymbol: false,
-            data: data[8],
-            // data: [],
+            // data: data[8],
+            data: [],
             lineStyle: {
               type: "dashed",
             },
@@ -404,8 +404,8 @@ pub fn build_html_file(data_c: &Vec<VecDeque<Option<Decimal>>>) -> String {
             name: "optimal_bid_price",
             type: "line",
             showSymbol: false,
-            data: data[9],
-            // data: [],
+            // data: data[9],
+            data: [],
             lineStyle: {
               type: "dashed",
             },

tests/framework_3_0_test.rs

@@ -1,77 +0,0 @@
-use std::future::Future;
-use std::time::{Duration, Instant};
-use exchanges::response_base::ResponseData;
-use std::sync::Arc;
-use tokio::sync::Mutex;
-use tracing::info;
-use global::log_utils::init_log_with_info;
-// {"clientOid": "1453351218bitget", "force": "gtc", "marginCoin": "USDT", "marginMode": "crossed", "orderType": "limit","price": "0.61810", "productType": "USDT-FUTURES", "reduceOnly": "NO", "side": "sell", "size": "17","symbol": "MOODENGUSDT"}
-// {"clientOid": "1439414436bitget", "force": "gtc", "marginCoin": "USDT", "marginMode": "crossed", "orderType": "limit","price": "0.61253", "productType": "USDT-FUTURES", "reduceOnly": "NO", "side": "buy", "size": "17","symbol": "MOODENGUSDT"}
-
-
-
-
-struct Core {
-    pub max_delay: u128,
-}
-
-#[tokio::test]
-async fn framework_3_0() {
-    init_log_with_info();
-
-    let core = Arc::new(Mutex::new(Core { max_delay: 0 }));
-    let handler_am = Arc::new(Mutex::new(TestHandler { core_am: core }));
-
-    // 一个闭包解决了引用问题。
-    generator(|data| {
-        let handler_c = handler_am.clone();
-
-        async move {
-            let mut handler = handler_c.lock().await;
-
-            handler.on_data(data).await
-        }
-    }).await;
-}
-
-// 消息创造者
-async fn generator<F, Fut>(handle_function: F)
-where
-    F: Fn(ResponseData) -> Fut,
-    Fut: Future<Output=()> + Send + 'static, // 确保 Fut 是一个 Future，且输出类型为 ()
-{
-    let data = ResponseData::new("aaa".to_string(),
-                                 "code".to_string(),
-                                 "msg".to_string(),
-                                 "data".to_string());
-    // let mut c = 0;
-    loop {
-        let mut s_data = data.clone();
-        s_data.time = chrono::Utc::now().timestamp_micros();
-        s_data.res_time = Instant::now();
-
-        handle_function(s_data).await;
-
-        tokio::time::sleep(Duration::from_micros(10)).await;
-    }
-}
-
-struct TestHandler {
-    pub core_am: Arc<Mutex<Core>>,
-}
-
-impl TestHandler {
-    // 消息处理者
-    pub async fn on_data(&mut self, data: ResponseData) {
-        let mut core = self.core_am.lock().await;
-
-        let delay_nanos = data.res_time.elapsed().as_nanos();
-
-        if delay_nanos > core.max_delay {
-            core.max_delay = delay_nanos;
-        }
-
-        // 处理响应数据
-        info!("delay nanos: {}, max delay is: {}", delay_nanos, core.max_delay);
-    }
-}

tests/order_command_test.rs

@@ -1,105 +0,0 @@
-use std::collections::{BTreeMap};
-use std::{env};
-use tokio::sync::{mpsc, Mutex};
-use std::io::Error;
-use std::sync::Arc;
-use std::time::Duration;
-use tracing::{error, info};
-use exchanges::proxy;
-use standard::exchange::{Exchange, ExchangeEnum};
-use standard::{Order, OrderCommand};
-
-#[tokio::test]
-async fn main() {
-    if proxy::ParsingDetail::http_enable_proxy() {
-        println!("检测有代理配置，配置走代理")
-    }
-    let mut params: BTreeMap<String, String> = BTreeMap::new();
-    let access_key = env::var("gate_access_key").unwrap_or("".to_string());
-    let secret_key = env::var("gate_secret_key").unwrap_or("".to_string());
-    params.insert("access_key".to_string(), access_key);
-    params.insert("secret_key".to_string(), secret_key);
-
-    let (order_sender, mut order_receiver) = mpsc::channel::<Order>(100);
-    let (error_sender, mut error_receiver) = mpsc::channel::<Error>(100);
-
-    global::log_utils::init_log_with_info();
-
-    let mut exchange = Exchange::new(ExchangeEnum::GateSwap, "BTC_USDT".to_string(), false,
-                                     params, order_sender.clone(), error_sender.clone()).await;
-    let exchange_arc = Arc::new(Mutex::new(exchange));
-    let main_thread = tokio::spawn(async move {
-        let client_id_0 = "123425678".to_string();
-        let client_id_1 = "123452679".to_string();
-        let client_id_2 = "123452677".to_string();
-        let client_id_3 = "123452676".to_string();
-
-        loop {
-            // 下单
-            info!("下单");
-            let mut command = OrderCommand::new();
-            command.limits_open.insert("BTC_USDT1".to_string(), vec!["0.0001".to_string(), "kd".to_string(), "24000".to_string(), client_id_0.clone()]);
-            command.limits_open.insert("BTC_USDT2".to_string(), vec!["0.0001".to_string(), "kk".to_string(), "28000".to_string(), client_id_1.clone()]);
-            command.limits_open.insert("BTC_USDT3".to_string(), vec!["0.0001".to_string(), "kd".to_string(), "23000".to_string(), client_id_2.clone()]);
-            command.limits_open.insert("BTC_USDT4".to_string(), vec!["0.0001".to_string(), "kk".to_string(), "29000".to_string(), client_id_3.clone()]);
-            info!(?command);
-            let e0 = exchange_arc.clone();
-            tokio::spawn(async move {
-                e0.lock().await.command_order(command.clone()).await;
-            });
-            info!("下单委托完毕");
-            tokio::time::sleep(Duration::from_millis(500)).await;
-
-            // 查单
-            // info!("查单");
-            // let mut command = OrderCommand::new();
-            // command.check.insert("BTC_USDT1".to_string(), vec![client_id_0.clone(), "".to_string()]);
-            // command.check.insert("BTC_USDT2".to_string(), vec![client_id_1.clone(), "".to_string()]);
-            // exchange.command_order(command.clone()).await;
-            // tokio::time::sleep(Duration::from_secs(5)).await;
-
-            // 撤单
-            info!("撤单");
-            let mut command = OrderCommand::new();
-            command.cancel.insert("BTC_USDT1".to_string(), vec![client_id_0.clone(), "".to_string()]);
-            command.cancel.insert("BTC_USDT2".to_string(), vec![client_id_1.clone(), "".to_string()]);
-            command.cancel.insert("BTC_USDT3".to_string(), vec![client_id_2.clone(), "".to_string()]);
-            command.cancel.insert("BTC_USDT4".to_string(), vec![client_id_3.clone(), "".to_string()]);
-            info!(?command);
-            let e1 = exchange_arc.clone();
-            tokio::spawn(async move {
-                e1.lock().await.command_order(command.clone()).await;
-            });
-            info!("撤单委托完毕");
-            tokio::time::sleep(Duration::from_secs(30)).await;
-        }
-    });
-
-    let handler_thread = tokio::spawn(async move {
-        loop {
-            match order_receiver.recv().await {
-                Some(order) => {
-                    info!(?order)
-                },
-                None => {
-                    error!("Channel has been closed!");
-                    break;
-                }
-            }
-        }
-    });
-
-    let error_handler_thread = tokio::spawn(async move {
-        loop {
-            match error_receiver.recv().await {
-                Some(error) => error!(?error),
-                None => {
-                    error!("Channel has been closed!");
-                    break;
-                }
-            }
-        }
-    });
-
-    tokio::try_join!(main_thread, handler_thread, error_handler_thread).unwrap();
-}