Asserzioni

Esistenza dell'Account

Verifica se gli account esistono o sono stati chiusi.

Verifica Esistenza Account

use litesvm_utils::{AssertionHelpers, LiteSVM, Signer, TestHelpers};
use solana_sdk::native_token::LAMPORTS_PER_SOL;

#[test]
fn test_assert_account_exists() {
    let mut svm = LiteSVM::new();

    let alice = svm.create_funded_account(10 * LAMPORTS_PER_SOL).unwrap();

    // This will pass - account exists
    svm.assert_account_exists(&alice.pubkey());
}

Verifica Account Chiuso

use litesvm_utils::{AssertionHelpers, LiteSVM, Pubkey};

#[test]
fn test_assert_account_closed() {
    let mut svm = LiteSVM::new();

    // A random pubkey that was never created
    let nonexistent = Pubkey::new_unique();

    // This will pass - account doesn't exist
    svm.assert_account_closed(&nonexistent);
}

assert_account_closed ha esito positivo quando un account non esiste, ha zero lamport, oppure ha dati vuoti. Usalo per verificare la pulizia dopo la chiusura degli account.

Asserzioni sui Saldi

Verifica i saldi di SOL e token.

Verifica Saldo SOL

use litesvm_utils::{AssertionHelpers, LiteSVM, Signer, TestHelpers};
use solana_sdk::native_token::LAMPORTS_PER_SOL;

#[test]
fn test_assert_sol_balance() {
    let mut svm = LiteSVM::new();

    let alice = svm.create_funded_account(10 * LAMPORTS_PER_SOL).unwrap();

    // Verify Alice has 10 SOL
    svm.assert_sol_balance(&alice.pubkey(), 10 * LAMPORTS_PER_SOL);
}

Verifica Saldo Token

use litesvm_utils::{AssertionHelpers, LiteSVM, Signer, TestHelpers};
use solana_sdk::native_token::LAMPORTS_PER_SOL;

#[test]
fn test_assert_token_balance() {
    let mut svm = LiteSVM::new();

    let authority = svm.create_funded_account(10 * LAMPORTS_PER_SOL).unwrap();
    let user = svm.create_funded_account(5 * LAMPORTS_PER_SOL).unwrap();

    // Create mint and token account
    let mint = svm.create_token_mint(&authority, 9).unwrap();
    let user_ata = svm.create_associated_token_account(&mint.pubkey(), &user).unwrap();

    // Mint tokens
    svm.mint_to(&mint.pubkey(), &user_ata, &authority, 5000).unwrap();

    // Verify balance
    svm.assert_token_balance(&user_ata, 5000);
}

Verifica Supply del Mint

use litesvm_utils::{AssertionHelpers, LiteSVM, Signer, TestHelpers};
use solana_sdk::native_token::LAMPORTS_PER_SOL;

#[test]
fn test_assert_mint_supply() {
    let mut svm = LiteSVM::new();

    let authority = svm.create_funded_account(10 * LAMPORTS_PER_SOL).unwrap();
    let user1 = svm.create_funded_account(5 * LAMPORTS_PER_SOL).unwrap();
    let user2 = svm.create_funded_account(5 * LAMPORTS_PER_SOL).unwrap();

    // Create mint (returns Keypair)
    let mint = svm.create_token_mint(&authority, 9).unwrap();

    // Create ATAs and mint tokens
    let user1_ata = svm.create_associated_token_account(&mint.pubkey(), &user1).unwrap();
    let user2_ata = svm.create_associated_token_account(&mint.pubkey(), &user2).unwrap();

    svm.mint_to(&mint.pubkey(), &user1_ata, &authority, 1000).unwrap();
    svm.mint_to(&mint.pubkey(), &user2_ata, &authority, 2000).unwrap();

    // Verify total supply
    svm.assert_mint_supply(&mint.pubkey(), 3000);
}

Proprietà dell'Account

Verifica la proprietà e le proprietà dei dati dell'account.

Verifica Proprietario Account

use litesvm_utils::{AssertionHelpers, LiteSVM, Signer, TestHelpers};
use solana_sdk::{native_token::LAMPORTS_PER_SOL, system_program};

#[test]
fn test_assert_account_owner() {
    let mut svm = LiteSVM::new();

    let alice = svm.create_funded_account(10 * LAMPORTS_PER_SOL).unwrap();

    // Regular accounts are owned by the System Program
    svm.assert_account_owner(&alice.pubkey(), &system_program::id());
}

use litesvm_utils::{AssertionHelpers, LiteSVM, Signer, TestHelpers};
use solana_sdk::native_token::LAMPORTS_PER_SOL;

