Testing Overview

Learn how to test Anchor programs using various testing strategies and frameworks.

Testing is a critical part of Solana program development. Anchor provides built-in support for testing your programs using TypeScript, Rust, and specialized testing frameworks. This section covers the testing strategies and tools available for Anchor programs.

Testing Strategies

There are three main approaches to testing Anchor programs:

1. Integration Tests - Test your program by deploying it to a local validator and interacting with it through a client
2. Unit Tests - Test individual functions and components in isolation using specialized test frameworks
3. Rust Tests - Write tests directly in Rust using the Anchor Rust client or test frameworks

The anchor test Command

The anchor test command is the primary way to run integration tests for your Anchor programs. It automates the entire testing workflow:

anchor test

When you run anchor test on a localnet cluster, it will:

1. Start a local Solana validator (solana-test-validator)
2. Build your programs using anchor build
3. Deploy your programs to the local validator
4. Run the test files in the tests/ directory
5. Stop the local validator

Common Options

# Skip starting a local validator (useful if already running)
anchor test --skip-local-validator

# Run tests against a specific cluster
anchor test --provider.cluster devnet

# Skip building before testing
anchor test --skip-build

# Skip deployment before testing
anchor test --skip-deploy

Manual Testing Workflow

For more control during development, you can manually run each step:

# Terminal 1: Start local validator
solana-test-validator

# Terminal 2: Build and deploy
anchor build
anchor deploy

# Run tests without starting validator
anchor test --skip-local-validator

This approach is useful when you want to:

• Keep the validator running between test runs
• Inspect accounts on the Solana Explorer
• Debug transaction logs in real-time
• Iterate quickly without restarting the validator

TypeScript Integration Tests

The default test template uses TypeScript with the Anchor client library. Tests are located in the tests/ directory.

Basic Test Structure

Here’s a simple test example:

import * as anchor from "@anchor-lang/core";
import { Program } from "@anchor-lang/core";
import { MyProgram } from "../target/types/my_program";
import { assert } from "chai";

describe("my-program", () => {
  // Configure the client to use the local cluster
  const provider = anchor.AnchorProvider.env();
  anchor.setProvider(provider);

  const program = anchor.workspace.MyProgram as Program<MyProgram>;

  it("Initializes an account", async () => {
    const myAccount = anchor.web3.Keypair.generate();

    const tx = await program.methods
      .initialize()
      .accounts({
        myAccount: myAccount.publicKey,
        user: provider.wallet.publicKey,
        systemProgram: anchor.web3.SystemProgram.programId,
      })
      .signers([myAccount])
      .rpc();

    console.log("Transaction signature:", tx);

    // Fetch and verify the account
    const account = await program.account.myAccount.fetch(
      myAccount.publicKey
    );
    assert.ok(account.initialized);
  });
});

Advanced Test Example

Here’s a more complex example testing an escrow program:

import * as anchor from "@anchor-lang/core";
import { Program } from "@anchor-lang/core";
import { TOKEN_PROGRAM_ID, Token } from "@solana/spl-token";
import { assert } from "chai";
import { Escrow } from "../target/types/escrow";

describe("escrow", () => {
  const provider = anchor.AnchorProvider.env();
  anchor.setProvider(provider);

  const program = anchor.workspace.Escrow as Program<Escrow>;
  
  let mintA: Token;
  let initializerTokenAccountA: anchor.web3.PublicKey;
  const initializerAmount = 500;

  it("Initializes escrow", async () => {
    const payer = anchor.web3.Keypair.generate();
    const mintAuthority = anchor.web3.Keypair.generate();

    // Airdrop SOL to payer
    await provider.connection.confirmTransaction(
      await provider.connection.requestAirdrop(
        payer.publicKey,
        10000000000
      )
    );

    // Create mint
    mintA = await Token.createMint(
      provider.connection,
      payer,
      mintAuthority.publicKey,
      null,
      0,
      TOKEN_PROGRAM_ID
    );

    // Create token account
    initializerTokenAccountA = await mintA.createAccount(
      provider.wallet.publicKey
    );

    // Mint tokens
    await mintA.mintTo(
      initializerTokenAccountA,
      mintAuthority.publicKey,
      [mintAuthority],
      initializerAmount
    );

    // Initialize escrow
    const escrowAccount = anchor.web3.Keypair.generate();
    
    await program.methods
      .initialize(
        new anchor.BN(initializerAmount),
        new anchor.BN(1000)
      )
      .accounts({
        initializer: provider.wallet.publicKey,
        escrowAccount: escrowAccount.publicKey,
        initializerDepositTokenAccount: initializerTokenAccountA,
        systemProgram: anchor.web3.SystemProgram.programId,
        tokenProgram: TOKEN_PROGRAM_ID,
      })
      .signers([escrowAccount])
      .rpc();

    // Verify escrow state
    const escrowState = await program.account.escrowAccount.fetch(
      escrowAccount.publicKey
    );
    assert.ok(escrowState.initializerAmount.eq(new anchor.BN(initializerAmount)));
  });
});

