as-rust/standard/tests/libs_test.rs

use std::collections::BTreeMap;
use std::env;
use rust_decimal_macros::dec;
use exchanges::proxy;
use standard::{Platform, PositionModeEnum};
use standard::utils;
use standard::exchange::{Exchange, ExchangeEnum};

// 创建交易所实体方法
fn test_new_exchange(exchange: ExchangeEnum) -> Box<dyn Platform> {
    if proxy::ParsingDetail::http_enable_proxy() {
        println!("检测有代理配置，配置走代理")
    }
    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, "ROSE_USDT".to_string(), false, params)
        }
        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, "ROSE_USDT".to_string(), false, params)
        }
        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, "ROSE_USDT".to_string(), false, params)
        }
        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, "ROSE_USDT".to_string(), false, params)
        }
        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, "ROSE_USDT".to_string(), false, params)
        }
    }
}

// 测试获取Binance交易所期货实体
#[tokio::test]
async fn test_binance_swap_account() {
    let binance_swap_exchange = test_new_exchange(ExchangeEnum::BinanceSwap);
    println!("exchange: {:?}", binance_swap_exchange.get_self_exchange());
    println!("is_colo: {:?}", binance_swap_exchange.get_self_is_colo());
    println!("params: {:?}", binance_swap_exchange.get_self_params());
}

// 测试获取Binance交易所现货实体
#[tokio::test]
async fn test_binance_spot_account() {
    let binance_spot_exchange = test_new_exchange(ExchangeEnum::BinanceSpot);
    println!("exchange: {:?}", binance_spot_exchange.get_self_exchange());
    println!("is_colo: {:?}", binance_spot_exchange.get_self_is_colo());
    println!("params: {:?}", binance_spot_exchange.get_self_params());
}

// 测试获取Gate交易所期货实体
#[tokio::test]
async fn test_gate_swap_account() {
    let gate_swap_exchange = test_new_exchange(ExchangeEnum::GateSwap);
    println!("exchange: {:?}", gate_swap_exchange.get_self_exchange());
    println!("is_colo: {:?}", gate_swap_exchange.get_self_is_colo());
    println!("params: {:?}", gate_swap_exchange.get_self_params());
}

// 测试获取Gate交易所现货实体
#[tokio::test]
async fn test_gate_spot_account() {
    let gate_spot_exchange = test_new_exchange(ExchangeEnum::GateSpot);
    println!("exchange: {:?}", gate_spot_exchange.get_self_exchange());
    println!("is_colo: {:?}", gate_spot_exchange.get_self_is_colo());
    println!("params: {:?}", gate_spot_exchange.get_self_params());
}

// 测试获取Gate交易所现货实体
#[tokio::test]
async fn test_kucoin_swap_account() {
    let kucoin_swap_exchange = test_new_exchange(ExchangeEnum::KucoinSwap);
    println!("exchange: {:?}", kucoin_swap_exchange.get_self_exchange());
    println!("is_colo: {:?}", kucoin_swap_exchange.get_self_is_colo());
    println!("params: {:?}", kucoin_swap_exchange.get_self_params());
}

// 测试币对连接符号替换
#[tokio::test]
async fn test_replace_symbol() {
    println!("test_replace_symbol: {}", utils::format_symbol("BTC_USDT".to_string(), "-"))
}

// 测试Binance期货K线推送
#[tokio::test]
async fn test_get_account() {
    let binance_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSwap);
    println!("binance_swap account:{:?}", binance_swap_exchange.get_account().await);
    let binance_spot_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::BinanceSpot);
    println!("binance_spot account:{:?}", binance_spot_exchange.get_account().await);
    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap);
    println!("gate_swap account:{:?}", gate_swap_exchange.get_account().await);
    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap);
    println!("kucoin_swap account:{:?}", kucoin_swap_exchange.get_account().await);
}

// 测试Gate 获取持仓信息
#[tokio::test]
async fn test_gate_swap_get_position() {
    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap);
    println!("gate_swap get_position:{:?}", gate_swap_exchange.get_position(PositionModeEnum::Both).await);
}

// 测试Gate获取Ticker信息
#[tokio::test]
async fn test_gate_swap_get_ticker() {
    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap);
    println!("gate_swap get_ticker:{:?}", gate_swap_exchange.get_ticker().await);
}

// 测试Gate获取Market信息
#[tokio::test]
async fn test_gate_swap_get_market() {
    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap);
    println!("gate_swap get_market:{:?}", gate_swap_exchange.get_market().await);
}

// 测试Gate获取Order详情信息
#[tokio::test]
async fn test_gate_swap_get_order_detail() {
    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap);
    println!("gate_swap get_order_detail:{:?}", gate_swap_exchange.get_order_detail("336321097375").await);
}

// 测试Gate获取Order列表信息
#[tokio::test]
async fn test_gate_swap_get_orders_list() {
    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap);
    println!("gate_swap get_orders_list:{:?}", gate_swap_exchange.get_orders_list("finished").await);
}

// 测试Gate 设置持仓模式
#[tokio::test]
async fn test_set_dual_mode() {
    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap);
    println!("gate_swap set_dual_mode:{:?}", gate_swap_exchange.set_dual_mode("usdt", true).await);
}

// 测试Gate 设置持仓模式
#[tokio::test]
async fn test_set_dual_leverage() {
    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap);
    println!("gate_swap set_dual_leverage:{:?}", gate_swap_exchange.set_dual_leverage("10").await);
}

// 测试Gate 测试下单
#[tokio::test]
async fn test_take_order() {
    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap);
    println!("gate_swap take_order:{:?}", gate_swap_exchange.take_order("123456", "pd", dec!(0.038850), dec!(1)).await);
}

// 测试Gate 撤销订单
#[tokio::test]
async fn test_cancel_order() {
    let gate_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::GateSwap);
    println!("gate_swap cancel_order:{:?}", gate_swap_exchange.cancel_order("337811438982", false).await);
}

// 测试kucoin 获取持仓信息
#[tokio::test]
async fn test_kucoin_swap_get_position() {
    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap);
    println!("kucoin_swap get_position:{:?}", kucoin_swap_exchange.get_position(PositionModeEnum::Both).await);
}

// 测试kucoin 获取Ticker信息
#[tokio::test]
async fn test_kucoin_swap_get_ticker() {
    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap);
    println!("kucoin_swap get_ticker:{:?}", kucoin_swap_exchange.get_ticker().await);
}

// 测试kucoin 获取Market信息
#[tokio::test]
async fn test_kucoin_swap_get_market() {
    let kucoin_swap_exchange: Box<dyn Platform> = test_new_exchange(ExchangeEnum::KucoinSwap);
    println!("kucoin_swap get_market:{:?}", kucoin_swap_exchange.get_market().await);
}