ledger-prototype/utxo/src/tests/withdrawal.rs

use super::{deposit, get_asset_manager_and_ledger, withdrawal};
use crate::{AccountId, Asset};

#[tokio::test]
async fn deposit_transfer_and_withdrawal() {
    let source = "account1".parse::<AccountId>().expect("account");
    let dest = "account2".parse::<AccountId>().expect("account");
    let fee = "fee".parse::<AccountId>().expect("account");
    let ledger = get_asset_manager_and_ledger().await;
    let usd: Asset = "USD/2".parse().expect("asset");

    deposit(&ledger, &source, usd.from_human("10").expect("amount")).await;
    deposit(&ledger, &source, usd.from_human("20").expect("amount")).await;

    assert_eq!(
        vec![usd.from_human("30").expect("amount"),],
        ledger.get_balance(&source).await.expect("balance")
    );

    ledger
        .new_transaction(
            "Exchange one".to_owned(),
            "settled".into(),
            vec![(source.clone(), usd.from_human("13").expect("amount"))],
            vec![
                (dest.clone(), usd.from_human("12.5").expect("amount")),
                (fee.clone(), usd.from_human("0.5").expect("amount")),
            ],
        )
        .await
        .expect("valid tx");

    assert_eq!(
        vec![usd.from_human("17").expect("amount"),],
        ledger.get_balance(&source).await.expect("balance")
    );
    assert_eq!(
        vec![usd.from_human("12.5").expect("amount"),],
        ledger.get_balance(&dest).await.expect("balance")
    );
    assert_eq!(
        vec![usd.from_human("0.5").expect("amount"),],
        ledger.get_balance(&fee).await.expect("balance")
    );

    assert!(withdrawal(
        &ledger,
        &source,
        "settled".into(),
        usd.from_human("17").expect("amount"),
    )
    .await
    .is_ok());

    assert!(ledger
        .get_balance(&source)
        .await
        .expect("balance")
        .is_empty());
    assert_eq!(
        vec![usd.from_human("12.5").expect("amount")],
        ledger.get_balance(&dest).await.expect("balance")
    );
    assert_eq!(
        vec![usd.from_human("0.5").expect("amount")],
        ledger.get_balance(&fee).await.expect("balance")
    );
}

#[tokio::test]
async fn fail_to_overwithdrawal() {
    let source = "account1".parse::<AccountId>().expect("account");
    let dest = "account2".parse::<AccountId>().expect("account");
    let fee = "fee".parse::<AccountId>().expect("account");
    let ledger = get_asset_manager_and_ledger().await;
    let usd: Asset = "USD/2".parse().expect("asset");

    deposit(&ledger, &source, usd.from_human("10").expect("amount")).await;
    deposit(&ledger, &source, usd.from_human("20").expect("amount")).await;

    assert_eq!(
        vec![usd.from_human("30").expect("amount"),],
        ledger.get_balance(&source).await.expect("balance")
    );

    ledger
        .new_transaction(
            "Exchange one".to_owned(),
            "settled".into(),
            vec![(source.clone(), usd.from_human("13").expect("amount"))],
            vec![
                (dest.clone(), usd.from_human("12.5").expect("amount")),
                (fee.clone(), usd.from_human("0.5").expect("amount")),
            ],
        )
        .await
        .expect("valid tx");

    assert_eq!(
        vec![usd.from_human("17").expect("amount"),],
        ledger.get_balance(&source).await.expect("balance")
    );
    assert_eq!(
        vec![usd.from_human("12.5").expect("amount"),],
        ledger.get_balance(&dest).await.expect("balance")
    );
    assert_eq!(
        vec![usd.from_human("0.5").expect("amount"),],
        ledger.get_balance(&fee).await.expect("balance")
    );

    assert!(withdrawal(
        &ledger,
        &source,
        "settled".into(),
        usd.from_human("1700").expect("amount"),
    )
    .await
    .is_err());

    assert_eq!(
        vec![usd.from_human("17").expect("amount"),],
        ledger.get_balance(&source).await.expect("balance")
    );
    assert_eq!(
        vec![usd.from_human("12.5").expect("amount"),],
        ledger.get_balance(&dest).await.expect("balance")
    );
    assert_eq!(
        vec![usd.from_human("0.5").expect("amount"),],
        ledger.get_balance(&fee).await.expect("balance")
    );
}

