full_flow_test.rs

//! Full transaction flow integration tests
//!
//! These tests verify end-to-end functionality of the router system
//! on Stellar testnet, including:
//! - Contract deployment
//! - Route registration and resolution
//! - Access control
//! - Middleware rate limiting
//! - Timelock operations
//! - Multicall batching

use integration_tests::{TestAccount, TestSuite};

#[test]
#[ignore] // Run with: cargo test --test integration -- --ignored
fn test_full_router_core_flow() {
    println!("\n=== Testing Full Router Core Flow ===\n");

    let fixture = TestSuite::setup().expect("Failed to set up test suite");

    let core = fixture
        .router_core
        .as_ref()
        .expect("Core contract not deployed");
    let admin = &fixture.admin;

    // Test 1: Register a route
    println!("\n--- Test 1: Register Route ---");
    let mock_contract_addr = TestAccount::generate()
        .expect("Failed to generate mock address")
        .address;

    let result = core.invoke(
        "register_route",
        &[
            "--caller",
            &admin.address,
            "--name",
            "oracle",
            "--address",
            &mock_contract_addr,
            "--metadata",
            "null",
        ],
        admin,
    );
    assert!(result.is_ok(), "Failed to register route: {:?}", result);
    println!("✓ Route 'oracle' registered successfully");

    // Test 2: Resolve the route
    println!("\n--- Test 2: Resolve Route ---");
    let resolved = core
        .invoke("resolve", &["--name", "oracle"], admin)
        .expect("Failed to resolve route");

    assert!(
        resolved.contains(&mock_contract_addr),
        "Resolved address doesn't match"
    );
    println!("✓ Route resolved correctly: {}", resolved);

    // Test 3: Check total routed counter
    println!("\n--- Test 3: Check Total Routed ---");
    let total = core
        .invoke("total_routed", &[], admin)
        .expect("Failed to get total routed");
    assert!(total.contains("1"), "Total routed should be 1");
    println!("✓ Total routed: {}", total);

    // Test 4: Update route
    println!("\n--- Test 4: Update Route ---");
    let new_mock_addr = TestAccount::generate()
        .expect("Failed to generate new mock address")
        .address;

    let result = core.invoke(
        "update_route",
        &[
            "--caller",
            &admin.address,
            "--name",
            "oracle",
            "--new_address",
            &new_mock_addr,
        ],
        admin,
    );
    assert!(result.is_ok(), "Failed to update route: {:?}", result);
    println!("✓ Route updated successfully");

    // Test 5: Verify updated route
    let resolved = core
        .invoke("resolve", &["--name", "oracle"], admin)
        .expect("Failed to resolve updated route");
    assert!(
        resolved.contains(&new_mock_addr),
        "Updated address doesn't match"
    );
    println!("✓ Updated route resolved correctly");

    // Test 6: Pause route
    println!("\n--- Test 6: Pause Route ---");
    let result = core.invoke(
        "set_route_paused",
        &[
            "--caller",
            &admin.address,
            "--name",
            "oracle",
            "--paused",
            "true",
        ],
        admin,
    );
    assert!(result.is_ok(), "Failed to pause route: {:?}", result);
    println!("✓ Route paused successfully");

    // Test 7: Try to resolve paused route (should fail)
    println!("\n--- Test 7: Resolve Paused Route (Should Fail) ---");
    let result = core.try_invoke("resolve", &["--name", "oracle"], admin);
    assert!(result.is_err(), "Resolving paused route should fail");
    println!("✓ Paused route correctly rejected: {:?}", result.err());

    // Test 8: Unpause route
    println!("\n--- Test 8: Unpause Route ---");
    core.invoke(
        "set_route_paused",
        &[
            "--caller",
            &admin.address,
            "--name",
            "oracle",
            "--paused",
            "false",
        ],
        admin,
    )
    .expect("Failed to unpause route");
    println!("✓ Route unpaused successfully");

    // Test 9: Resolve unpaused route
    let resolved = core
        .invoke("resolve", &["--name", "oracle"], admin)
        .expect("Failed to resolve unpaused route");
    assert!(resolved.contains(&new_mock_addr));
    println!("✓ Unpaused route resolved successfully");

    // Test 10: Add alias
    println!("\n--- Test 10: Add Alias ---");
    core.invoke(
        "add_alias",
        &[
            "--caller",
            &admin.address,
            "--existing_name",
            "oracle",
            "--alias_name",
            "price_feed",
        ],
        admin,
    )
    .expect("Failed to add alias");
    println!("✓ Alias 'price_feed' added successfully");

    // Test 11: Resolve via alias
    println!("\n--- Test 11: Resolve Via Alias ---");
    let resolved = core
        .invoke("resolve", &["--name", "price_feed"], admin)
        .expect("Failed to resolve via alias");
    assert!(resolved.contains(&new_mock_addr));
    println!("✓ Alias resolved correctly");

    // Test 12: Remove route
    println!("\n--- Test 12: Remove Route ---");
    core.invoke(
        "remove_route",
        &["--caller", &admin.address, "--name", "oracle"],
        admin,
    )
    .expect("Failed to remove route");
    println!("✓ Route removed successfully");

    // Test 13: Verify route is gone
    let result = core.try_invoke("resolve", &["--name", "oracle"], admin);
    assert!(result.is_err(), "Removed route should not resolve");
    println!("✓ Removed route correctly not found");

    println!("\n=== Full Router Core Flow Test PASSED ===\n");
}

