d0zingcat/ore
1
0
Fork 0
mirror of https://github.com/d0zingcat/ore.git synced 2026-05-14 07:26:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

loaders unit tests

Browse Source
This commit is contained in:
Hardhat Chad
2024-03-24 20:51:47 +00:00
parent 0836c40f89
commit 0aeb60edb9
3 changed files with 983 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

940
src/loaders.rs
View File

@@ -276,6 +276,7 @@ pub fn load_uninitialized_account<'a, 'info>(
if !info.is_writable {
return Err(ProgramError::InvalidAccountData);
}
Ok(())
}
@@ -329,3 +330,942 @@ pub fn load_program<'a, 'info>(
Ok(())
}
#[cfg(test)]
mod tests {
use solana_program::{
account_info::AccountInfo, keccak::Hash as KeccakHash, program_option::COption,
program_pack::Pack, pubkey::Pubkey, system_program,
};
use spl_token::state::{AccountState, Mint};
use crate::{
loaders::{
load_account, load_any_bus, load_bus, load_mint, load_proof, load_signer, load_sysvar,
load_token_account, load_treasury, load_uninitialized_account, load_uninitialized_pda,
},
state::{Bus, Proof, Treasury},
utils::Discriminator,
BUS, BUS_ADDRESSES, BUS_COUNT, MINT_ADDRESS, PROOF, TOKEN_DECIMALS, TREASURY,
TREASURY_ADDRESS,
};
use super::load_program;
#[test]
pub fn test_signer_not_signer() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = system_program::id();
let info = AccountInfo::new(
&key,
false,
false,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_signer(&info).is_err());
}
#[test]
pub fn test_load_bus_bad_account_owner() {
let key = BUS_ADDRESSES[0];
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = system_program::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_bus(&info, 0, true).is_err());
}
#[test]
pub fn test_load_bus_bad_key() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = crate::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_bus(&info, 0, true).is_err());
}
#[test]
pub fn test_load_bus_empty_data() {
let key = BUS_ADDRESSES[0];
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = crate::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_bus(&info, 0, true).is_err());
}
#[test]
pub fn test_load_bus_bad_data() {
let key = BUS_ADDRESSES[0];
let mut lamports = 1_000_000_000;
let mut data = [
&(Treasury::discriminator() as u64).to_le_bytes(), // Bus discriminator
Bus { id: 0, rewards: 0 }.to_bytes(),
]
.concat();
let owner = crate::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_bus(&info, 0, true).is_err());
}
#[test]
pub fn test_load_bus_bad_id() {
let key = BUS_ADDRESSES[0];
let mut lamports = 1_000_000_000;
let mut data = [
&(Bus::discriminator() as u64).to_le_bytes(), // Bus discriminator
Bus { id: 1, rewards: 0 }.to_bytes(),
]
.concat();
let owner = crate::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_bus(&info, 0, true).is_err());
}
#[test]
pub fn test_load_bus_not_writeable() {
let key = BUS_ADDRESSES[0];
let mut lamports = 1_000_000_000;
let mut data = [
&(Bus::discriminator() as u64).to_le_bytes(),
Bus { id: 0, rewards: 0 }.to_bytes(),
]
.concat();
let owner = crate::id();
let info = AccountInfo::new(
&key,
false,
false,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_bus(&info, 0, true).is_err());
}
#[test]
pub fn test_load_any_bus_bad_account_owner() {
let key = BUS_ADDRESSES[0];
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = system_program::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_any_bus(&info, true).is_err());
}
#[test]
pub fn test_load_any_bus_bad_key() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = crate::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_any_bus(&info, true).is_err());
}
#[test]
pub fn test_load_any_bus_empty_data() {
let key = BUS_ADDRESSES[0];
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = crate::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_any_bus(&info, true).is_err());
}
#[test]
pub fn test_load_any_bus_bad_data() {
let key = BUS_ADDRESSES[0];
let mut lamports = 1_000_000_000;
let mut data = [
&(Treasury::discriminator() as u64).to_le_bytes(), // Treasury discriminator
Bus { id: 0, rewards: 0 }.to_bytes(),
]
.concat();
let owner = crate::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_any_bus(&info, true).is_err());
}
#[test]
pub fn test_load_any_bus_bad_id() {
let key = BUS_ADDRESSES[0];
let mut lamports = 1_000_000_000;
let mut data = [
&(Bus::discriminator() as u64).to_le_bytes(),
Bus {
id: (BUS_COUNT + 1) as u64,
rewards: 0,
}
.to_bytes(),
]
.concat();
let owner = crate::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_any_bus(&info, true).is_err());
}
#[test]
pub fn test_load_any_bus_mismatch_id() {
let key = BUS_ADDRESSES[0];
let mut lamports = 1_000_000_000;
let mut data = [
&(Bus::discriminator() as u64).to_le_bytes(),
Bus {
id: 1 as u64,
rewards: 0,
}
.to_bytes(),
]
.concat();
let owner = crate::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_any_bus(&info, true).is_err());
}
#[test]
pub fn test_load_any_bus_not_writeable() {
let key = BUS_ADDRESSES[0];
let mut lamports = 1_000_000_000;
let mut data = [
&(Bus::discriminator() as u64).to_le_bytes(),
Bus { id: 0, rewards: 0 }.to_bytes(),
]
.concat();
let owner = crate::id();
let info = AccountInfo::new(
&key,
false,
false,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_any_bus(&info, true).is_err());
}
#[test]
pub fn test_load_proof_bad_account_owner() {
let authority = Pubkey::new_unique();
let pda = Pubkey::find_program_address(&[PROOF, authority.as_ref()], &crate::id());
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = system_program::id();
let info = AccountInfo::new(
&pda.0,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_proof(&info, &authority, true).is_err());
}
#[test]
pub fn test_load_proof_bad_key() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = crate::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_proof(&info, &Pubkey::new_unique(), true).is_err());
}
#[test]
pub fn test_load_proof_empty_data() {
let authority = Pubkey::new_unique();
let pda = Pubkey::find_program_address(&[PROOF, authority.as_ref()], &crate::id());
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = crate::id();
let info = AccountInfo::new(
&pda.0,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_proof(&info, &authority, true).is_err());
}
#[test]
pub fn test_load_proof_bad_data() {
let authority = Pubkey::new_unique();
let pda = Pubkey::find_program_address(&[PROOF, authority.as_ref()], &crate::id());
let mut lamports = 1_000_000_000;
let mut data = [
&(Bus::discriminator() as u64).to_le_bytes(), // Bus discriminator
Proof {
authority,
claimable_rewards: 0,
hash: KeccakHash::new_from_array([u8::MAX; 32]).into(),
total_hashes: 0,
total_rewards: 0,
}
.to_bytes(),
]
.concat();
let owner = crate::id();
let info = AccountInfo::new(
&pda.0,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_proof(&info, &authority, true).is_err());
}
#[test]
pub fn test_load_proof_not_writeable() {
let authority = Pubkey::new_unique();
let pda = Pubkey::find_program_address(&[PROOF, authority.as_ref()], &crate::id());
let mut lamports = 1_000_000_000;
let mut data = [
&(Proof::discriminator() as u64).to_le_bytes(),
Proof {
authority,
claimable_rewards: 0,
hash: KeccakHash::new_from_array([u8::MAX; 32]).into(),
total_hashes: 0,
total_rewards: 0,
}
.to_bytes(),
]
.concat();
let owner = crate::id();
let info = AccountInfo::new(
&pda.0,
false,
false,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_proof(&info, &authority, true).is_err());
}
#[test]
pub fn test_load_treasury_bad_account_owner() {
let pda = Pubkey::find_program_address(&[TREASURY], &crate::id());
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = system_program::id();
let info = AccountInfo::new(
&pda.0,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_treasury(&info, true).is_err());
}
#[test]
pub fn test_load_treasury_bad_key() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = crate::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_treasury(&info, true).is_err());
}
#[test]
pub fn test_load_treasury_empty_data() {
let key = TREASURY_ADDRESS;
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = crate::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_treasury(&info, true).is_err());
}
#[test]
pub fn test_load_treasury_bad_data() {
let pda = Pubkey::find_program_address(&[TREASURY], &crate::id());
let mut lamports = 1_000_000_000;
let mut data = [
&(Bus::discriminator() as u64).to_le_bytes(), // Bus discriminator
Treasury {
bump: pda.1 as u64,
admin: Pubkey::new_unique(),
difficulty: KeccakHash::new_from_array([u8::MAX; 32]).into(),
last_reset_at: 0,
reward_rate: 100,
total_claimed_rewards: 0,
}
.to_bytes(),
]
.concat();
let owner = crate::id();
let info = AccountInfo::new(
&pda.0,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_treasury(&info, true).is_err());
}
#[test]
pub fn test_load_treasury_not_writeable() {
let pda = Pubkey::find_program_address(&[TREASURY], &crate::id());
let mut lamports = 1_000_000_000;
let mut data = [
&(Treasury::discriminator() as u64).to_le_bytes(),
Treasury {
bump: pda.1 as u64,
admin: Pubkey::new_unique(),
difficulty: KeccakHash::new_from_array([u8::MAX; 32]).into(),
last_reset_at: 0,
reward_rate: 100,
total_claimed_rewards: 0,
}
.to_bytes(),
]
.concat();
let owner = crate::id();
let info = AccountInfo::new(
&pda.0,
false,
false,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_treasury(&info, true).is_err());
}
#[test]
pub fn test_load_mint_bad_account_owner() {
let key = MINT_ADDRESS;
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = system_program::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err());
}
#[test]
pub fn test_load_mint_bad_key() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = spl_token::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_mint(&info, true).is_err());
}
#[test]
pub fn test_load_mint_empty_data() {
let key = MINT_ADDRESS;
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = spl_token::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_mint(&info, true).is_err());
}
#[test]
pub fn test_load_mint_bad_data() {
let key = MINT_ADDRESS;
let mut lamports = 1_000_000_000;
let mut data = [1];
let owner = spl_token::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_mint(&info, true).is_err());
}
#[test]
pub fn test_load_mint_not_writeable() {
let mut data: [u8; Mint::LEN] = [0; Mint::LEN];
Mint {
mint_authority: COption::Some(TREASURY_ADDRESS),
supply: 0,
decimals: TOKEN_DECIMALS,
is_initialized: true,
freeze_authority: COption::None,
}
.pack_into_slice(&mut data);
let key = MINT_ADDRESS;
let mut lamports = 1_000_000_000;
let owner = spl_token::id();
let info = AccountInfo::new(
&key,
false,
false,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_mint(&info, true).is_err());
}
#[test]
pub fn test_load_token_account_bad_account_owner() {
let mut data: [u8; spl_token::state::Account::LEN] = [0; spl_token::state::Account::LEN];
spl_token::state::Account {
mint: MINT_ADDRESS,
owner: TREASURY_ADDRESS,
amount: 2_000_000_000,
delegate: COption::None,
state: AccountState::Initialized,
is_native: COption::None,
delegated_amount: 0,
close_authority: COption::None,
}
.pack_into_slice(&mut data);
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let owner = system_program::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err());
}
#[test]
pub fn test_load_token_account_empty_data() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = spl_token::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err());
}
#[test]
pub fn test_load_token_account_bad_data() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [1];
let owner = spl_token::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err());
}
#[test]
pub fn test_load_token_account_bad_owner_mint() {
let mut data: [u8; spl_token::state::Account::LEN] = [0; spl_token::state::Account::LEN];
spl_token::state::Account {
mint: MINT_ADDRESS,
owner: TREASURY_ADDRESS,
amount: 2_000_000_000,
delegate: COption::None,
state: AccountState::Initialized,
is_native: COption::None,
delegated_amount: 0,
close_authority: COption::None,
}
.pack_into_slice(&mut data);
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let owner = spl_token::id();
let info = AccountInfo::new(
&key,
false,
false,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_token_account(&info, Some(&key), &MINT_ADDRESS, false).is_err());
assert!(load_token_account(&info, None, &Pubkey::new_unique(), false).is_err());
assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err());
}
#[test]
pub fn test_load_uninitialized_pda_bad_key_bump() {
let pda = Pubkey::find_program_address(&[TREASURY], &crate::id());
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = system_program::id();
let info = AccountInfo::new(
&pda.0,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_uninitialized_pda(&info, &[BUS], pda.1, &crate::id()).is_err());
assert!(load_uninitialized_pda(&info, &[TREASURY], 0, &crate::id()).is_err());
}
#[test]
pub fn test_load_uninitialized_account_bad_owner() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = spl_token::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_uninitialized_account(&info).is_err());
}
#[test]
pub fn test_load_uninitialized_account_data_not_empty() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [0];
let owner = system_program::id();
let info = AccountInfo::new(
&key,
false,
true,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_uninitialized_account(&info).is_err());
}
#[test]
pub fn test_load_uninitialized_account_not_writeable() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = system_program::id();
let info = AccountInfo::new(
&key,
false,
false,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_uninitialized_account(&info).is_err());
}
#[test]
pub fn test_load_sysvar_bad_owner() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = system_program::id();
let info = AccountInfo::new(
&key,
false,
false,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_sysvar(&info, key).is_err());
}
#[test]
pub fn test_load_account_bad_key() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = system_program::id();
let info = AccountInfo::new(
&key,
false,
false,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_account(&info, Pubkey::new_unique(), false).is_err());
}
#[test]
pub fn test_load_account_not_writeable() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = system_program::id();
let info = AccountInfo::new(
&key,
false,
false,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_account(&info, key, true).is_err());
}
#[test]
pub fn test_load_program_bad_key() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = system_program::id();
let info = AccountInfo::new(
&key,
false,
false,
&mut lamports,
&mut data,
&owner,
true,
0,
);
assert!(load_program(&info, Pubkey::new_unique()).is_err());
}
#[test]
pub fn test_load_program_not_executable() {
let key = Pubkey::new_unique();
let mut lamports = 1_000_000_000;
let mut data = [];
let owner = system_program::id();
let info = AccountInfo::new(
&key,
false,
false,
&mut lamports,
&mut data,
&owner,
false,
0,
);
assert!(load_program(&info, key).is_err());
}
}

