blockworks-foundation
/
mango-v4
mirror of https://github.com/blockworks-foundation/mango-v4.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Tests: Unify group + tokens setup

This commit is contained in:
Christian Kamm 2022-03-21 07:49:51 +01:00
parent 75ac224b6e
commit a6a31f226c
8 changed files with 174 additions and 415 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

98
programs/mango-v4/tests/program_test/mango_setup.rs Normal file
View File

@ -0,0 +1,98 @@
#![allow(dead_code)]
use anchor_lang::prelude::*;
use solana_sdk::signature::Keypair;
use super::mango_client::*;
use super::solana::SolanaCookie;
use super::{send_tx, MintCookie};
pub struct GroupWithTokensConfig<'a> {
pub admin: &'a Keypair,
pub payer: &'a Keypair,
pub mints: &'a [MintCookie],
}
pub struct Token {
pub index: u16,
pub mint: MintCookie,
pub oracle: Pubkey,
pub bank: Pubkey,
pub vault: Pubkey,
}
pub struct GroupWithTokens {
pub group: Pubkey,
pub tokens: Vec<Token>,
}
impl<'a> GroupWithTokensConfig<'a> {
pub async fn create(self, solana: &SolanaCookie) -> GroupWithTokens {
let GroupWithTokensConfig {
admin,
payer,
mints,
} = self;
let group = send_tx(solana, CreateGroupInstruction { admin, payer })
.await
.unwrap()
.group;
let address_lookup_table = solana.create_address_lookup_table(admin, payer).await;
let mut tokens = vec![];
for (index, mint) in mints.iter().enumerate() {
let create_stub_oracle_accounts = send_tx(
solana,
CreateStubOracle {
mint: mint.pubkey,
payer,
},
)
.await
.unwrap();
let oracle = create_stub_oracle_accounts.oracle;
send_tx(
solana,
SetStubOracle {
mint: mint.pubkey,
payer,
price: "1.0",
},
)
.await
.unwrap();
let token_index = index as u16;
let register_token_accounts = send_tx(
solana,
RegisterTokenInstruction {
token_index,
decimals: mint.decimals,
maint_asset_weight: 0.9,
init_asset_weight: 0.8,
maint_liab_weight: 1.1,
init_liab_weight: 1.2,
group,
admin,
mint: mint.pubkey,
address_lookup_table,
payer,
},
)
.await
.unwrap();
let bank = register_token_accounts.bank;
let vault = register_token_accounts.vault;
tokens.push(Token {
index: token_index,
mint: mint.clone(),
oracle,
bank,
vault,
});
}
GroupWithTokens { group, tokens }
}
}

1
programs/mango-v4/tests/program_test/mod.rs
View File

@ -18,6 +18,7 @@ pub use utils::*;
pub mod cookies;
pub mod mango_client;
pub mod mango_setup;
pub mod serum;
pub mod solana;
pub mod utils;

60
programs/mango-v4/tests/test_basic.rs
View File

