as-rust/tests/order_command_test.rs

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();
}