154
tests/test_initialize.rs
View File

@@ -3,12 +3,10 @@ use mpl_token_metadata::{
types::{Key, TokenStandard},
};
use ore::{
instruction::{InitializeArgs, OreInstruction},
state::{Bus, Treasury},
utils::AccountDeserialize,
BUS, BUS_ADDRESSES, BUS_COUNT, INITIAL_DIFFICULTY, INITIAL_REWARD_RATE, METADATA,
METADATA_ADDRESS, METADATA_NAME, METADATA_SYMBOL, METADATA_URI, MINT, MINT_ADDRESS, MINT_NOISE,
TREASURY,
BUS_ADDRESSES, BUS_COUNT, INITIAL_DIFFICULTY, INITIAL_REWARD_RATE, METADATA_ADDRESS,
METADATA_NAME, METADATA_SYMBOL, METADATA_URI, MINT_ADDRESS, TREASURY,
};
use solana_program::{
hash::Hash, program_option::COption, program_pack::Pack, pubkey::Pubkey, rent::Rent,
@@ -119,136 +117,36 @@ async fn test_initialize_not_enough_accounts() {
}
#[tokio::test]
async fn test_initialize_bad_pda() {
async fn test_initialize_bad_key() {
// Setup
let (mut banks, payer, blockhash) = setup_program_test_env().await;
// Pdas
let bus_pdas = [
Pubkey::find_program_address(&[BUS, &[0]], &ore::id()),
Pubkey::find_program_address(&[BUS, &[1]], &ore::id()),
Pubkey::find_program_address(&[BUS, &[2]], &ore::id()),
Pubkey::find_program_address(&[BUS, &[3]], &ore::id()),
Pubkey::find_program_address(&[BUS, &[4]], &ore::id()),
Pubkey::find_program_address(&[BUS, &[5]], &ore::id()),
Pubkey::find_program_address(&[BUS, &[6]], &ore::id()),
Pubkey::find_program_address(&[BUS, &[7]], &ore::id()),
];
let mint_pda = Pubkey::find_program_address(&[MINT, MINT_NOISE.as_slice()], &ore::id());
let treasury_pda = Pubkey::find_program_address(&[TREASURY], &ore::id());
let metadata_pda = Pubkey::find_program_address(
&[
METADATA,
mpl_token_metadata::ID.as_ref(),
mint_pda.0.as_ref(),
],
&mpl_token_metadata::ID,
);
// Bad addresses
let bad_pda = Pubkey::find_program_address(&[b"t"], &ore::id());
for i in 1..12 {
let mut ix = ore::instruction::initialize(payer.pubkey());
ix.accounts[i].pubkey = bad_pda.0;
let tx =
Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
let res = banks.process_transaction(tx).await;
assert!(res.is_err());
}
}
// Bad bus pda
let mut ix = ore::instruction::initialize(payer.pubkey());
ix.accounts[1].pubkey = bad_pda.0;
ix.data = [
OreInstruction::Initialize.to_vec(),
InitializeArgs {
bus_0_bump: bad_pda.1,
bus_1_bump: bus_pdas[1].1,
bus_2_bump: bus_pdas[2].1,
bus_3_bump: bus_pdas[3].1,
bus_4_bump: bus_pdas[4].1,
bus_5_bump: bus_pdas[5].1,
bus_6_bump: bus_pdas[6].1,
bus_7_bump: bus_pdas[7].1,
metadata_bump: metadata_pda.1,
mint_bump: mint_pda.1,
treasury_bump: treasury_pda.1,
}
.to_bytes()
.to_vec(),
]
.concat();
let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
let res = banks.process_transaction(tx).await;
assert!(res.is_err());
#[tokio::test]
async fn test_initialize_bad_programs() {
// Setup
let (mut banks, payer, blockhash) = setup_program_test_env().await;
// Bad metadata pda
let mut ix = ore::instruction::initialize(payer.pubkey());
ix.accounts[9].pubkey = bad_pda.0;
ix.data = [
OreInstruction::Initialize.to_vec(),
InitializeArgs {
bus_0_bump: bus_pdas[0].1,
bus_1_bump: bus_pdas[1].1,
bus_2_bump: bus_pdas[2].1,
bus_3_bump: bus_pdas[3].1,
bus_4_bump: bus_pdas[4].1,
bus_5_bump: bus_pdas[5].1,
bus_6_bump: bus_pdas[6].1,
bus_7_bump: bus_pdas[7].1,
metadata_bump: bad_pda.1,
mint_bump: mint_pda.1,
treasury_bump: treasury_pda.1,
}
.to_bytes()
.to_vec(),
]
.concat();
let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
let res = banks.process_transaction(tx).await;
assert!(res.is_err());
// Bad mint pda
let mut ix = ore::instruction::initialize(payer.pubkey());
ix.accounts[10].pubkey = bad_pda.0;
ix.data = [
OreInstruction::Initialize.to_vec(),
InitializeArgs {
bus_0_bump: bus_pdas[0].1,
bus_1_bump: bus_pdas[1].1,
bus_2_bump: bus_pdas[2].1,
bus_3_bump: bus_pdas[3].1,
bus_4_bump: bus_pdas[4].1,
bus_5_bump: bus_pdas[5].1,
bus_6_bump: bus_pdas[6].1,
bus_7_bump: bus_pdas[7].1,
metadata_bump: metadata_pda.1,
mint_bump: bad_pda.1,
treasury_bump: treasury_pda.1,
}
.to_bytes()
.to_vec(),
]
.concat();
let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
let res = banks.process_transaction(tx).await;
assert!(res.is_err());
// Bad treasury pda
let mut ix = ore::instruction::initialize(payer.pubkey());
ix.accounts[11].pubkey = bad_pda.0;
ix.data = [
OreInstruction::Initialize.to_vec(),
InitializeArgs {
bus_0_bump: bus_pdas[0].1,
bus_1_bump: bus_pdas[1].1,
bus_2_bump: bus_pdas[2].1,
bus_3_bump: bus_pdas[3].1,
bus_4_bump: bus_pdas[4].1,
bus_5_bump: bus_pdas[5].1,
bus_6_bump: bus_pdas[6].1,
bus_7_bump: bus_pdas[7].1,
metadata_bump: metadata_pda.1,
mint_bump: mint_pda.1,
treasury_bump: bad_pda.1,
}
.to_bytes()
.to_vec(),
]
.concat();
let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
let res = banks.process_transaction(tx).await;
assert!(res.is_err());
// Bad addresses
for i in 13..18 {
let mut ix = ore::instruction::initialize(payer.pubkey());
ix.accounts[i].pubkey = Pubkey::new_unique();
let tx =
Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
let res = banks.process_transaction(tx).await;
assert!(res.is_err());
}
}
async fn setup_program_test_env() -> (BanksClient, Keypair, Hash) {

17
tests/test_reset.rs
View File

@@ -105,6 +105,23 @@ async fn test_reset() {
assert_eq!(treasury_tokens.close_authority, COption::None);
}
#[tokio::test]
async fn test_reset_bad_key() {
// Setup
let (mut banks, payer, _, blockhash) = setup_program_test_env(ClockState::Normal).await;
// Bad addresses
let bad_pda = Pubkey::find_program_address(&[b"t"], &ore::id());
for i in 1..13 {
let mut ix = ore::instruction::reset(payer.pubkey());
ix.accounts[i].pubkey = bad_pda.0;
let tx =
Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
let res = banks.process_transaction(tx).await;
assert!(res.is_err());
}
}
#[tokio::test]
async fn test_reset_busses_out_of_order_fail() {
// Setup