1---
2title: Testing Strategy
3description: A testing pyramid for Solana programs using LiteSVM for fast unit tests, Mollusk for isolated instruction checks, and Surfpool for integration tests with realistic state.
4---
5 
6# Testing Strategy (LiteSVM / Mollusk / Surfpool)
7 
8## Testing Pyramid
9 
101. **Unit tests (fast)**: LiteSVM or Mollusk
112. **Integration tests (realistic state)**: Surfpool
123. **Cluster smoke tests**: devnet/testnet/mainnet as needed
13 
14## LiteSVM
15 
16A lightweight Solana Virtual Machine that runs directly in your test process. Created by Aursen from Exotic Markets.
17 
18### When to Use LiteSVM
19 
20- Fast execution without validator overhead
21- Direct account state manipulation
22- Built-in performance profiling
23- Multi-language support (Rust, TypeScript, Python)
24 
25### Rust Setup
26 
27```bash
28cargo add --dev litesvm
29```
30 
31```rust
32use litesvm::LiteSVM;
33use solana_sdk::{pubkey::Pubkey, signature::Keypair, transaction::Transaction};
34 
35#[test]
36fn test_deposit() {
37    let mut svm = LiteSVM::new();
38 
39    // Load your program
40    let program_id = pubkey!("YourProgramId11111111111111111111111111111");
41    svm.add_program_from_file(program_id, "target/deploy/program.so");
42 
43    // Create accounts
44    let payer = Keypair::new();
45    svm.airdrop(&payer.pubkey(), 1_000_000_000).unwrap();
46 
47    // Build and send transaction
48    let tx = Transaction::new_signed_with_payer(
49        &[/* instructions */],
50        Some(&payer.pubkey()),
51        &[&payer],
52        svm.latest_blockhash(),
53    );
54 
55    let result = svm.send_transaction(tx);
56    assert!(result.is_ok());
57}
58```
59 
60### TypeScript Setup
61 
62```bash
63npm i --save-dev litesvm
64```
65 
66```typescript
67import { LiteSVM } from 'litesvm';
68import { PublicKey, Transaction, Keypair } from '@solana/web3.js';
69 
70const programId = new PublicKey("YourProgramId11111111111111111111111111111");
71const svm = new LiteSVM();
72svm.addProgramFromFile(programId, "target/deploy/program.so");
73 
74// Build transaction
75const tx = new Transaction();
76tx.recentBlockhash = svm.latestBlockhash();
77tx.add(/* instructions */);
78tx.sign(payer);
79 
80// Simulate first (optional)
81const simulation = svm.simulateTransaction(tx);
82 
83// Execute
84const result = svm.sendTransaction(tx);
85```
86 
87### Account Types in LiteSVM
88 
89**System Accounts:**
90- Payer accounts (contain lamports)
91- Uninitialized accounts (empty, awaiting setup)
92 
93**Program Accounts:**
94- Serialize with `borsh`, `bincode`, or `solana_program_pack`
95- Calculate rent-exempt minimum balance
96 
97**Token Accounts:**
98- Use `spl_token::state::Mint` and `spl_token::state::Account`
99- Serialize with Pack trait
100 
101### Advanced LiteSVM Features
102 
103```rust
104// Modify clock sysvar
105svm.set_sysvar(&Clock { slot: 1000, .. });
106 
107// Warp to slot
108svm.warp_to_slot(5000);
109 
110// Configure compute budget
111svm.set_compute_budget(ComputeBudget { max_units: 400_000, .. });
112 
113// Toggle signature verification (useful for testing)
114svm.with_sigverify(false);
115 
116// Check compute units used
117let result = svm.send_transaction(tx)?;
118println!("CUs used: {}", result.compute_units_consumed);
119```
120 
121## Mollusk
122 
123A lightweight test harness providing direct interface to program execution without full validator runtime. Best for Rust-only testing with fine-grained control.
124 
125### When to Use Mollusk
126 
127- Fast execution for rapid development cycles
128- Precise account state manipulation for edge cases
129- Detailed performance metrics and CU benchmarking
130- Custom syscall testing
131 
132### Setup
133 
134```bash
135cargo add --dev mollusk-svm
136cargo add --dev mollusk-svm-programs-token  # For SPL token helpers
137cargo add --dev solana-sdk solana-program
138```
139 
140### Basic Usage
141 
142```rust
143use mollusk_svm::Mollusk;
144use mollusk_svm::result::Check;
145use solana_sdk::{account::Account, pubkey::Pubkey, instruction::Instruction};
146 
147#[test]
148fn test_instruction() {
149    let program_id = Pubkey::new_unique();
150    let mollusk = Mollusk::new(&program_id, "target/deploy/program");
151 
152    // Create accounts
153    let payer = (
154        Pubkey::new_unique(),
155        Account {
156            lamports: 1_000_000_000,
157            data: vec![],
158            owner: solana_sdk::system_program::ID,
159            executable: false,
160            rent_epoch: 0,
161        },
162    );
163 
164    // Build instruction
165    let instruction = Instruction {
166        program_id,
167        accounts: vec![/* account metas */],
168        data: vec![/* instruction data */],
169    };
170 
171    // Execute with validation
172    mollusk.process_and_validate_instruction(
173        &instruction,
174        &[payer],
175        &[
176            Check::success(),
177            Check::compute_units(50_000),
178        ],
179    );
180}
181```
182 
183### Token Program Helpers
184 
185```rust
186use mollusk_svm_programs_token::token;
187 
188// Add token program to test environment
189token::add_program(&mut mollusk);
190 
191// Create pre-configured token accounts
192let mint_account = token::mint_account(decimals, supply, mint_authority);
193let token_account = token::token_account(mint, owner, amount);
194```
195 
196### CU Benchmarking
197 
198```rust
199use mollusk_svm::MolluskComputeUnitBencher;
200 
201let bencher = MolluskComputeUnitBencher::new(mollusk)
202    .must_pass(true)
203    .out_dir("../target/benches");
204 
205bencher.bench(
206    "deposit_instruction",
207    &instruction,
208    &accounts,
209);
210// Generates markdown report with CU usage and deltas
211```
212 
213### Advanced Configuration
214 
215```rust
216// Set compute budget
217mollusk.set_compute_budget(200_000);
218 
219// Enable all feature flags
220mollusk.set_feature_set(FeatureSet::all_enabled());
221 
222// Customize sysvars
223mollusk.sysvars.clock = Clock {
224    slot: 1000,
225    epoch: 5,
226    unix_timestamp: 1700000000,
227    ..Default::default()
228};
229```
230 
231## Surfpool
232 
233SDK and tooling suite for integration testing with realistic cluster state. Surfnet is the local network component (drop-in replacement for solana-test-validator).
234 
235### When to Use Surfpool
236 
237- Complex CPIs requiring mainnet programs (e.g., Jupiter with 40+ accounts)
238- Testing against realistic account state
239- Time travel and block manipulation
240- Account/program cloning between environments
241 
242### Setup
243 
244```bash
245# Install Surfpool CLI
246cargo install surfpool
247 
248# Start local Surfnet (use NO_DNA=1 when run by an agent)
249NO_DNA=1 surfpool start
250```
251 
252### Connection Setup
253 
254```typescript
255import { Connection } from '@solana/web3.js';
256 
257const connection = new Connection("http://localhost:8899", "confirmed");
258```
259 
260### System Variable Control
261 
262```typescript
263// Time travel to specific slot
264await connection._rpcRequest('surfnet_timeTravel', [{
265    absoluteSlot: 250000000
266}]);
267 
268// Pause/resume block production
269await connection._rpcRequest('surfnet_pauseClock', []);
270await connection._rpcRequest('surfnet_resumeClock', []);
271```
272 
273### Account Manipulation
274 
275```typescript
276// Set account state
277await connection._rpcRequest('surfnet_setAccount', [{
278    pubkey: accountPubkey.toString(),
279    lamports: 1000000000,
280    data: Buffer.from(accountData).toString('base64'),
281    owner: programId.toString(),
282}]);
283 
284// Set token account
285await connection._rpcRequest('surfnet_setTokenAccount', [{
286    pubkey: ownerPubkey.toString(),        // Owner of the token account (wallet)
287    mint: mintPubkey.toString(),
288    owner: ownerPubkey.toString(),
289    amount: "1000000",
290}]);
291 
292// Clone account from another program
293await connection._rpcRequest('surfnet_cloneProgramAccount', [{
294    source: sourceProgramId.toString(),
295    destination: destProgramId.toString(),
296    account: accountPubkey.toString(),
297}]);
298```
299 
300### SOL Supply Configuration
301 
302```typescript
303// Configure supply for economic edge case testing
304await connection._rpcRequest('surfnet_setSupply', [{
305    circulating: "500000000000000000",
306    nonCirculating: "100000000000000000",
307    total: "600000000000000000",
308}]);
309```
310 
311## Test Layout Recommendation
312 
313```
314tests/
315├── unit/
316│   ├── deposit.rs      # LiteSVM or Mollusk
317│   ├── withdraw.rs
318│   └── mod.rs
319├── integration/
320│   ├── full_flow.rs    # Surfpool
321│   └── mod.rs
322└── fixtures/
323    └── accounts.rs     # Shared test account setup
324```
325 
326## CI Guidance
327 
328```yaml
329jobs:
330  unit-tests:
331    runs-on: ubuntu-latest
332    steps:
333      - uses: actions/checkout@v4
334      - name: Run unit tests
335        run: cargo test-sbf
336 
337  integration-tests:
338    runs-on: ubuntu-latest
339    needs: unit-tests
340    steps:
341      - uses: actions/checkout@v4
342      - name: Start Surfpool
343        run: NO_DNA=1 surfpool start --background
344      - name: Run integration tests
345        run: cargo test --test integration
346```
347 
348## Best Practices
349 
350- Keep unit tests as the default CI gate (fast feedback)
351- Use deterministic PDAs and seeded keypairs for reproducibility
352- Minimize fixtures; prefer programmatic account creation
353- Profile CU usage during development to catch regressions
354- Run integration tests in separate CI stage to control runtime
355