Merge pull request #567 from devJaja/feature/add-tests-issues-479-484-485-486

Author: Levi-Ojukwu

contracts/invoice_liquidity/src/tests_benchmarks.rs

@@ -140,3 +140,182 @@ fn benchmark_all_functions_summary() {
         std::println!("| {name:<14} | {cpu:>16} | {mem:>14} |");
     }
 }
+
+// ================================================================
+// Tests for get_contract_stats with multiple tokens (Issue #485)
+// ================================================================
+
+use soroban_sdk::{contract, contractimpl, token::Client as TokenClient};
+
+#[contract]
+struct MockPriceOracle;
+
+#[contractimpl]
+impl MockPriceOracle {
+    pub fn get_price(_env: soroban_sdk::Env, _token: Address) -> i128 {
+        20_000
+    }
+}
+
+struct MultiTokenBenchEnv {
+    env: Env,
+    contract: InvoiceLiquidityContractClient<'static>,
+    usdc: Address,
+    usdc_client: TokenClient<'static>,
+    xlm: Address,
+    eurc: Address,
+    freelancer: Address,
+    payer: Address,
+    lp: Address,
+    admin: Address,
+}
+
+fn setup_multi_token() -> MultiTokenBenchEnv {
+    let env = Env::default();
+    env.mock_all_auths();
+
+    let mut ledger = env.ledger().get();
+    ledger.timestamp = 1_700_000_000;
+    env.ledger().set(ledger);
+
+    let usdc_admin = Address::generate(&env);
+    let usdc = env.register_stellar_asset_contract_v2(usdc_admin.clone());
+    let xlm_admin = Address::generate(&env);
+    let xlm = env.register_stellar_asset_contract_v2(xlm_admin);
+    let eurc_admin = Address::generate(&env);
+    let eurc = env.register_stellar_asset_contract_v2(eurc_admin);
+
+    let admin = usdc_admin.clone();
+    let contract_id = env.register_contract(None, InvoiceLiquidityContract);
+    let contract = InvoiceLiquidityContractClient::new(&env, &contract_id);
+    contract.initialize(&admin, &usdc.address(), &eurc.address(), &xlm.address());
+
+    let freelancer = Address::generate(&env);
+    let payer = Address::generate(&env);
+    let lp = Address::generate(&env);
+
+    let usdc_client = StellarAssetClient::new(&env, &usdc.address());
+    let usdc_token = TokenClient::new(&env, &usdc.address());
+    let xlm_client = StellarAssetClient::new(&env, &xlm.address());
+    let eurc_client = StellarAssetClient::new(&env, &eurc.address());
+
+    usdc_client.mint(&lp, &10_000_000_000_000);
+    usdc_client.mint(&payer, &10_000_000_000_000);
+    xlm_client.mint(&lp, &10_000_000_000_000);
+    xlm_client.mint(&payer, &10_000_000_000_000);
+    eurc_client.mint(&lp, &10_000_000_000_000);
+    eurc_client.mint(&payer, &10_000_000_000_000);
+
+    MultiTokenBenchEnv {
+        env,
+        contract,
+        usdc: usdc.address(),
+        usdc_client,
+        xlm: xlm.address(),
+        eurc: eurc.address(),
+        freelancer,
+        payer,
+        lp,
+        admin,
+    }
+}
+
+fn submit_and_fund(
+    t: &MultiTokenBenchEnv,
+    token: &Address,
+    amount: i128,
+) -> u64 {
+    let due_date = t.env.ledger().timestamp() + 86_400 * 30;
+    let id = t.contract.submit_invoice(
+        &t.freelancer,
+        &t.payer,
+        &amount,
+        &due_date,
+        &300u32,
+        token,
+        &ReferralCode::None,
+    );
+    t.contract.fund_invoice(&t.lp, &id, &amount, &false);
+    t.contract.mark_paid(&id, &amount);
+    id
+}
+
+#[test]
+fn test_stats_tracks_usdc_volume() {
+    let t = setup_multi_token();
+    submit_and_fund(&t, &t.usdc, 500_000_000);
+
+    let stats = t.contract.get_contract_stats();
+    assert_eq!(stats.total_volume_usdc, 500_000_000);
+    assert_eq!(stats.total_invoices, 1);
+    assert_eq!(stats.total_funded, 1);
+    assert_eq!(stats.total_paid, 1);
+}
+
+#[test]
+fn test_stats_tracks_xlm_volume() {
+    let t = setup_multi_token();
+    submit_and_fund(&t, &t.xlm, 2_000_000_000);
+
+    let stats = t.contract.get_contract_stats();
+    assert_eq!(stats.total_volume_xlm, 2_000_000_000);
+    assert_eq!(stats.total_volume_usdc, 0);
+}
+
+#[test]
+fn test_stats_tracks_eurc_volume() {
+    let t = setup_multi_token();
+    submit_and_fund(&t, &t.eurc, 750_000_000);
+
+    let stats = t.contract.get_contract_stats();
+    assert_eq!(stats.total_volume_eurc, 750_000_000);
+    assert_eq!(stats.total_volume_usdc, 0);
+    assert_eq!(stats.total_volume_xlm, 0);
+}
+
+#[test]
+fn test_stats_multi_token_aggregation() {
+    let t = setup_multi_token();
+    submit_and_fund(&t, &t.usdc, 1_000_000_000);
+    submit_and_fund(&t, &t.xlm, 2_000_000_000);
+    submit_and_fund(&t, &t.eurc, 3_000_000_000);
+
+    let stats = t.contract.get_contract_stats();
+    assert_eq!(stats.total_invoices, 3);
+    assert_eq!(stats.total_funded, 3);
+    assert_eq!(stats.total_paid, 3);
+    assert_eq!(stats.total_volume_usdc, 1_000_000_000);
+    assert_eq!(stats.total_volume_xlm, 2_000_000_000);
+    assert_eq!(stats.total_volume_eurc, 3_000_000_000);
+}
+
+#[test]
+fn test_stats_usd_normalized_with_price_oracle() {
+    let t = setup_multi_token();
+    submit_and_fund(&t, &t.usdc, 1_000_000_000);
+
+    // Install a mock price oracle that returns a fixed price.
+    let oracle_id = t.env.register_contract(None, MockPriceOracle);
+    t.env.as_contract(&t.contract.address, || {
+        let mut config = crate::storage::get_config(&t.env).unwrap();
+        config.price_oracle = Some(oracle_id.clone());
+        crate::storage::set_config(&t.env, &config);
+    });
+
+    let stats = t.contract.get_contract_stats();
+    // MockPriceOracle returns 20_000; normalized = 1_000_000_000 * 20_000 / 10_000
+    assert_eq!(
+        stats.total_volume_usd_normalized,
+        1_000_000_000 * 20_000 / 10_000
+    );
+}
+
+#[test]
+fn test_stats_without_price_oracle_returns_zero_normalized() {
+    let t = setup_multi_token();
+    submit_and_fund(&t, &t.usdc, 1_000_000_000);
+
+    // No oracle configured — should return 0 for normalized volume.
+    let stats = t.contract.get_contract_stats();
+    assert_eq!(stats.total_volume_usd_normalized, 0);
+}