@ -19,7 +19,7 @@ async fn test_basic() -> Result<(), TransportError> {
let admin = &Keypair::new();
let owner = &context.users[0].key;
let payer = &context.users[1].key;
let mint0 = &context.mints[0];
let mints = &context.mints[0..1];
let payer_mint0_account = context.users[1].token_accounts[0];
let dust_threshold = 0.01;
@ -27,10 +27,15 @@ async fn test_basic() -> Result<(), TransportError> {
// SETUP: Create a group, account, register a token (mint0)
//
let group = send_tx(solana, CreateGroupInstruction { admin, payer })
.await
.unwrap()
.group;
let mango_setup::GroupWithTokens { group, tokens } = mango_setup::GroupWithTokensConfig {
admin,
payer,
mints,
}
.create(solana)
.await;
let bank = tokens[0].bank;
let vault = tokens[0].vault;
let account = send_tx(
solana,
@ -45,51 +50,6 @@ async fn test_basic() -> Result<(), TransportError> {
.unwrap()
.account;
let create_stub_oracle_accounts = send_tx(
solana,
CreateStubOracle {
mint: mint0.pubkey,
payer,
},
)
.await
.unwrap();
let _oracle = create_stub_oracle_accounts.oracle;
send_tx(
solana,
SetStubOracle {
mint: mint0.pubkey,
payer,
price: "1.0",
},
)
.await
.unwrap();
let address_lookup_table = solana.create_address_lookup_table(admin, payer).await;
let register_token_accounts = send_tx(
solana,
RegisterTokenInstruction {
token_index: 0,
decimals: mint0.decimals,
maint_asset_weight: 0.9,
init_asset_weight: 0.8,
maint_liab_weight: 1.1,
init_liab_weight: 1.2,
group,
admin,
mint: mint0.pubkey,
address_lookup_table,
payer,
},
)
.await
.unwrap();
let bank = register_token_accounts.bank;
let vault = register_token_accounts.vault;
//
// TEST: Deposit funds
//

130
programs/mango-v4/tests/test_health_compute.rs
View File

@ -1,10 +1,8 @@
#![cfg(feature = "test-bpf")]
use solana_program::pubkey::Pubkey;
use solana_program_test::*;
use solana_sdk::{signature::Keypair, transport::TransportError};
use mango_v4::state::*;
use program_test::*;
mod program_test;
@ -25,10 +23,13 @@ async fn test_health_compute_tokens() -> Result<(), TransportError> {
// SETUP: Create a group and an account
//
let group = send_tx(solana, CreateGroupInstruction { admin, payer })
.await
.unwrap()
.group;
let mango_setup::GroupWithTokens { group, .. } = mango_setup::GroupWithTokensConfig {
admin,
payer,
mints,
}
.create(solana)
.await;
let account = send_tx(
solana,
@ -43,59 +44,6 @@ async fn test_health_compute_tokens() -> Result<(), TransportError> {
.unwrap()
.account;
//
// SETUP: Register mints (and make oracles for them)
//
let register_mint = |index: TokenIndex, mint: MintCookie, address_lookup_table: Pubkey| async move {
let create_stub_oracle_accounts = send_tx(
solana,
CreateStubOracle {
mint: mint.pubkey,
payer,
},
)
.await
.unwrap();
let oracle = create_stub_oracle_accounts.oracle;
send_tx(
solana,
SetStubOracle {
mint: mint.pubkey,
payer,
price: "1.0",
},
)
.await
.unwrap();
let register_token_accounts = send_tx(
solana,
RegisterTokenInstruction {
token_index: index,
decimals: mint.decimals,
maint_asset_weight: 0.9,
init_asset_weight: 0.8,
maint_liab_weight: 1.1,
init_liab_weight: 1.2,
group,
admin,
mint: mint.pubkey,
address_lookup_table,
payer,
},
)
.await
.unwrap();
let bank = register_token_accounts.bank;
(oracle, bank)
};
let address_lookup_table = solana.create_address_lookup_table(admin, payer).await;
for mint in mints {
register_mint(mint.index as u16, mint.clone(), address_lookup_table).await;
}
//
// TEST: Deposit user funds for all the mints
// each deposit will end with a health check
@ -138,10 +86,13 @@ async fn test_health_compute_serum() -> Result<(), TransportError> {
// SETUP: Create a group and an account
//
let group = send_tx(solana, CreateGroupInstruction { admin, payer })
.await
.unwrap()
.group;
let mango_setup::GroupWithTokens { group, .. } = mango_setup::GroupWithTokensConfig {
admin,
payer,
mints,
}
.create(solana)
.await;
let account = send_tx(
solana,
@ -156,59 +107,6 @@ async fn test_health_compute_serum() -> Result<(), TransportError> {
.unwrap()
.account;
//
// SETUP: Register mints (and make oracles for them)
//
let register_mint = |index: TokenIndex, mint: MintCookie, address_lookup_table: Pubkey| async move {
let create_stub_oracle_accounts = send_tx(
solana,
CreateStubOracle {
mint: mint.pubkey,
payer,
},
)
.await
.unwrap();
let oracle = create_stub_oracle_accounts.oracle;
send_tx(
solana,
SetStubOracle {
mint: mint.pubkey,
payer,
price: "1.0",
},
)
.await
.unwrap();
let register_token_accounts = send_tx(
solana,
RegisterTokenInstruction {
token_index: index,
decimals: mint.decimals,
maint_asset_weight: 0.9,
init_asset_weight: 0.8,
maint_liab_weight: 1.1,
init_liab_weight: 1.2,
group,
admin,
mint: mint.pubkey,
address_lookup_table,
payer,
},
)
.await
.unwrap();
let bank = register_token_accounts.bank;
(oracle, bank)
};
let address_lookup_table = solana.create_address_lookup_table(admin, payer).await;
for mint in mints {
register_mint(mint.index as u16, mint.clone(), address_lookup_table).await;
}
//
// SETUP: Create serum markets and register them
//

60
programs/mango-v4/tests/test_margin_trade.rs
View File

@ -34,7 +34,7 @@ async fn test_margin_trade() -> Result<(), TransportError> {
let admin = &Keypair::new();
let owner = &context.users[0].key;
let payer = &context.users[1].key;
let mint0 = &context.mints[0];
let mints = &context.mints[0..1];
let payer_mint0_account = context.users[1].token_accounts[0];
let dust_threshold = 0.01;
@ -42,10 +42,15 @@ async fn test_margin_trade() -> Result<(), TransportError> {
// SETUP: Create a group, account, register a token (mint0)
//
let group = send_tx(solana, CreateGroupInstruction { admin, payer })
.await
.unwrap()
.group;
let mango_setup::GroupWithTokens { group, tokens } = mango_setup::GroupWithTokensConfig {
admin,
payer,
mints,
}
.create(solana)
.await;
let bank = tokens[0].bank;
let vault = tokens[0].vault;
let account = send_tx(
solana,
@ -60,51 +65,6 @@ async fn test_margin_trade() -> Result<(), TransportError> {
.unwrap()
.account;
let create_stub_oracle_accounts = send_tx(
solana,
CreateStubOracle {
mint: mint0.pubkey,
payer,
},
)
.await
.unwrap();
let _oracle = create_stub_oracle_accounts.oracle;
send_tx(
solana,
SetStubOracle {
mint: mint0.pubkey,
payer,
price: "1.0",
},
)
.await
.unwrap();
let address_lookup_table = solana.create_address_lookup_table(admin, payer).await;
let register_token_accounts = send_tx(
solana,
RegisterTokenInstruction {
token_index: 0,
decimals: mint0.decimals,
maint_asset_weight: 0.9,
init_asset_weight: 0.8,
maint_liab_weight: 1.1,
init_liab_weight: 1.2,
group,
admin,
mint: mint0.pubkey,
address_lookup_table,
payer,
},
)
.await
.unwrap();
let bank = register_token_accounts.bank;
let vault = register_token_accounts.vault;
//
// TEST: Deposit funds
//

78
programs/mango-v4/tests/test_perp.rs
View File

@ -1,10 +1,8 @@
#![cfg(feature = "test-bpf")]
use solana_program::pubkey::Pubkey;
use solana_program_test::*;
use solana_sdk::{signature::Keypair, transport::TransportError};
use mango_v4::state::*;
use program_test::*;
mod program_test;
@ -17,18 +15,20 @@ async fn test_perp() -> Result<(), TransportError> {
let admin = &Keypair::new();
let owner = &context.users[0].key;
let payer = &context.users[1].key;
let mint0 = &context.mints[0];
let mint1 = &context.mints[1];
let mints = &context.mints[0..2];
let payer_mint_accounts = &context.users[1].token_accounts[0..=2];
//
// SETUP: Create a group and an account
//
let group = send_tx(solana, CreateGroupInstruction { admin, payer })
.await
.unwrap()
.group;
let mango_setup::GroupWithTokens { group, tokens } = mango_setup::GroupWithTokensConfig {
admin,
payer,
mints,
}
.create(solana)
.await;
let account = send_tx(
solana,
@ -43,62 +43,6 @@ async fn test_perp() -> Result<(), TransportError> {
.unwrap()
.account;
//
// SETUP: Register mints (and make oracles for them)
//
let register_mint = |index: TokenIndex, mint: MintCookie, address_lookup_table: Pubkey| async move {
let create_stub_oracle_accounts = send_tx(
solana,
CreateStubOracle {
mint: mint.pubkey,
payer,
},
)
.await
.unwrap();
let oracle = create_stub_oracle_accounts.oracle;
send_tx(
solana,
SetStubOracle {
mint: mint.pubkey,
payer,
price: "1.0",
},
)
.await
.unwrap();
let register_token_accounts = send_tx(
solana,
RegisterTokenInstruction {
token_index: index,
decimals: mint.decimals,
maint_asset_weight: 0.9,
init_asset_weight: 0.8,
maint_liab_weight: 1.1,
init_liab_weight: 1.2,
group,
admin,
mint: mint.pubkey,
address_lookup_table,
payer,
},
)
.await
.unwrap();
let bank = register_token_accounts.bank;
(oracle, bank)
};
let address_lookup_table = solana.create_address_lookup_table(admin, payer).await;
let base_token_index = 0;
let (_oracle0, _bank0) =
register_mint(base_token_index, mint0.clone(), address_lookup_table).await;
let quote_token_index = 1;
let (_oracle1, _bank1) =
register_mint(quote_token_index, mint1.clone(), address_lookup_table).await;
//
// SETUP: Deposit user funds
//
@ -139,10 +83,10 @@ async fn test_perp() -> Result<(), TransportError> {
group,
admin,
payer,
mint: mint0.pubkey,
mint: mints[0].pubkey,
perp_market_index: 0,
base_token_index,
quote_token_index,
base_token_index: tokens[0].index,
quote_token_index: tokens[1].index,
// e.g. BTC mango-v3 mainnet.1
quote_lot_size: 10,
base_lot_size: 100,

70
programs/mango-v4/tests/test_position_lifetime.rs
View File

@ -18,9 +18,7 @@ async fn test_position_lifetime() -> Result<()> {
let admin = &Keypair::new();
let owner = &context.users[0].key;
let payer = &context.users[1].key;
let mint0 = &context.mints[0];
let mint1 = &context.mints[1];
let mint2 = &context.mints[2];
let mints = &context.mints[0..3];
let payer_mint_accounts = &context.users[1].token_accounts[0..=2];
@ -28,10 +26,13 @@ async fn test_position_lifetime() -> Result<()> {
// SETUP: Create a group and accounts
//
let group = send_tx(solana, CreateGroupInstruction { admin, payer })
.await
.unwrap()
.group;
let mango_setup::GroupWithTokens { group, tokens } = mango_setup::GroupWithTokensConfig {
admin,
payer,
mints,
}
.create(solana)
.await;
let account = send_tx(
solana,
@ -59,59 +60,6 @@ async fn test_position_lifetime() -> Result<()> {
.unwrap()
.account;
//
// SETUP: Register three mints (and make oracles for them)
//
let address_lookup_table = solana.create_address_lookup_table(admin, payer).await;
let register_mint = |index: TokenIndex, mint: MintCookie| async move {
let create_stub_oracle_accounts = send_tx(
solana,
CreateStubOracle {
mint: mint.pubkey,
payer,
},
)
.await
.unwrap();
let oracle = create_stub_oracle_accounts.oracle;
send_tx(
solana,
SetStubOracle {
mint: mint.pubkey,
payer,
price: "1.0",
},
)
.await
.unwrap();
let register_token_accounts = send_tx(
solana,
RegisterTokenInstruction {
token_index: index,
decimals: mint.decimals,
maint_asset_weight: 0.9,
init_asset_weight: 0.8,
maint_liab_weight: 1.1,
init_liab_weight: 1.2,
group,
admin,
mint: mint.pubkey,
address_lookup_table,
payer,
},
)
.await
.unwrap();
let bank = register_token_accounts.bank;
(oracle, bank)
};
register_mint(0, mint0.clone()).await;
let (_oracle1, bank1) = register_mint(1, mint1.clone()).await;
register_mint(2, mint2.clone()).await;
//
// SETUP: Put some tokens into the funding account to allow borrowing
//
@ -218,7 +166,7 @@ async fn test_position_lifetime() -> Result<()> {
.await
.unwrap();
assert_eq!(
account_position(solana, account, bank1).await,
account_position(solana, account, tokens[1].bank).await,
-(borrow_amount as i64)
);

92
programs/mango-v4/tests/test_serum.rs
View File

@ -1,7 +1,6 @@
#![cfg(feature = "test-bpf")]
use anchor_spl::dex::serum_dex;
use solana_program::pubkey::Pubkey;
use solana_program_test::*;
use solana_sdk::{signature::Keypair, transport::TransportError};
@ -18,23 +17,22 @@ async fn test_serum() -> Result<(), TransportError> {
let admin = &Keypair::new();
let owner = &context.users[0].key;
let payer = &context.users[1].key;
let mint0 = &context.mints[0];
let mint1 = &context.mints[1];
let mints = &context.mints[0..2];
let payer_mint_accounts = &context.users[1].token_accounts[0..=2];
//
// SETUP: Create serum market
//
let serum_market_cookie = context.serum.list_spot_market(mint0, mint1).await;
//
// SETUP: Create a group and an account
//
let group = send_tx(solana, CreateGroupInstruction { admin, payer })
.await
.unwrap()
.group;
let mango_setup::GroupWithTokens { group, tokens } = mango_setup::GroupWithTokensConfig {
admin,
payer,
mints,
}
.create(solana)
.await;
let base_token = &tokens[0];
let quote_token = &tokens[1];
let account = send_tx(
solana,
@ -50,60 +48,12 @@ async fn test_serum() -> Result<(), TransportError> {
.account;
//
// SETUP: Register mints (and make oracles for them)
// SETUP: Create serum market
//
let register_mint = |index: TokenIndex, mint: MintCookie, address_lookup_table: Pubkey| async move {
let create_stub_oracle_accounts = send_tx(
solana,
CreateStubOracle {
mint: mint.pubkey,
payer,
},
)
.await
.unwrap();
let oracle = create_stub_oracle_accounts.oracle;
send_tx(
solana,
SetStubOracle {
mint: mint.pubkey,
payer,
price: "1.0",
},
)
.await
.unwrap();
let register_token_accounts = send_tx(
solana,
RegisterTokenInstruction {
token_index: index,
decimals: mint.decimals,
maint_asset_weight: 0.9,
init_asset_weight: 0.8,
maint_liab_weight: 1.1,
init_liab_weight: 1.2,
group,
admin,
mint: mint.pubkey,
address_lookup_table,
payer,
},
)
.await
.unwrap();
let bank = register_token_accounts.bank;
(oracle, bank)
};
let address_lookup_table = solana.create_address_lookup_table(admin, payer).await;
let base_token_index = 0;
let (_oracle0, bank0) =
register_mint(base_token_index, mint0.clone(), address_lookup_table).await;
let quote_token_index = 1;
let (_oracle1, bank1) =
register_mint(quote_token_index, mint1.clone(), address_lookup_table).await;
let serum_market_cookie = context
.serum
.list_spot_market(&base_token.mint, &quote_token.mint)
.await;
//
// SETUP: Deposit user funds
@ -147,8 +97,8 @@ async fn test_serum() -> Result<(), TransportError> {
serum_program: context.serum.program_id,
serum_market_external: serum_market_cookie.market,
market_index: 0,
base_token_index,
quote_token_index,
base_token_index: base_token.index,
quote_token_index: quote_token.index,
payer,
},
)
@ -204,8 +154,8 @@ async fn test_serum() -> Result<(), TransportError> {
.await
.unwrap();
let native0 = account_position(solana, account, bank0).await;
let native1 = account_position(solana, account, bank1).await;
let native0 = account_position(solana, account, base_token.bank).await;
let native1 = account_position(solana, account, quote_token.bank).await;
assert_eq!(native0, 1000);
assert_eq!(native1, 900);
@ -247,8 +197,8 @@ async fn test_serum() -> Result<(), TransportError> {
.await
.unwrap();
let native0 = account_position(solana, account, bank0).await;
let native1 = account_position(solana, account, bank1).await;
let native0 = account_position(solana, account, base_token.bank).await;
let native1 = account_position(solana, account, quote_token.bank).await;
assert_eq!(native0, 1000);
assert_eq!(native1, 1000);