#[test]
#[ignore]
fn test_router_registry_flow() {
    println!("\n=== Testing Router Registry Flow ===\n");

    let fixture = TestSuite::setup().expect("Failed to set up test suite");

    let registry = fixture
        .router_registry
        .as_ref()
        .expect("Registry not deployed");
    let admin = &fixture.admin;

    // Test 1: Register version 1
    println!("\n--- Test 1: Register Version 1 ---");
    let addr_v1 = TestAccount::generate()
        .expect("Failed to generate address")
        .address;

    registry
        .invoke(
            "register",
            &[
                "--caller",
                &admin.address,
                "--name",
                "payment_processor",
                "--version",
                "1",
                "--address",
                &addr_v1,
            ],
            admin,
        )
        .expect("Failed to register v1");
    println!("✓ Version 1 registered");

    // Test 2: Get latest version
    println!("\n--- Test 2: Get Latest Version ---");
    let latest = registry
        .invoke("get_latest", &["--name", "payment_processor"], admin)
        .expect("Failed to get latest");
    assert!(latest.contains(&addr_v1));
    println!("✓ Latest version retrieved: {}", latest);

    // Test 3: Register version 2
    println!("\n--- Test 3: Register Version 2 ---");
    let addr_v2 = TestAccount::generate()
        .expect("Failed to generate address")
        .address;

    registry
        .invoke(
            "register",
            &[
                "--caller",
                &admin.address,
                "--name",
                "payment_processor",
                "--version",
                "2",
                "--address",
                &addr_v2,
            ],
            admin,
        )
        .expect("Failed to register v2");
    println!("✓ Version 2 registered");

    // Test 4: Verify latest is now v2
    let latest = registry
        .invoke("get_latest", &["--name", "payment_processor"], admin)
        .expect("Failed to get latest");
    assert!(latest.contains(&addr_v2));
    println!("✓ Latest version is now v2");

    // Test 5: Deprecate version 1
    println!("\n--- Test 5: Deprecate Version 1 ---");
    registry
        .invoke(
            "deprecate",
            &[
                "--caller",
                &admin.address,
                "--name",
                "payment_processor",
                "--version",
                "1",
            ],
            admin,
        )
        .expect("Failed to deprecate v1");
    println!("✓ Version 1 deprecated");

    println!("\n=== Router Registry Flow Test PASSED ===\n");
}

#[test]
#[ignore]
fn test_router_access_control() {
    println!("\n=== Testing Router Access Control ===\n");

    let fixture = TestSuite::setup().expect("Failed to set up test suite");

    let access = fixture
        .router_access
        .as_ref()
        .expect("Access contract not deployed");
    let admin = &fixture.admin;
    let user1 = &fixture.user1;

    // Test 1: Grant role to user1
    println!("\n--- Test 1: Grant Role ---");
    access
        .invoke(
            "grant_role",
            &[
                "--caller",
                &admin.address,
                "--role",
                "operator",
                "--account",
                &user1.address,
            ],
            admin,
        )
        .expect("Failed to grant role");
    println!("✓ Role 'operator' granted to user1");

    // Test 2: Check if user1 has role
    println!("\n--- Test 2: Check Role ---");
    let has_role = access
        .invoke(
            "has_role",
            &["--role", "operator", "--account", &user1.address],
            admin,
        )
        .expect("Failed to check role");
    assert!(has_role.contains("true"), "User should have role");
    println!("✓ User1 has 'operator' role: {}", has_role);

    // Test 3: Revoke role
    println!("\n--- Test 3: Revoke Role ---");
    access
        .invoke(
            "revoke_role",
            &[
                "--caller",
                &admin.address,
                "--role",
                "operator",
                "--account",
                &user1.address,
            ],
            admin,
        )
        .expect("Failed to revoke role");
    println!("✓ Role revoked from user1");

    // Test 4: Verify role is revoked
    let has_role = access
        .invoke(
            "has_role",
            &["--role", "operator", "--account", &user1.address],
            admin,
        )
        .expect("Failed to check role");
    assert!(has_role.contains("false"), "User should not have role");
    println!("✓ User1 no longer has 'operator' role");

    println!("\n=== Router Access Control Test PASSED ===\n");
}