contracts/invoice_liquidity/src/tests_lp_priority_queue.rs

@@ -293,3 +293,158 @@ fn test_full_queue_lifecycle_with_payout() {
     let invoice = t.contract.get_invoice(&id);
     assert_eq!(invoice.status, InvoiceStatus::Paid);
 }
+
+// ================================================================
+// Tests for LP priority queue edge cases (Issue #486)
+// ================================================================
+
+#[test]
+fn test_tie_breaking_three_lps_first_come_wins() {
+    let t = setup_queue();
+    let id = submit_invoice(&t);
+
+    // All three LPs have default score 50.
+    t.contract.join_fund_queue(&t.lp_a, &id); // 1st
+    t.contract.join_fund_queue(&t.lp_b, &id); // 2nd
+    t.contract.join_fund_queue(&t.lp_c, &id); // 3rd
+
+    let winner = t.contract.resolve_fund_queue(&id);
+    assert_eq!(winner, t.lp_a, "first LP should win on three-way tie");
+}
+
+#[test]
+fn test_resolve_empty_queue_rejected() {
+    let t = setup_queue();
+    let id = submit_invoice(&t);
+
+    let result = t.contract.try_resolve_fund_queue(&id);
+    assert_eq!(result, Err(Ok(ContractError::NotFunded)));
+}
+
+#[test]
+fn test_join_queue_after_invoice_resolved_rejected() {
+    let t = setup_queue();
+    let id = submit_invoice(&t);
+
+    t.contract.join_fund_queue(&t.lp_a, &id);
+    t.contract.resolve_fund_queue(&id);
+
+    let result = t.contract.try_join_fund_queue(&t.lp_c, &id);
+    assert_eq!(result, Err(Ok(ContractError::NotApprovedFunder)));
+}
+
+#[test]
+fn test_join_queue_for_funded_invoice_rejected() {
+    let t = setup_queue();
+    let id = submit_invoice(&t);
+
+    t.contract
+        .fund_invoice(&t.lp_a, &id, &INVOICE_AMOUNT, &false);
+
+    let result = t.contract.try_join_fund_queue(&t.lp_b, &id);
+    assert_eq!(result, Err(Ok(ContractError::AlreadyFunded)));
+}
+
+#[test]
+fn test_join_queue_for_paid_invoice_rejected() {
+    let t = setup_queue();
+    let id = submit_invoice(&t);
+
+    t.contract
+        .fund_invoice(&t.lp_a, &id, &INVOICE_AMOUNT, &false);
+    t.contract.mark_paid(&id, &INVOICE_AMOUNT);
+
+    let result = t.contract.try_join_fund_queue(&t.lp_b, &id);
+    assert_eq!(result, Err(Ok(ContractError::AlreadyPaid)));
+}
+
+#[test]
+fn test_join_queue_for_cancelled_invoice_rejected() {
+    let t = setup_queue();
+    let id = submit_invoice(&t);
+
+    t.contract.cancel_invoice(&id);
+
+    let result = t.contract.try_join_fund_queue(&t.lp_a, &id);
+    assert_eq!(result, Err(Ok(ContractError::AlreadyCancelled)));
+}
+
+#[test]
+fn test_join_queue_for_expired_invoice_rejected() {
+    let t = setup_queue();
+    let id = submit_invoice(&t);
+
+    // Advance time past due date to make it expirable.
+    let mut ledger = t.env.ledger().get();
+    ledger.timestamp += DUE_DATE_OFFSET + 1;
+    t.env.ledger().set(ledger);
+
+    t.contract.expire_invoice(&id);
+
+    let result = t.contract.try_join_fund_queue(&t.lp_a, &id);
+    assert_eq!(result, Err(Ok(ContractError::InvoiceExpired)));
+}
+
+#[test]
+fn test_non_approved_lp_cannot_fund_with_4_arg_signature() {
+    let t = setup_queue();
+    let id = submit_invoice(&t);
+
+    t.contract.join_fund_queue(&t.lp_a, &id);
+    t.contract.resolve_fund_queue(&id);
+
+    // lp_b is not the approved LP — should fail with 4-arg fund_invoice.
+    let result = t.contract.try_fund_invoice(&t.lp_b, &id, &INVOICE_AMOUNT, &false);
+    assert_eq!(result, Err(Ok(ContractError::NotApprovedFunder)));
+}
+
+#[test]
+fn test_queue_lifecycle_with_different_scores() {
+    let t = setup_queue();
+    let id = submit_invoice(&t);
+
+    // Boost lp_c's score by having it fund several invoices.
+    for _ in 0..5u32 {
+        let extra_id = submit_invoice(&t);
+        t.contract
+            .fund_invoice(&t.lp_c, &extra_id, &INVOICE_AMOUNT, &false);
+    }
+    // lp_c score is now 55, lp_a=50, lp_b=50.
+
+    t.contract.join_fund_queue(&t.lp_a, &id);
+    t.contract.join_fund_queue(&t.lp_b, &id);
+    t.contract.join_fund_queue(&t.lp_c, &id);
+
+    let winner = t.contract.resolve_fund_queue(&id);
+    assert_eq!(winner, t.lp_c, "highest score should win regardless of join order");
+
+    t.contract
+        .fund_invoice(&t.lp_c, &id, &INVOICE_AMOUNT, &false);
+    t.contract.mark_paid(&id, &INVOICE_AMOUNT);
+
+    let invoice = t.contract.get_invoice(&id);
+    assert_eq!(invoice.status, InvoiceStatus::Paid);
+}
+
+#[test]
+fn test_resolve_queue_only_once_stored() {
+    let t = setup_queue();
+    let id = submit_invoice(&t);
+
+    t.contract.join_fund_queue(&t.lp_a, &id);
+    let first_winner = t.contract.resolve_fund_queue(&id);
+
+    // Adding a new LP with higher score after resolution doesn't change result.
+    let boosted_id = submit_invoice(&t);
+    for _ in 0..10u32 {
+        let extra = submit_invoice(&t);
+        t.contract
+            .fund_invoice(&t.lp_b, &extra, &INVOICE_AMOUNT, &false);
+    }
+    t.contract
+        .fund_invoice(&t.lp_b, &boosted_id, &INVOICE_AMOUNT, &false);
+
+    // Can't join after resolution anyway, but resolve is idempotent.
+    let second_winner = t.contract.resolve_fund_queue(&id);
+    assert_eq!(first_winner, second_winner);
+}