as-rust/tests/order_command_test.rs

use std::collections::{BTreeMap};
use std::{env};
use tokio::sync::mpsc;
use std::io::Error;
use std::time::Duration;
use tracing::{error, info, subscriber, trace};
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 exchange = Exchange::new(ExchangeEnum::GateSwap, "BTC_USDT".to_string(), false, params);

    let sub = tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        .with_span_events(tracing_subscriber::fmt::format::FmtSpan::FULL)
        .finish();
    subscriber::set_global_default(sub).expect("策略模块日志初始化错误");

    let (order_sender, mut order_receiver) = mpsc::channel::<Order>(100);
    let (error_sender, mut error_receiver) = mpsc::channel::<Error>(100);

    let main_thread = tokio::spawn(async move {
        let client_id_0 = "123425678".to_string();
        let client_id_1 = "123452679".to_string();

        loop {
            // 下单
            info!("下单");
            let mut command = OrderCommand::new();
            command.limits_open.insert("BTC_USDT1".to_string(), vec!["0.001".to_string(), "kd".to_string(), "25000".to_string(), client_id_0.clone()]);
            command.limits_open.insert("BTC_USDT2".to_string(), vec!["0.001".to_string(), "kk".to_string(), "28000".to_string(), client_id_1.clone()]);
            exchange.command_order(command.clone(), order_sender.clone(), error_sender.clone()).await;
            tokio::time::sleep(Duration::from_secs(5)).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(), order_sender.clone(), error_sender.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()]);
            exchange.command_order(command.clone(), order_sender.clone(), error_sender.clone()).await;
            tokio::time::sleep(Duration::from_secs(10)).await;
        }
    });

    let handler_thread = tokio::spawn(async move {
        info!("handler_thread被创建");

        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 {
        info!("error_handler_thread被创建");

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