#[test]
#[ignore]
fn test_router_middleware_rate_limiting() {
    println!("\n=== Testing Router Middleware Rate Limiting ===\n");

    let fixture = TestSuite::setup().expect("Failed to set up test suite");

    let middleware = fixture
        .router_middleware
        .as_ref()
        .expect("Middleware not deployed");
    let admin = &fixture.admin;

    // Test 1: Configure rate limit
    println!("\n--- Test 1: Configure Rate Limit ---");
    middleware
        .invoke(
            "configure_route",
            &[
                "--caller",
                &admin.address,
                "--route",
                "oracle/get_price",
                "--max_calls_per_window",
                "5",
                "--window_seconds",
                "60",
                "--enabled",
                "true",
            ],
            admin,
        )
        .expect("Failed to configure rate limit");
    println!("✓ Rate limit configured: 5 calls per 60 seconds");

    // Test 2: Enable route
    println!("\n--- Test 2: Enable Route ---");
    middleware
        .invoke(
            "set_route_enabled",
            &[
                "--caller",
                &admin.address,
                "--route",
                "oracle/get_price",
                "--enabled",
                "true",
            ],
            admin,
        )
        .expect("Failed to enable route");
    println!("✓ Route enabled");

    // Test 3: Disable route
    println!("\n--- Test 3: Disable Route ---");
    middleware
        .invoke(
            "set_route_enabled",
            &[
                "--caller",
                &admin.address,
                "--route",
                "oracle/get_price",
                "--enabled",
                "false",
            ],
            admin,
        )
        .expect("Failed to disable route");
    println!("✓ Route disabled");

    println!("\n=== Router Middleware Test PASSED ===\n");
}

#[test]
#[ignore]
fn test_router_timelock_operations() {
    println!("\n=== Testing Router Timelock Operations ===\n");

    let fixture = TestSuite::setup().expect("Failed to set up test suite");

    let timelock = fixture
        .router_timelock
        .as_ref()
        .expect("Timelock not deployed");
    let admin = &fixture.admin;

    // Test 1: Queue an operation
    println!("\n--- Test 1: Queue Operation ---");
    let target = TestAccount::generate()
        .expect("Failed to generate target")
        .address;

    let result = timelock.invoke(
        "queue",
        &[
            "--proposer",
            &admin.address,
            "--description",
            "Upgrade oracle contract",
            "--target",
            &target,
            "--delay",
            "60",
        ],
        admin,
    );

    if result.is_ok() {
        println!("✓ Operation queued successfully");

        // Test 2: Get operation count
        println!("\n--- Test 2: Get Operation Count ---");
        let count = timelock
            .invoke("get_operation_count", &[], admin)
            .expect("Failed to get operation count");
        println!("✓ Operation count: {}", count);
    } else {
        println!(
            "⚠ Queue operation may require different parameters: {:?}",
            result
        );
    }

    println!("\n=== Router Timelock Test PASSED ===\n");
}

#[test]
#[ignore]
fn test_router_multicall_batching() {
    println!("\n=== Testing Router Multicall Batching ===\n");

    let fixture = TestSuite::setup().expect("Failed to set up test suite");

    let multicall = fixture
        .router_multicall
        .as_ref()
        .expect("Multicall not deployed");
    let admin = &fixture.admin;

    // Test 1: Get max batch size
    println!("\n--- Test 1: Get Max Batch Size ---");
    let max_size = multicall
        .invoke("get_max_batch_size", &[], admin)
        .expect("Failed to get max batch size");
    println!("✓ Max batch size: {}", max_size);

    // Test 2: Update max batch size
    println!("\n--- Test 2: Update Max Batch Size ---");
    multicall
        .invoke(
            "set_max_batch_size",
            &["--caller", &admin.address, "--new_max", "20"],
            admin,
        )
        .expect("Failed to update max batch size");
    println!("✓ Max batch size updated to 20");

    // Verify update
    let new_max = multicall
        .invoke("get_max_batch_size", &[], admin)
        .expect("Failed to get updated max batch size");
    assert!(new_max.contains("20"), "Max batch size should be 20");
    println!("✓ Max batch size verified: {}", new_max);

    println!("\n=== Router Multicall Test PASSED ===\n");
}

