Testing

aztec test

use crate::MyContract;
use aztec::{
    protocol_types::address::AztecAddress,
    test::helpers::test_environment::TestEnvironment,
};
 
#[test]
unconstrained fn test_basic_flow() {
    // 1. Create test environment
    let mut env = TestEnvironment::new();
 
    // 2. Create accounts
    let owner = env.create_light_account();
}

let deployer = env.deploy("ContractName");
 
// If on a different crate:
let deployer = env.deploy("../other_contract");

let initializer = MyContract::interface().constructor(param1, param2);
 
let contract_address = deployer.with_private_initializer(owner, initializer);
let contract_address = deployer.with_public_initializer(owner, initializer);
let contract_address = deployer.without_initializer();

pub unconstrained fn setup(initial_value: Field) -> (TestEnvironment, AztecAddress, AztecAddress) {
    let mut env = TestEnvironment::new();
    let owner = env.create_light_account();
    let initializer = MyContract::interface().constructor(initial_value, owner);
    let contract_address = env.deploy("MyContract").with_private_initializer(owner, initializer);
    (env, contract_address, owner)
}
 
#[test]
unconstrained fn test_something() {
    let (env, contract_address, owner) = setup(42);
    // Your test logic here
}

// Call private function
env.call_private(caller, Token::at(token_address).transfer(recipient, 100));
 
// Returns the result
let result = env.call_private(owner, Contract::at(address).get_private_data());

// Call public function
env.call_public(caller, Token::at(token_address).mint_to_public(recipient, 100));
 
// View public state (read-only)
let balance = env.view_public(Token::at(token_address).balance_of_public(owner));

// Simulate utility/view functions (unconstrained)
let total = env.simulate_utility(Token::at(token_address).balance_of_private(owner));

pub unconstrained fn check_balance(
    env: TestEnvironment,
    token_address: AztecAddress,
    owner: AztecAddress,
    expected: u128,
) {
    assert_eq(
        env.simulate_utility(Token::at(token_address).balance_of_private(owner)),
        expected
    );
}

// Light account - fast, limited features
let owner = env.create_light_account();
 
// Contract account - full features, slower
let owner = env.create_contract_account();

pub unconstrained fn setup(with_authwits: bool) -> (TestEnvironment, AztecAddress, AztecAddress) {
    let mut env = TestEnvironment::new();
    let (owner, recipient) = if with_authwits {
        (env.create_contract_account(), env.create_contract_account())
    } else {
        (env.create_light_account(), env.create_light_account())
    };
    // ... deploy contracts ...
    (env, owner, recipient)
}

use aztec::test::helpers::authwit::{
    add_private_authwit_from_call_interface,
    add_public_authwit_from_call_interface,
};

#[test]
unconstrained fn test_private_authwit() {
    // Setup with contract accounts (required for authwits)
    let (env, token_address, owner, spender) = setup(true);
 
    // Create the call that needs authorization
    let amount = 100;
    let nonce = 7; // Non-zero nonce for authwit
    let burn_call = Token::at(token_address).burn_private(owner, amount, nonce);
 
    // Grant authorization from owner to spender
    add_private_authwit_from_call_interface(owner, spender, burn_call);
 
    // Spender can now execute the authorized action
    env.call_private(spender, burn_call);
}

#[test]
unconstrained fn test_public_authwit() {
    let (env, token_address, owner, spender) = setup(true);
 
    // Create public action that needs authorization
    let transfer_call = Token::at(token_address).transfer_public(owner, recipient, 100, nonce);
 
    // Grant public authorization
    add_public_authwit_from_call_interface(owner, spender, transfer_call);
 
    // Execute with authorization
    env.call_public(spender, transfer_call);
}
 
## Time traveling
 
Contract calls do not advance the timestamp by default, despite each of them resulting in a block with a single transaction. Block timestamp can instead by manually manipulated by any of the following methods:
 
```rust
// Sets the timestamp of the next block to be mined, i.e. of the next public execution. Does not affect private execution.
env.set_next_block_timestamp(block_timestamp);
 
// Same as `set_next_block_timestamp`, but moving time forward by `duration` instead of advancing to a target timestamp.
env.advance_next_block_timestamp_by(duration);
 
// Mines an empty block at a given timestamp, causing the next public execution to occur at this time (like `set_next_block_timestamp`), but also allowing for private execution to happen using this empty block as the anchor block.
env.mine_block_at(block_timestamp);

#[test(should_fail)]
unconstrained fn test_unauthorized_access() {
    let (env, contract, owner) = setup(false);
    let attacker = env.create_light_account();
 
    // This should fail because attacker is not authorized
    env.call_private(attacker, Contract::at(contract).owner_only_function());
}

#[test(should_fail_with = "Balance too low")]
unconstrained fn test_insufficient_balance() {
    let (env, token, owner, recipient) = setup(false);
 
    // Try to transfer more than available
    let balance = 100;
    let transfer_amount = 101;
 
    env.call_private(owner, Token::at(token).transfer(recipient, transfer_amount));
}

#[test(should_fail_with = "Unknown auth witness for message hash")]
unconstrained fn test_missing_authwit() {
    let (env, token, owner, spender) = setup(true);
 
    // Try to burn without authorization
    let burn_call = Token::at(token).burn_private(owner, 100, 1);
 
    // No authwit granted - this should fail
    env.call_private(spender, burn_call);
}