Rust Tests

You can write tests in Rust using the Anchor Rust client. To initialize a project with Rust tests:

anchor init --test-template rust my-program

Rust test files are located in tests/src/:

use anchor_client::{
    solana_sdk::{
        commitment_config::CommitmentConfig,
        pubkey::Pubkey,
        signature::read_keypair_file,
    },
    Client, Cluster,
};
use std::str::FromStr;

#[test]
fn test_initialize() {
    let program_id = "YourProgramID111111111111111111111111111";
    let anchor_wallet = std::env::var("ANCHOR_WALLET").unwrap();
    let payer = read_keypair_file(&anchor_wallet).unwrap();

    let client = Client::new_with_options(
        Cluster::Localnet,
        &payer,
        CommitmentConfig::confirmed(),
    );
    
    let program_id = Pubkey::from_str(program_id).unwrap();
    let program = client.program(program_id).unwrap();

    let tx = program
        .request()
        .accounts(my_program::accounts::Initialize {})
        .args(my_program::instruction::Initialize {})
        .send()
        .expect("Transaction failed");

    println!("Transaction signature: {}", tx);
}

Test Configuration

Test behavior is configured in Anchor.toml:

[provider]
cluster = "Localnet"  # or "Devnet", "Mainnet"
wallet = "~/.config/solana/id.json"

[scripts]
test = "yarn run ts-mocha -p ./tsconfig.json -t 1000000 tests/**/*.ts"

Program Logs

When running tests, program logs are automatically streamed to:

.anchor/program-logs/<address>.<program-name>.log

You can use msg!() in your program code to add debug logging:

use anchor_lang::prelude::*;

#[program]
pub mod my_program {
    use super::*;
    
    pub fn initialize(ctx: Context<Initialize>) -> Result<()> {
        msg!("Initializing with user: {}", ctx.accounts.user.key());
        Ok(())
    }
}

Specialized Testing Frameworks

For more advanced testing scenarios, Anchor supports specialized testing frameworks:

• [LiteSVMtesting/litesvm) - Fast and lightweight in-process testing in Rust, TypeScript, and Python
• [Mollusktesting/mollusk) - Lightweight Rust testing harness for direct SVM program execution

These frameworks offer:

• Faster test execution (no validator startup time)
• More control over the test environment
• Advanced features like time travel and arbitrary account manipulation
• Better isolation for unit testing

Best Practices

1. Write tests early - Use Test-Driven Development (TDD) to write tests before implementing features
2. Test edge cases - Include tests for error conditions, boundary values, and invalid inputs
3. Use descriptive test names - Make it clear what each test is verifying
4. Keep tests isolated - Each test should be independent and not rely on other tests
5. Mock external dependencies - Use test accounts and fixtures instead of live accounts when possible
6. Test on devnet before mainnet - Always test on devnet before deploying to mainnet
7. Use continuous integration - Automate testing with CI/CD pipelines

Next Steps

• Learn about [LiteSVMtesting/litesvm) for fast in-process testing
• Explore [Mollusktesting/mollusk) for lightweight Rust testing
• Read about the TypeScript Client
• Check out the Rust Client documentation