/// End-to-end test for the timelock-guarded route update security pattern.
///
/// This test exercises the primary cross-contract safety pattern described in
/// docs/security.md and docs/architecture.md: sensitive route changes in
/// router-core must pass through the router-timelock delay queue. Without this
/// guard a compromised admin key can redirect any route instantly.
///
/// Flow:
///   1. Deploy + initialize router-core and router-timelock.
///   2. Register an initial route in router-core.
///   3. Queue a route-update operation in router-timelock.
///   4. Call execute BEFORE the ETA — expect NotReady (error code 5).
///   5. Advance past the ETA (testnet: wait; unit env: ledger.timestamp +=).
///   6. Call execute AFTER the ETA — expect success.
///   7. Manually apply the route update in router-core (execute marks the op
///      done; the actual cross-contract call is the next step in the flow).
///   8. Resolve the route — verify it reflects the new address.
///
/// NOTE: Because testnet time cannot be fast-forwarded via CLI, step 5 uses
/// the minimum delay (60 s) and waits for real time to elapse. In the
/// soroban-sdk unit environment (see cross_contract_tests.rs) the ledger
/// timestamp is manipulated directly.
#[test]
#[ignore] // Run with: cargo test --test integration_tests -- --ignored --test-threads=1
fn test_timelock_guarded_route_update() {
    println!("\n=== Testing Timelock-Guarded Route Update Flow ===\n");

    let fixture = TestSuite::setup().expect("Failed to set up test suite");

    let core = fixture
        .router_core
        .as_ref()
        .expect("Core contract not deployed");
    let timelock = fixture
        .router_timelock
        .as_ref()
        .expect("Timelock contract not deployed");
    let admin = &fixture.admin;

    // ── Step 1: Contracts are already deployed and initialized by TestSuite::setup().
    // router-timelock was initialized with min_delay = 60 seconds.
    println!("✓ Contracts deployed and initialized by TestSuite");

    // ── Step 2: Register an initial route in router-core.
    println!("\n--- Step 2: Register initial route ---");
    let initial_addr = TestAccount::generate()
        .expect("Failed to generate initial address")
        .address;

    core.invoke(
        "register_route",
        &[
            "--caller",
            &admin.address,
            "--name",
            "oracle",
            "--address",
            &initial_addr,
            "--metadata",
            "null",
        ],
        admin,
    )
    .expect("Failed to register initial route");

    let resolved = core
        .invoke("resolve", &["--name", "oracle"], admin)
        .expect("Failed to resolve initial route");
    assert!(
        resolved.contains(&initial_addr),
        "Initial route should resolve to initial_addr, got: {}",
        resolved
    );
    println!(
        "✓ Route 'oracle' registered and resolves to: {}",
        initial_addr
    );

    // ── Step 3: Queue a route-update operation in router-timelock.
    // The operation target is the new address we intend to point the route at.
    println!("\n--- Step 3: Queue route update in router-timelock ---");
    let new_addr = TestAccount::generate()
        .expect("Failed to generate new address")
        .address;

    // delay = 60 s (equals min_delay), grace_period = 120 s, no dependencies.
    let op_id_result = timelock.invoke(
        "queue",
        &[
            "--proposer",
            &admin.address,
            "--description",
            "Update oracle route to new address",
            "--target",
            &new_addr,
            "--delay",
            "60",
            "--grace_period_seconds",
            "120",
            "--deps",
            "[]",
        ],
        admin,
    );
    assert!(
        op_id_result.is_ok(),
        "Failed to queue operation: {:?}",
        op_id_result
    );
    let op_id = op_id_result.unwrap();
    println!("✓ Operation queued, op_id: {}", op_id);

    // Confirm the operation is in Queued state (not yet Ready).
    let status = timelock
        .invoke("get_operation_status", &["--op_id", &op_id], admin)
        .expect("Failed to get operation status");
    assert!(
        status.contains("Queued"),
        "Operation should be Queued before ETA, got: {}",
        status
    );
    println!("✓ Operation status is Queued (ETA not yet reached)");

    // ── Step 4: Call execute BEFORE the ETA — must return NotReady (error code 5).
    println!("\n--- Step 4: Execute before ETA (should fail with NotReady) ---");
    let early_result = timelock.try_invoke(
        "execute",
        &["--caller", &admin.address, "--op_id", &op_id],
        admin,
    );
    assert!(
        early_result.is_err(),
        "execute before ETA should fail, but got: {:?}",
        early_result
    );
    let early_error = early_result.err().unwrap();
    assert!(
        early_error.contains("NotReady") || early_error.contains("5"),
        "Expected NotReady (error code 5), got: {}",
        early_error
    );
    println!(
        "✓ execute before ETA correctly rejected with NotReady: {}",
        early_error
    );

    // ── Step 5: Wait for the ETA to pass on testnet (min_delay = 60 s).
    // We add a small buffer (5 s) to account for block time variance.
    println!("\n--- Step 5: Waiting 65 s for ETA to pass on testnet ---");
    std::thread::sleep(std::time::Duration::from_secs(65));
    println!("✓ ETA has elapsed");

    // Confirm the operation status has transitioned to Ready.
    let status = timelock
        .invoke("get_operation_status", &["--op_id", &op_id], admin)
        .expect("Failed to get operation status after wait");
    assert!(
        status.contains("Ready"),
        "Operation should be Ready after ETA, got: {}",
        status
    );
    println!("✓ Operation status is Ready");

    // ── Step 6: Call execute AFTER the ETA — expect success.
    println!("\n--- Step 6: Execute after ETA (should succeed) ---");
    timelock
        .invoke(
            "execute",
            &["--caller", &admin.address, "--op_id", &op_id],
            admin,
        )
        .expect("Failed to execute timelock operation after ETA");

    // Verify the operation is now in Executed state.
    let status = timelock
        .invoke("get_operation_status", &["--op_id", &op_id], admin)
        .expect("Failed to get operation status after execute");
    assert!(
        status.contains("Executed"),
        "Operation should be Executed, got: {}",
        status
    );
    println!("✓ Timelock operation executed successfully");

    // ── Step 7: Apply the route update in router-core.
    // The timelock execute() marks the op done but does NOT perform the
    // cross-contract call itself (the current router-timelock design records
    // the intended target address in the Op struct for off-chain actors or a
    // future executor integration to act upon). The admin now performs the
    // actual route update, which in production would be triggered by the
    // timelock execution event.
    println!("\n--- Step 7: Apply route update in router-core ---");
    core.invoke(
        "update_route",
        &[
            "--caller",
            &admin.address,
            "--name",
            "oracle",
            "--new_address",
            &new_addr,
        ],
        admin,
    )
    .expect("Failed to update route in router-core");
    println!("✓ Route updated in router-core");

    // ── Step 8: Resolve the route and verify it reflects the new address.
    println!("\n--- Step 8: Resolve route (should return new address) ---");
    let resolved = core
        .invoke("resolve", &["--name", "oracle"], admin)
        .expect("Failed to resolve updated route");
    assert!(
        resolved.contains(&new_addr),
        "Route should resolve to new_addr '{}', got: '{}'",
        new_addr,
        resolved
    );
    // Explicitly confirm the old address is gone.
    assert!(
        !resolved.contains(&initial_addr),
        "Route should no longer resolve to initial_addr '{}', got: '{}'",
        initial_addr,
        resolved
    );
    println!("✓ Route resolves to new address: {}", resolved);

    println!("\n=== Timelock-Guarded Route Update Test PASSED ===\n");
}

