as-rust/exchanges/tests/binance_swap_test.rs

use std::cmp::max;
use std::collections::BTreeMap;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;

use tokio::sync::Mutex;
use tracing::{info, trace};

use exchanges::binance_swap_rest::BinanceSwapRest;
use exchanges::binance_swap_ws::{BinanceSwapLogin, BinanceSwapSubscribeType, BinanceSwapWs, BinanceSwapWsType};
use exchanges::response_base::ResponseData;
use global::trace_stack::TraceStack;

const ACCESS_KEY: &str = "rgKH05A1QOpXj4NDKuIb8edOLPPpF0gYu8WBpiAIqG4aCwHsytjFWiOtoWYUPB7R";
const SECRET_KEY: &str = "14573tSKmHLyV5WO7L31hNK0HZ21yiyMqWg85POvrKDyOn2i9bZKNTlPBUqR3fpm";


//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 mut ws = get_ws(None);
    // ws.set_symbols(vec!["BTC_USDT".to_string()]);
    // ws.set_subscribe(vec![
    //     BinanceSwapSubscribeType::PuBookTicker,
    //     // BinanceSwapSubscribeType::PuAggTrade,
    //     // BinanceSwapSubscribeType::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!("线程-数据读取-开启");
    //     let mut max_delay = 0i64;
    //     loop {
    //         // 从通道中接收并丢弃所有的消息，直到通道为空
    //         while let Ok(Some(data)) = read_rx.try_next() {
    //             // 消息被忽略
    //             let mut trace_stack = TraceStack::new(0, Instant::now());
    //             trace_stack.on_before_unlock_core();
    //             trace_stack.on_after_network(data.time);
    //
    //             let delay = trace_stack.before_unlock_core - trace_stack.after_network;
    //             max_delay = max(max_delay, delay);
    //             info!("{}us, max={}us", delay, max_delay);
    //
    //             // 从通道中接收并丢弃所有的消息，直到通道为空
    //             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 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_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(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_data1 = rest.get_server_time().await;
    trace!(?rep_data1);

    trace!("开始时间：{:?}",chrono::Utc::now().timestamp_millis().to_string());
    let rep_data = rest.cancel_order_all("BTCUSDT".to_string()).await;
    trace!(?rep_data);
    trace!("结束时间：{:?}",chrono::Utc::now().timestamp_millis().to_string());
}

//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)
}


fn get_ws(btree_map: Option<BinanceSwapLogin>) -> BinanceSwapWs {
    let binance_ws = BinanceSwapWs::new(false,
                                        btree_map,
                                        BinanceSwapWsType::PublicAndPrivate);
    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
}