as-rust/standard/tests/exchange_test.rs

use std::collections::{BTreeMap};
use std::{env};
use std::io::Error;
use std::sync::Arc;
use std::sync::atomic::AtomicBool;
use std::time::Duration;
use rust_decimal_macros::dec;
use tokio::sync::mpsc::{channel, Receiver, Sender};
use tokio::try_join;
use tracing::trace;
use exchanges::kucoin_swap_ws::{KucoinSubscribeType, KucoinSwapWs, KucoinWsType};
use exchanges::response_base::ResponseData;
use standard::exchange::{Exchange, ExchangeEnum};
use standard::{kucoin_handle, Order, Platform, utils};

// 创建实体
pub async fn test_new_exchange(exchange: ExchangeEnum, symbol: &str) -> Box<dyn Platform> {
    utils::proxy_handle();
    let (order_sender, _order_receiver): (Sender<Order>, Receiver<Order>) = channel(1024);
    let (error_sender, _error_receiver): (Sender<Error>, Receiver<Error>) = channel(1024);
    match exchange {
        ExchangeEnum::BinanceSwap => {
            let mut params: BTreeMap<String, String> = BTreeMap::new();
            let access_key = env::var("binance_access_key").unwrap_or("".to_string());
            let secret_key = env::var("binance_secret_key").unwrap_or("".to_string());
            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 = env::var("binance_access_key").unwrap_or("".to_string());
            let secret_key = env::var("binance_secret_key").unwrap_or("".to_string());
            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 = 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);
            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 = 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);
            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 = 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);
            Exchange::new(exchange, symbol.to_string(), false, params, order_sender, error_sender).await
        }
    }
}

#[allow(dead_code)]
pub async fn test_new_exchange_wss<T>(exchange: ExchangeEnum, symbol: &str, subscriber_type: T, mold: &str) where Vec<KucoinSubscribeType>: From<T> {
    utils::proxy_handle();

    match exchange {
        ExchangeEnum::BinanceSwap => {
            panic!("该交易所不支持！")
        }
        ExchangeEnum::GateSwap => {
            panic!("该交易所不支持！")
        }
        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_usdt_swap@{}", symbol.to_string().to_lowercase());
            let bool_v1 = Arc::new(AtomicBool::new(true));

            let (res_sender, mut res_receiver): (Sender<ResponseData>, Receiver<ResponseData>) = 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 exchange_wss;
            if ["depth", "ticker"].contains(&mold) {
                exchange_wss = KucoinSwapWs::new_label(name, false, params, KucoinWsType::Public, res_sender).await
            } else {
                exchange_wss = KucoinSwapWs::new_label(name, false, params, KucoinWsType::Private, res_sender).await
            }
            exchange_wss.set_subscribe(subscriber_type.into());

            let t1 = tokio::spawn(async move {
                exchange_wss.custom_subscribe(bool_v1, vec![symbol_format]).await;
            });
            let mold_arc = Arc::new(mold.to_string());
            let t2 = tokio::spawn(async move {
                let mold_clone = Arc::clone(&mold_arc);
                loop {
                    tokio::time::sleep(Duration::from_millis(1)).await;
                    if let Ok(received) = res_receiver.try_recv() {
                        match mold_clone.as_str() {
                            "depth" => {
                                let result = kucoin_handle::handle_special_depth(received);
                                trace!(?result)
                            }
                            "ticker" => {
                                let result = kucoin_handle::handle_special_ticker(received);
                                trace!(?result)
                            }
                            "account" => {
                                trace!(?received);
                                let result = kucoin_handle::handle_account_info(received, symbol_back.clone());
                                trace!(?result)
                            }
                            "position" => {
                                trace!(?received);
                                let result = kucoin_handle::handle_position(received, dec!(1));
                                trace!(?result)
                            }
                            "orders" => {
                                trace!(?received);
                                let result = kucoin_handle::handle_order(received, dec!(0.001));
                                trace!(?result)
                            }
                            _ => {
                                panic!("没有该命令！mode={}", mold_clone)
                            }
                        }
                    }
                }
            });
            try_join!(t1, t2).unwrap();
        }
        _ => {
            panic!("该交易所不支持！")
        }
    }
}