Rewrite system integration test

Create Client helpers instead of Bank helpers.

runtime/tests/system.rs

@@ -4,54 +4,57 @@ use solana_sdk::native_program::ProgramError;
 use solana_sdk::signature::{Keypair, KeypairUtil};
 use solana_sdk::system_instruction::SystemInstruction;
 use solana_sdk::system_program;
-use solana_sdk::transaction::{InstructionError, TransactionError};
+use solana_sdk::transaction::{InstructionError, Transaction, TransactionError};
 use solana_sdk::transaction_builder::{BuilderInstruction, TransactionBuilder};
 
-struct SystemBank<'a> {
+struct SystemClient<'a> {
     bank: &'a Bank,
+    keypair: Keypair,
 }
 
-impl<'a> SystemBank<'a> {
+impl<'a> SystemClient<'a> {
-    fn new(bank: &'a Bank) -> Self {
+    fn new(bank: &'a Bank, keypair: Keypair) -> Self {
         bank.add_native_program("solana_system_program", &system_program::id());
-        Self { bank }
+        Self { bank, keypair }
+    }
+
+    fn process_transaction(&self, mut tx: Transaction) -> Result<(), TransactionError> {
+        tx.sign_unchecked(&[&self.keypair], self.bank.last_blockhash());
+        self.bank.process_transaction(&tx)
     }
 }
+
 #[test]
 fn test_system_unsigned_transaction() {
     let (genesis_block, from_keypair) = GenesisBlock::new(100);
     let bank = Bank::new(&genesis_block);
-    let system_bank = SystemBank::new(&bank);
+    let from_pubkey = from_keypair.pubkey();
+    let alice_client = SystemClient::new(&bank, from_keypair);
+
+    let to_keypair = Keypair::new();
+    let to_pubkey = Keypair::new().pubkey();
+    let mallory_client = SystemClient::new(&bank, to_keypair);
 
     // Fund to account to bypass AccountNotFound error
-    let to_keypair = Keypair::new();
+    let ix = SystemInstruction::new_move(&from_pubkey, &to_pubkey, 50);
-    let blockhash = system_bank.bank.last_blockhash();
+    let tx = TransactionBuilder::new_singleton(ix);
-    let tx = TransactionBuilder::default()
+    alice_client.process_transaction(tx).unwrap();
-        .push(SystemInstruction::new_move(
-            &from_keypair.pubkey(),
-            &to_keypair.pubkey(),
-            50,
-        ))
-        .sign(&[&from_keypair], blockhash);
-    system_bank.bank.process_transaction(&tx).unwrap();
 
     // Erroneously sign transaction with recipient account key
     // No signature case is tested by bank `test_zero_signatures()`
-    let blockhash = system_bank.bank.last_blockhash();
+    let ix = BuilderInstruction::new(
-    let tx = TransactionBuilder::default()
+        system_program::id(),
-        .push(BuilderInstruction::new(
+        &SystemInstruction::Move { lamports: 10 },
-            system_program::id(),
+        vec![(from_pubkey, false), (to_pubkey, true)],
-            &SystemInstruction::Move { lamports: 10 },
+    );
-            vec![(from_keypair.pubkey(), false), (to_keypair.pubkey(), true)],
+    let tx = TransactionBuilder::new_singleton(ix);
-        ))
-        .sign(&[&to_keypair], blockhash);
     assert_eq!(
-        system_bank.bank.process_transaction(&tx),
+        mallory_client.process_transaction(tx),
         Err(TransactionError::InstructionError(
             0,
             InstructionError::ProgramError(ProgramError::MissingRequiredSignature)
         ))
     );
-    assert_eq!(system_bank.bank.get_balance(&from_keypair.pubkey()), 50);
+    assert_eq!(bank.get_balance(&from_pubkey), 50);
-    assert_eq!(system_bank.bank.get_balance(&to_keypair.pubkey()), 50);
+    assert_eq!(bank.get_balance(&to_pubkey), 50);
 }