ore/tests/test_update_admin.rs

// use ore::{state::Treasury, utils::AccountDeserialize, TREASURY_ADDRESS};
// use solana_program::{
//     hash::Hash, native_token::LAMPORTS_PER_SOL, pubkey::Pubkey, rent::Rent, system_program,
// };
// use solana_program_test::{processor, read_file, BanksClient, ProgramTest};
// use solana_sdk::{
//     account::Account,
//     signature::{Keypair, Signer},
//     transaction::Transaction,
// };

// #[tokio::test]
// async fn test_update_admin() {
//     // Setup
//     let (mut banks, payer, _, blockhash) = setup_program_test_env().await;

//     // Submit tx
//     let ix = ore::instruction::initialize(payer.pubkey());
//     let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
//     let res = banks.process_transaction(tx).await;
//     assert!(res.is_ok());

//     // Get treasury account
//     let treasury_account = banks.get_account(TREASURY_ADDRESS).await.unwrap().unwrap();
//     let treasury = Treasury::try_from_bytes(&treasury_account.data).unwrap();

//     // Submit update admin ix
//     let new_admin = Pubkey::new_unique();
//     let ix = ore::instruction::update_admin(payer.pubkey(), new_admin);
//     let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
//     let res = banks.process_transaction(tx).await;
//     assert!(res.is_ok());

//     // Assert treasury state
//     let treasury_account = banks.get_account(TREASURY_ADDRESS).await.unwrap().unwrap();
//     let treasury_ = Treasury::try_from_bytes(&treasury_account.data).unwrap();
//     assert_eq!(treasury_.bump, treasury.bump);
//     assert_eq!(treasury_.admin, new_admin);
//     assert_eq!(treasury_.difficulty, treasury.difficulty);
//     assert_eq!(treasury_.last_reset_at, treasury.last_reset_at);
//     assert_eq!(treasury_.reward_rate, treasury.reward_rate);
//     assert_eq!(
//         treasury_.total_claimed_rewards,
//         treasury.total_claimed_rewards
//     );

//     // Submit another update admin ix
//     let ix = ore::instruction::update_admin(payer.pubkey(), payer.pubkey());
//     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_update_admin_bad_signer() {
//     // Setup
//     let (mut banks, payer, alt_payer, blockhash) = setup_program_test_env().await;

//     // Submit tx
//     let ix = ore::instruction::initialize(payer.pubkey());
//     let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
//     let res = banks.process_transaction(tx).await;
//     assert!(res.is_ok());

//     // Submit ix
//     let ix = ore::instruction::update_admin(alt_payer.pubkey(), Pubkey::new_unique());
//     let tx = Transaction::new_signed_with_payer(
//         &[ix],
//         Some(&alt_payer.pubkey()),
//         &[&alt_payer],
//         blockhash,
//     );
//     let res = banks.process_transaction(tx).await;
//     assert!(res.is_err());
// }

// #[tokio::test]
// async fn test_update_admin_not_enough_accounts() {
//     // Setup
//     let (mut banks, payer, _, blockhash) = setup_program_test_env().await;

//     // Submit tx
//     let ix = ore::instruction::initialize(payer.pubkey());
//     let tx = Transaction::new_signed_with_payer(&[ix], Some(&payer.pubkey()), &[&payer], blockhash);
//     let res = banks.process_transaction(tx).await;
//     assert!(res.is_ok());

//     // Submit ix without enough accounts
//     let mut ix = ore::instruction::update_admin(payer.pubkey(), Pubkey::new_unique());
//     ix.accounts.remove(1);
//     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, Keypair, Hash) {
//     let mut program_test = ProgramTest::new("ore", ore::ID, processor!(ore::process_instruction));
//     program_test.prefer_bpf(true);

//     // Setup metadata program
//     let data = read_file(&"tests/buffers/metadata_program.bpf");
//     program_test.add_account(
//         mpl_token_metadata::ID,
//         Account {
//             lamports: Rent::default().minimum_balance(data.len()).max(1),
//             data,
//             owner: solana_sdk::bpf_loader::id(),
//             executable: true,
//             rent_epoch: 0,
//         },
//     );

//     // Setup alt payer
//     let payer_alt = Keypair::new();
//     program_test.add_account(
//         payer_alt.pubkey(),
//         Account {
//             lamports: LAMPORTS_PER_SOL,
//             data: vec![],
//             owner: system_program::id(),
//             executable: false,
//             rent_epoch: 0,
//         },
//     );

//     let (banks, payer, blockhash) = program_test.start().await;
//     (banks, payer, payer_alt, blockhash)
// }