#[test]
fn test_assert_token_account_owner() {
    let mut svm = LiteSVM::new();

    let authority = svm.create_funded_account(10 * LAMPORTS_PER_SOL).unwrap();
    let user = svm.create_funded_account(5 * LAMPORTS_PER_SOL).unwrap();

    let mint = svm.create_token_mint(&authority, 9).unwrap();
    let user_ata = svm.create_associated_token_account(&mint.pubkey(), &user).unwrap();

    // Token accounts are owned by the Token Program
    svm.assert_account_owner(&user_ata, &spl_token::id());
}

Verifica Lunghezza Dati Account

use litesvm_utils::{AssertionHelpers, LiteSVM, Signer, TestHelpers};
use solana_sdk::native_token::LAMPORTS_PER_SOL;

#[test]
fn test_assert_account_data_len() {
    let mut svm = LiteSVM::new();

    let authority = svm.create_funded_account(10 * LAMPORTS_PER_SOL).unwrap();
    let user = svm.create_funded_account(5 * LAMPORTS_PER_SOL).unwrap();

    let mint = svm.create_token_mint(&authority, 9).unwrap();
    let user_ata = svm.create_associated_token_account(&mint.pubkey(), &user).unwrap();

    // Token mint accounts are 82 bytes
    svm.assert_account_data_len(&mint.pubkey(), 82);

    // Token accounts are 165 bytes
    svm.assert_account_data_len(&user_ata, 165);
}

Dimensioni comuni degli account: - Mint Account: 82 byte - token account: 165 byte - System Account: 0 byte (solo lamport)

Esempio Completo

Ecco un test completo che dimostra asserzioni multiple:

use litesvm_utils::{AssertionHelpers, LiteSVM, Signer, TestHelpers, TransactionHelpers};
use solana_sdk::{native_token::LAMPORTS_PER_SOL, system_instruction};

#[test]
fn test_comprehensive_assertions() {
    let mut svm = LiteSVM::new();

    // Setup
    let admin = svm.create_funded_account(100 * LAMPORTS_PER_SOL).unwrap();
    let alice = svm.create_funded_account(10 * LAMPORTS_PER_SOL).unwrap();
    let bob = svm.create_funded_account(0).unwrap();

    // Verify initial SOL balances
    svm.assert_sol_balance(&admin.pubkey(), 100 * LAMPORTS_PER_SOL);
    svm.assert_sol_balance(&alice.pubkey(), 10 * LAMPORTS_PER_SOL);
    svm.assert_sol_balance(&bob.pubkey(), 0);

    // Transfer SOL from Alice to Bob
    let transfer_ix = system_instruction::transfer(
        &alice.pubkey(),
        &bob.pubkey(),
        5 * LAMPORTS_PER_SOL,
    );
    svm.send_instruction(transfer_ix, &[&alice]).unwrap().assert_success();

    // Verify balances after transfer (Alice paid fees too)
    svm.assert_sol_balance(&bob.pubkey(), 5 * LAMPORTS_PER_SOL);

    // Create token infrastructure (mint returns Keypair, ATAs return Pubkey)
    let mint = svm.create_token_mint(&admin, 6).unwrap();
    let alice_ata = svm.create_associated_token_account(&mint.pubkey(), &alice).unwrap();
    let bob_ata = svm.create_associated_token_account(&mint.pubkey(), &bob).unwrap();

    // Verify account properties
    svm.assert_account_exists(&mint.pubkey());
    svm.assert_account_exists(&alice_ata);
    svm.assert_account_owner(&mint.pubkey(), &spl_token::id());
    svm.assert_account_data_len(&mint.pubkey(), 82);
    svm.assert_account_data_len(&alice_ata, 165);

    // Mint and verify
    svm.mint_to(&mint.pubkey(), &alice_ata, &admin, 1_000_000).unwrap();
    svm.mint_to(&mint.pubkey(), &bob_ata, &admin, 500_000).unwrap();

    svm.assert_token_balance(&alice_ata, 1_000_000);
    svm.assert_token_balance(&bob_ata, 500_000);
    svm.assert_mint_supply(&mint.pubkey(), 1_500_000);

    println!("All assertions passed!");
}

Gestione dei Fallimenti delle Asserzioni

Quando un'asserzione fallisce, genererà un panic con un messaggio descrittivo:

// This will panic with a message like:
// "Expected token balance 1000, but got 500"
svm.assert_token_balance(&some_ata, 1000); // when balance is actually 500

Le asserzioni sono progettate per fallire rapidamente con messaggi di errore chiari. Usale liberamente nei tuoi test per individuare i problemi in anticipo.

Indice dei contenuti