aptos-move-testing

Aptos Move Testing Expert

Expert on testing Move smart contracts on Aptos blockchain.

Triggers

• move test, unit test, integration test
• move prover, formal verification
• debug, coverage, assert, expect
• test failure, debugging

Test Attributes

#[test]
fun test_basic() { }

#[test(account = @0x1)]
fun test_with_signer(account: &signer) { }

#[test(alice = @0x123, bob = @0x456)]
fun test_multi_signer(alice: &signer, bob: &signer) { }

#[test]
#[expected_failure(abort_code = ERROR_CODE)]
fun test_should_fail() { }

#[test_only]
fun helper_function() { }

Basic Testing Pattern

#[test(account = @0x123)]
fun test_resource_creation(account: &signer) {
    let addr = signer::address_of(account);
    
    // Create resource
    create_resource(account);
    
    // Verify exists
    assert!(exists<MyResource>(addr), 0);
    
    // Verify state
    let resource = borrow_global<MyResource>(addr);
    assert!(resource.value == expected, 1);
}

Test Commands

# Run all tests
aptos move test

# Run specific test
aptos move test --filter test_name

# With coverage
aptos move test --coverage

# With gas profiling
aptos move test --gas

# Verbose
aptos move test --verbose

Multi-Signer Testing

#[test(alice = @0x123, bob = @0x456)]
fun test_transfer(alice: &signer, bob: &signer) {
    let alice_addr = signer::address_of(alice);
    let bob_addr = signer::address_of(bob);
    
    initialize(alice);
    initialize(bob);
    
    transfer(alice, bob_addr, 100);
    
    assert!(get_balance(alice_addr) == 900, 0);
    assert!(get_balance(bob_addr) == 100, 1);
}

Error Testing

#[test]
#[expected_failure(abort_code = ERROR_INSUFFICIENT_BALANCE)]
fun test_insufficient_balance() {
    transfer(from, to, amount_too_large);
}

#[test]
#[expected_failure]  // Any failure
fun test_any_failure() {
    assert!(false, 0);
}

Test-Only Helpers

#[test_only]
module test_helpers {
    public fun setup_account(account: &signer): address {
        let addr = signer::address_of(account);
        // Setup logic
        addr
    }
}

Debugging

#[test_only]
use std::debug;

#[test]
fun test_with_debug() {
    debug::print(&b"Value:");
    debug::print(&value);
}

Move Prover Specs

spec transfer {
    requires sender_balance >= amount;
    ensures global<Balance>(sender).value == 
            old(global<Balance>(sender).value) - amount;
    aborts_if sender_balance < amount;
}

spec module {
    invariant forall addr: address:
        exists<Balance>(addr) ==> global<Balance>(addr).value >= 0;
}

# Run prover
aptos move prove
aptos move prove --filter MyModule

Coverage Goals

Test coverage should include:

• All public functions
• All abort conditions
• All state transitions
• All access control checks
• Edge cases (zero, max values, empty)

Common Issues

Resource Already Exists

// Check existence first
if (!exists<Resource>(addr)) {
    move_to(account, Resource {});
}

Need Signer

// Use test parameter
#[test(account = @0x1)]
fun test_with_signer(account: &signer) { }

Test Timeout

// Reduce iterations
#[test]
fun test_optimized() {
    for (i in 0..100) { }  // Not 1000000
}

CI/CD Integration

name: Move Tests
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Install Aptos CLI
        run: curl -fsSL "https://aptos.dev/scripts/install_cli.py" | python3
      - name: Run Tests
        run: aptos move test --coverage
      - name: Run Prover
        run: aptos move prove

Best Practices

• Test all public functions
• Test all error conditions
• Use specific abort codes
• Break complex tests into smaller ones
• Use test-only helpers for setup
• Profile gas usage in tests
• Run prover for critical code