#[tokio::test]
async fn cancelled_withdrawal() {
    let source = "account1".parse::<AccountId>().expect("account");
    let dest = "account2".parse::<AccountId>().expect("account");
    let fee = "fee".parse::<AccountId>().expect("account");
    let ledger = get_asset_manager_and_ledger().await;
    let usd: Asset = "USD/2".parse().expect("asset");

    deposit(&ledger, &source, usd.from_human("10").expect("amount")).await;
    deposit(&ledger, &source, usd.from_human("20").expect("amount")).await;

    assert_eq!(
        vec![usd.from_human("30").expect("amount"),],
        ledger.get_balance(&source).await.expect("balance")
    );

    ledger
        .new_transaction(
            "Exchange one".to_owned(),
            "settled".into(),
            vec![(source.clone(), usd.from_human("13").expect("amount"))],
            vec![
                (dest.clone(), usd.from_human("12.5").expect("amount")),
                (fee.clone(), usd.from_human("0.5").expect("amount")),
            ],
        )
        .await
        .expect("valid tx");

    assert_eq!(
        vec![usd.from_human("17").expect("amount"),],
        ledger.get_balance(&source).await.expect("balance")
    );
    assert_eq!(
        vec![usd.from_human("12.5").expect("amount"),],
        ledger.get_balance(&dest).await.expect("balance")
    );
    assert_eq!(
        vec![usd.from_human("0.5").expect("amount"),],
        ledger.get_balance(&fee).await.expect("balance")
    );

    let rev_id = withdrawal(
        &ledger,
        &source,
        "pending".into(),
        usd.from_human("17").expect("amount"),
    )
    .await
    .expect("valid tx");

    assert!(ledger
        .get_balance(&source)
        .await
        .expect("balance")
        .is_empty());
    assert_eq!(
        vec![usd.from_human("12.5").expect("amount"),],
        ledger.get_balance(&dest).await.expect("balance")
    );
    assert_eq!(
        vec![usd.from_human("0.5").expect("amount"),],
        ledger.get_balance(&fee).await.expect("balance")
    );

    ledger
        .change_status(
            rev_id,
            "cancelled".into(),
            "cancelled by test".to_owned(),
            None,
        )
        .await
        .expect("valid tx");

    assert_eq!(
        vec![usd.from_human("17").expect("amount"),],
        ledger.get_balance(&source).await.expect("balance")
    );

    assert_eq!(
        vec![usd.from_human("12.5").expect("amount"),],
        ledger.get_balance(&dest).await.expect("balance")
    );
    assert_eq!(
        vec![usd.from_human("0.5").expect("amount"),],
        ledger.get_balance(&fee).await.expect("balance")
    );
}

#[tokio::test]
async fn negative_withdrawal() {
    let source = "account1".parse::<AccountId>().expect("account");
    let ledger = get_asset_manager_and_ledger().await;
    let usd: Asset = "USD/2".parse().expect("asset");

    deposit(
        &ledger,
        &source,
        usd.from_human("-1000").expect("valid amount"),
    )
    .await;

    assert_eq!(
        vec![usd.from_human("-1000").expect("valid amount"),],
        ledger.get_balance(&source).await.expect("balance")
    );

    assert_eq!(
        vec![usd.from_human("-1000").expect("valid amount"),],
        ledger.get_balance(&source).await.expect("balance")
    );

    assert!(withdrawal(
        &ledger,
        &source,
        "settled".into(),
        usd.from_human("-1000").expect("valid amount"),
    )
    .await
    .is_err());

    assert!(withdrawal(
        &ledger,
        &source,
        "settled".into(),
        usd.from_human("-1").expect("valid amount"),
    )
    .await
    .is_err());

    assert!(withdrawal(
        &ledger,
        &source,
        "settled".into(),
        usd.from_human("0").expect("valid amount"),
    )
    .await
    .is_err());

    assert!(withdrawal(
        &ledger,
        &source,
        "settled".into(),
        usd.from_human("10").expect("valid amount"),
    )
    .await
    .is_err());

    assert_eq!(
        vec![usd.from_human("-1000").expect("valid amount"),],
        ledger.get_balance(&source).await.expect("balance")
    );
}