gaspersic/solana
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Replaces MockInvokeContext by ThisInvokeContext in tests (#20881)

Browse Source 
* Replaces MockInvokeContext by ThisInvokeContext in BpfLoader, SystemInstructionProcessor, CLIs, ConfigProcessor, StakeProcessor and VoteProcessor.

* Finally, removes MockInvokeContext, MockComputeMeter and MockLogger.

* Adjusts assert_instruction_count test.

* Moves ThisInvokeContext to the program-runtime crate.
This commit is contained in:
Alexander Meißner
2021-11-04 21:47:32 +01:00
committed by GitHub
parent 0597594943
commit 7200c5106e
33 changed files with 2640 additions and 2783 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
programs/config/Cargo.toml
View File

@@ -18,6 +18,7 @@ solana-sdk = { path = "../../sdk", version = "=1.9.0" }
[dev-dependencies]
solana-logger = { path = "../../logger", version = "=1.9.0" }
solana-program-runtime = { path = "../../program-runtime", version = "=1.9.0" }
[lib]
crate-type = ["lib"]

192
programs/config/src/config_processor.rs
View File

@@ -138,28 +138,25 @@ mod tests {
use crate::{config_instruction, get_config_data, id, ConfigKeys, ConfigState};
use bincode::serialized_size;
use serde_derive::{Deserialize, Serialize};
use solana_program_runtime::invoke_context::mock_process_instruction;
use solana_sdk::{
account::{Account, AccountSharedData},
keyed_account::create_keyed_accounts_unified,
process_instruction::MockInvokeContext,
account::AccountSharedData,
pubkey::Pubkey,
signature::{Keypair, Signer},
system_instruction::SystemInstruction,
};
use std::cell::RefCell;
use std::{cell::RefCell, rc::Rc};
fn process_instruction(
owner: &Pubkey,
instruction_data: &[u8],
keyed_accounts: &[(bool, bool, &Pubkey, &RefCell<AccountSharedData>)],
keyed_accounts: &[(bool, bool, Pubkey, Rc<RefCell<AccountSharedData>>)],
) -> Result<(), InstructionError> {
let processor_account = AccountSharedData::new_ref(0, 0, &solana_sdk::native_loader::id());
let mut keyed_accounts = keyed_accounts.to_vec();
keyed_accounts.insert(0, (false, false, owner, &processor_account));
super::process_instruction(
1,
mock_process_instruction(
&id(),
Vec::new(),
instruction_data,
&mut MockInvokeContext::new(owner, create_keyed_accounts_unified(&keyed_accounts)),
keyed_accounts,
super::process_instruction,
)
}
@@ -187,8 +184,10 @@ mod tests {
}
}
fn create_config_account(keys: Vec<(Pubkey, bool)>) -> (Keypair, RefCell<AccountSharedData>) {
let from_pubkey = solana_sdk::pubkey::new_rand();
fn create_config_account(
keys: Vec<(Pubkey, bool)>,
) -> (Keypair, Rc<RefCell<AccountSharedData>>) {
let from_pubkey = Pubkey::new_unique();
let config_keypair = Keypair::new();
let config_pubkey = config_keypair.pubkey();
@@ -204,14 +203,10 @@ mod tests {
} => space,
_ => panic!("Not a CreateAccount system instruction"),
};
let config_account = RefCell::new(AccountSharedData::from(Account {
data: vec![0; space as usize],
owner: id(),
..Account::default()
}));
let keyed_accounts = [(true, false, &config_pubkey, &config_account)];
let config_account = AccountSharedData::new_ref(0, space as usize, &id());
let keyed_accounts = [(true, false, config_pubkey, config_account.clone())];
assert_eq!(
process_instruction(&id(), &instructions[1].data, &keyed_accounts),
process_instruction(&instructions[1].data, &keyed_accounts),
Ok(())
);
@@ -237,9 +232,9 @@ mod tests {
let my_config = MyConfig::new(42);
let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
let keyed_accounts = [(true, false, &config_pubkey, &config_account)];
let keyed_accounts = [(true, false, config_pubkey, config_account.clone())];
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Ok(())
);
assert_eq!(
@@ -258,9 +253,9 @@ mod tests {
let mut instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
instruction.data = vec![0; 123]; // <-- Replace data with a vector that's too large
let keyed_accounts = [(true, false, &config_pubkey, &config_account)];
let keyed_accounts = [(true, false, config_pubkey, config_account)];
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Err(InstructionError::InvalidInstructionData)
);
}
@@ -275,9 +270,9 @@ mod tests {
let mut instruction = config_instruction::store(&config_pubkey, true, vec![], &my_config);
instruction.accounts[0].is_signer = false; // <----- not a signer
let keyed_accounts = [(false, false, &config_pubkey, &config_account)];
let keyed_accounts = [(false, false, config_pubkey, config_account)];
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Err(InstructionError::MissingRequiredSignature)
);
}
@@ -285,9 +280,9 @@ mod tests {
#[test]
fn test_process_store_with_additional_signers() {
solana_logger::setup();
let pubkey = solana_sdk::pubkey::new_rand();
let signer0_pubkey = solana_sdk::pubkey::new_rand();
let signer1_pubkey = solana_sdk::pubkey::new_rand();
let pubkey = Pubkey::new_unique();
let signer0_pubkey = Pubkey::new_unique();
let signer1_pubkey = Pubkey::new_unique();
let keys = vec![
(pubkey, false),
(signer0_pubkey, true),
@@ -298,15 +293,15 @@ mod tests {
let my_config = MyConfig::new(42);
let instruction = config_instruction::store(&config_pubkey, true, keys.clone(), &my_config);
let signer0_account = RefCell::new(AccountSharedData::default());
let signer1_account = RefCell::new(AccountSharedData::default());
let signer0_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
let signer1_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
let keyed_accounts = [
(true, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account),
(true, false, &signer1_pubkey, &signer1_account),
(true, false, config_pubkey, config_account.clone()),
(true, false, signer0_pubkey, signer0_account),
(true, false, signer1_pubkey, signer1_account),
];
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Ok(())
);
let meta_data: ConfigKeys = deserialize(config_account.borrow().data()).unwrap();
@@ -320,21 +315,18 @@ mod tests {
#[test]
fn test_process_store_without_config_signer() {
solana_logger::setup();
let pubkey = solana_sdk::pubkey::new_rand();
let signer0_pubkey = solana_sdk::pubkey::new_rand();
let pubkey = Pubkey::new_unique();
let signer0_pubkey = Pubkey::new_unique();
let keys = vec![(pubkey, false), (signer0_pubkey, true)];
let (config_keypair, _) = create_config_account(keys.clone());
let config_pubkey = config_keypair.pubkey();
let my_config = MyConfig::new(42);
let instruction = config_instruction::store(&config_pubkey, false, keys, &my_config);
let signer0_account = RefCell::new(AccountSharedData::from(Account {
owner: id(),
..Account::default()
}));
let keyed_accounts = [(true, false, &signer0_pubkey, &signer0_account)];
let signer0_account = AccountSharedData::new_ref(0, 0, &id());
let keyed_accounts = [(true, false, signer0_pubkey, signer0_account)];
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Err(InstructionError::InvalidAccountData)
);
}
@@ -342,10 +334,10 @@ mod tests {
#[test]
fn test_process_store_with_bad_additional_signer() {
solana_logger::setup();
let signer0_pubkey = solana_sdk::pubkey::new_rand();
let signer1_pubkey = solana_sdk::pubkey::new_rand();
let signer0_account = RefCell::new(AccountSharedData::default());
let signer1_account = RefCell::new(AccountSharedData::default());
let signer0_pubkey = Pubkey::new_unique();
let signer1_pubkey = Pubkey::new_unique();
let signer0_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
let signer1_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
let keys = vec![(signer0_pubkey, true)];
let (config_keypair, config_account) = create_config_account(keys.clone());
let config_pubkey = config_keypair.pubkey();
@@ -355,18 +347,18 @@ mod tests {
// Config-data pubkey doesn't match signer
let mut keyed_accounts = [
(true, false, &config_pubkey, &config_account),
(true, false, &signer1_pubkey, &signer1_account),
(true, false, config_pubkey, config_account),
(true, false, signer1_pubkey, signer1_account),
];
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Err(InstructionError::MissingRequiredSignature)
);
// Config-data pubkey not a signer
keyed_accounts[1] = (false, false, &signer0_pubkey, &signer0_account);
keyed_accounts[1] = (false, false, signer0_pubkey, signer0_account);
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Err(InstructionError::MissingRequiredSignature)
);
}
@@ -374,13 +366,13 @@ mod tests {
#[test]
fn test_config_updates() {
solana_logger::setup();
let pubkey = solana_sdk::pubkey::new_rand();
let signer0_pubkey = solana_sdk::pubkey::new_rand();
let signer1_pubkey = solana_sdk::pubkey::new_rand();
let signer2_pubkey = solana_sdk::pubkey::new_rand();
let signer0_account = RefCell::new(AccountSharedData::default());
let signer1_account = RefCell::new(AccountSharedData::default());
let signer2_account = RefCell::new(AccountSharedData::default());
let pubkey = Pubkey::new_unique();
let signer0_pubkey = Pubkey::new_unique();
let signer1_pubkey = Pubkey::new_unique();
let signer2_pubkey = Pubkey::new_unique();
let signer0_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
let signer1_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
let signer2_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
let keys = vec![
(pubkey, false),
(signer0_pubkey, true),
@@ -392,12 +384,12 @@ mod tests {
let instruction = config_instruction::store(&config_pubkey, true, keys.clone(), &my_config);
let mut keyed_accounts = [
(true, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account),
(true, false, &signer1_pubkey, &signer1_account),
(true, false, config_pubkey, config_account.clone()),
(true, false, signer0_pubkey, signer0_account),
(true, false, signer1_pubkey, signer1_account),
];
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Ok(())
);
@@ -407,7 +399,7 @@ mod tests {
config_instruction::store(&config_pubkey, false, keys.clone(), &new_config);
keyed_accounts[0].0 = false;
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Ok(())
);
let meta_data: ConfigKeys = deserialize(config_account.borrow().data()).unwrap();
@@ -423,7 +415,7 @@ mod tests {
let instruction = config_instruction::store(&config_pubkey, false, keys, &my_config);
keyed_accounts[2].0 = false;
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Err(InstructionError::MissingRequiredSignature)
);
@@ -434,9 +426,9 @@ mod tests {
(signer2_pubkey, true),
];
let instruction = config_instruction::store(&config_pubkey, false, keys, &my_config);
keyed_accounts[2] = (true, false, &signer2_pubkey, &signer2_account);
keyed_accounts[2] = (true, false, signer2_pubkey, signer2_account);
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Err(InstructionError::MissingRequiredSignature)
);
}
@@ -446,7 +438,7 @@ mod tests {
solana_logger::setup();
let config_address = Pubkey::new_unique();
let signer0_pubkey = Pubkey::new_unique();
let signer0_account = RefCell::new(AccountSharedData::default());
let signer0_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
let keys = vec![
(config_address, false),
(signer0_pubkey, true),
@@ -459,12 +451,12 @@ mod tests {
// Attempt initialization with duplicate signer inputs
let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
let keyed_accounts = [
(true, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account),
(true, false, &signer0_pubkey, &signer0_account),
(true, false, config_pubkey, config_account),
(true, false, signer0_pubkey, signer0_account.clone()),
(true, false, signer0_pubkey, signer0_account),
];
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Err(InstructionError::InvalidArgument),
);
}
@@ -475,8 +467,8 @@ mod tests {
let config_address = Pubkey::new_unique();
let signer0_pubkey = Pubkey::new_unique();
let signer1_pubkey = Pubkey::new_unique();
let signer0_account = RefCell::new(AccountSharedData::default());
let signer1_account = RefCell::new(AccountSharedData::default());
let signer0_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
let signer1_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
let keys = vec![
(config_address, false),
(signer0_pubkey, true),
@@ -488,12 +480,12 @@ mod tests {
let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
let mut keyed_accounts = [
(true, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account),
(true, false, &signer1_pubkey, &signer1_account),
(true, false, config_pubkey, config_account),
(true, false, signer0_pubkey, signer0_account),
(true, false, signer1_pubkey, signer1_account),
];
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Ok(()),
);
@@ -505,9 +497,9 @@ mod tests {
(signer0_pubkey, true),
];
let instruction = config_instruction::store(&config_pubkey, false, dupe_keys, &new_config);
keyed_accounts[2] = keyed_accounts[1];
keyed_accounts[2] = keyed_accounts[1].clone();
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Err(InstructionError::InvalidArgument),
);
}
@@ -515,9 +507,9 @@ mod tests {
#[test]
fn test_config_updates_requiring_config() {
solana_logger::setup();
let pubkey = solana_sdk::pubkey::new_rand();
let signer0_pubkey = solana_sdk::pubkey::new_rand();
let signer0_account = RefCell::new(AccountSharedData::default());
let pubkey = Pubkey::new_unique();
let signer0_pubkey = Pubkey::new_unique();
let signer0_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
let keys = vec![
(pubkey, false),
(signer0_pubkey, true),
@@ -535,11 +527,11 @@ mod tests {
let instruction = config_instruction::store(&config_pubkey, true, keys.clone(), &my_config);
let keyed_accounts = [
(true, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account),
(true, false, config_pubkey, config_account.clone()),
(true, false, signer0_pubkey, signer0_account),
];
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Ok(())
);
@@ -548,7 +540,7 @@ mod tests {
let instruction =
config_instruction::store(&config_pubkey, true, keys.clone(), &new_config);
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Ok(())
);
let meta_data: ConfigKeys = deserialize(config_account.borrow().data()).unwrap();
@@ -563,32 +555,32 @@ mod tests {
let keys = vec![(pubkey, false), (config_keypair.pubkey(), true)];
let instruction = config_instruction::store(&config_pubkey, true, keys, &my_config);
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts[0..1]),
process_instruction(&instruction.data, &keyed_accounts[0..1]),
Err(InstructionError::MissingRequiredSignature)
);
}
#[test]
fn test_config_initialize_no_panic() {
let from_pubkey = solana_sdk::pubkey::new_rand();
let config_pubkey = solana_sdk::pubkey::new_rand();
let from_pubkey = Pubkey::new_unique();
let config_pubkey = Pubkey::new_unique();
let (_, _config_account) = create_config_account(vec![]);
let instructions =
config_instruction::create_account::<MyConfig>(&from_pubkey, &config_pubkey, 1, vec![]);
assert_eq!(
process_instruction(&id(), &instructions[1].data, &[]),
process_instruction(&instructions[1].data, &[]),
Err(InstructionError::NotEnoughAccountKeys)
);
}
#[test]
fn test_config_bad_owner() {
let from_pubkey = solana_sdk::pubkey::new_rand();
let config_pubkey = solana_sdk::pubkey::new_rand();
let from_pubkey = Pubkey::new_unique();
let config_pubkey = Pubkey::new_unique();
let new_config = MyConfig::new(84);
let signer0_pubkey = solana_sdk::pubkey::new_rand();
let signer0_account = RefCell::new(AccountSharedData::default());
let config_account = RefCell::new(AccountSharedData::default());
let signer0_pubkey = Pubkey::new_unique();
let signer0_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
let config_account = AccountSharedData::new_ref(0, 0, &Pubkey::new_unique());
let (_, _config_account) = create_config_account(vec![]);
let keys = vec![
(from_pubkey, false),
@@ -598,11 +590,11 @@ mod tests {
let instruction = config_instruction::store(&config_pubkey, true, keys, &new_config);
let keyed_accounts = [
(true, false, &config_pubkey, &config_account),
(true, false, &signer0_pubkey, &signer0_account),
(true, false, config_pubkey, config_account),
(true, false, signer0_pubkey, signer0_account),
];
assert_eq!(
process_instruction(&id(), &instruction.data, &keyed_accounts),
process_instruction(&instruction.data, &keyed_accounts),
Err(InstructionError::InvalidAccountOwner)
);
}