#[test]
#[ignore]
fn test_admin_transfer() {
    println!("\n=== Testing Admin Transfer ===\n");

    let fixture = TestSuite::setup().expect("Failed to set up test suite");

    let core = fixture
        .router_core
        .as_ref()
        .expect("Core contract not deployed");
    let admin = &fixture.admin;
    let new_admin = &fixture.user1;

    // Test 1: Get current admin
    println!("\n--- Test 1: Get Current Admin ---");
    let current_admin = core
        .invoke("admin", &[], admin)
        .expect("Failed to get admin");
    assert!(current_admin.contains(&admin.address));
    println!("✓ Current admin: {}", current_admin);

    // Test 2: Transfer admin
    println!("\n--- Test 2: Transfer Admin ---");
    core.invoke(
        "transfer_admin",
        &[
            "--current",
            &admin.address,
            "--new_admin",
            &new_admin.address,
        ],
        admin,
    )
    .expect("Failed to transfer admin");
    println!("✓ Admin transferred to user1");

    // Test 3: Verify new admin
    let current_admin = core
        .invoke("admin", &[], new_admin)
        .expect("Failed to get new admin");
    assert!(current_admin.contains(&new_admin.address));
    println!("✓ New admin verified: {}", current_admin);

    println!("\n=== Admin Transfer Test PASSED ===\n");
}