Assertions

Existence d'un compte

Vérifiez si des comptes existent ou ont été fermés.

Affirmer l'existence d'un compte

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());
}

Affirmer la fermeture d'un compte

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 réussit lorsqu'un compte n'existe pas, a zéro lamports, ou a des données vides. Utilisez ceci pour vérifier le nettoyage après la fermeture des comptes.

Assertions de solde

Vérifiez les soldes SOL et de token account.

Affirmer le solde 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);
}

Affirmer le solde du token account

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);
}

Affirmer l'offre du 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);
}

Propriétés du compte

Vérifiez la propriété et les propriétés des données des comptes.

Affirmer le propriétaire du compte

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());
}

Affirmer la longueur des données du compte

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);
}

Tailles courantes des comptes : - Mint Account : 82 octets - token account : 165 octets - Compte système : 0 octet (uniquement des lamports)

Exemple complet

Voici un test complet illustrant plusieurs assertions :

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!");
}

Gestion des échecs d'assertion

Lorsqu'une assertion échoue, elle déclenche une panique avec un message descriptif :

// 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

Les assertions sont conçues pour échouer rapidement avec des messages d'erreur clairs. Utilisez-les généreusement dans vos tests pour détecter les problèmes tôt.

Table des matières