Skip to content

Commit

Permalink
small portion of fixes for tests:
Browse files Browse the repository at this point in the history 
non_functional::fragment::fragment_load_test
non_functional::rest::rest_load_quick
non_functional::transaction::test_expired_transactions_processing_speed
non_functional::transaction::test_transactions_with_long_ttl_processing_speed, non_functional::voting::public::noise::adversary_public_vote_quick_test
  • Loading branch information
@dkijania
dkijania committed Oct 14, 2021
1 parent 26d82fe commit 9f78821
Show file tree
Hide file tree
Showing 7 changed files with 108 additions and 96 deletions.
5 changes: 3 additions & 2 deletions testing/jormungandr-integration-tests/src/non_functional/fragment.rs
View file
Expand Up @@ -27,6 +27,7 @@ pub fn fragment_load_test() {
.with_slots_per_epoch(30)
.with_consensus_genesis_praos_active_slot_coeff(ActiveSlotCoefficient::MAXIMUM)
.with_slot_duration(4)
.with_block_content_max_size(204800)
.with_epoch_stability_depth(10)
.with_kes_update_speed(KesUpdateSpeed::new(43200).unwrap()),
)
Expand Down Expand Up @@ -70,14 +71,14 @@ pub fn fragment_load_test() {
use jormungandr_testing_utils::testing::jcli::FragmentsCheck;
use jormungandr_testing_utils::testing::jcli::JCli;

request_generator.prepare(BlockDateDto::new(0, 19));
request_generator.prepare(BlockDateDto::new(2, 0));

let jcli: JCli = Default::default();
let fragment_check = FragmentsCheck::new(jcli, &jormungandr);
let wait = Wait::new(Duration::from_secs(1), 25);
fragment_check.wait_until_all_processed(&wait).unwrap();

time::wait_for_epoch(1, jormungandr.rest());
time::wait_for_epoch(3, jormungandr.rest());

load::start_async(
request_generator,
Expand Down
3 changes: 3 additions & 0 deletions testing/jormungandr-integration-tests/src/non_functional/rest.rs
View file
Expand Up @@ -21,6 +21,9 @@ pub fn rest_load_quick() {

jormungandr.steal_temp_dir().unwrap().into_persistent();

// give some time to jormungandr spin off on slower environments
std::thread::sleep(std::time::Duration::from_secs(3));

let rest_client = jormungandr.rest();
let request = RestRequestGen::new(rest_client);
let config = Configuration::duration(
Expand Down
45 changes: 14 additions & 31 deletions testing/jormungandr-integration-tests/src/non_functional/transaction.rs
View file
@@ -1,3 +1,4 @@
use chain_impl_mockchain::fragment::Fragment;
use chain_impl_mockchain::{block::BlockDate, fee::LinearFee};
use jormungandr_lib::interfaces::{
ActiveSlotCoefficient, BlockDate as JLibBlockDate, KesUpdateSpeed, Mempool,
Expand All @@ -8,7 +9,7 @@ use jormungandr_testing_utils::{
benchmark_efficiency, benchmark_endurance, benchmark_speed,
node::time,
EfficiencyBenchmarkDef, EfficiencyBenchmarkFinish, Endurance, FragmentSender,
FragmentSenderSetup, FragmentVerifier, MemPoolCheck, Thresholds,
FragmentSenderSetup, Thresholds,
{jcli::JCli, jormungandr::ConfigurationBuilder, startup},
},
wallet::Wallet,
Expand Down Expand Up @@ -262,24 +263,16 @@ pub fn test_expired_transactions_processing_speed() {
time::wait_for_date(JLibBlockDate::new(0, 1), jormungandr.rest());

let output_value = 1;

let settings = jormungandr.rest().settings().unwrap();
let block_date_generator = BlockDateGenerator::rolling(
&settings,
BlockDate {
epoch: 1,
slot_id: 0,
},
false,
);

let transactions = (0..N_TRANSACTIONS)
let transactions: Vec<Fragment> = (0..N_TRANSACTIONS)
.map(|_| {
let tx = sender
.transaction_to(
&jormungandr.genesis_block_hash(),
&LinearFee::new(0, 0, 0),
block_date_generator.block_date(),
BlockDate {
epoch: 0,
slot_id: 0,
},
receiver.address(),
output_value.into(),
)
Expand All @@ -301,13 +294,13 @@ pub fn test_expired_transactions_processing_speed() {
.start();

let summary = fragment_sender
.send_batch_fragments(transactions, false, &jormungandr)
.send_batch_fragments_in_chunks(transactions, 100, false, &jormungandr)
.unwrap();

benchmark.stop().print();

assert!(summary.accepted.is_empty());
assert_eq!(summary.rejected.len(), N_TRANSACTIONS);

benchmark.stop().print();
}

#[test]
Expand Down Expand Up @@ -348,7 +341,7 @@ pub fn test_transactions_with_long_ttl_processing_speed() {

let output_value = 1;

let transactions = (0..N_TRANSACTIONS)
let transactions: Vec<Fragment> = (0..N_TRANSACTIONS)
.map(|_| {
let tx = sender
.transaction_to(
Expand Down Expand Up @@ -376,20 +369,10 @@ pub fn test_transactions_with_long_ttl_processing_speed() {
.start();

let summary = fragment_sender
.send_batch_fragments(transactions, false, &jormungandr)
.send_batch_fragments_in_chunks(transactions, 100, false, &jormungandr)
.unwrap();

assert_eq!(summary.accepted.len(), N_TRANSACTIONS);
assert!(summary.rejected.is_empty());

for fragment_id in summary.fragment_ids() {
FragmentVerifier::wait_and_verify_is_in_block(
Duration::from_millis(100),
MemPoolCheck::from(fragment_id),
&jormungandr,
)
.unwrap();
}

assert!(summary.accepted.is_empty());
assert_eq!(summary.rejected.len(), N_TRANSACTIONS);
benchmark.stop().print();
}
15 changes: 12 additions & 3 deletions testing/jormungandr-integration-tests/src/non_functional/voting/public/mod.rs
View file
Expand Up @@ -241,12 +241,21 @@ pub fn adversary_public_vote_load_scenario(
.start()
.unwrap();

let settings = jormungandr.rest().settings().unwrap();

let generator = BlockDateGenerator::rolling(
&settings,
BlockDate {
epoch: 1,
slot_id: 0,
},
false,
);

let transaction_sender = FragmentSender::new(
jormungandr.genesis_block_hash(),
jormungandr.fees(),
chain_impl_mockchain::block::BlockDate::first()
.next_epoch()
.into(),
generator,
FragmentSenderSetup::no_verify(),
);

Expand Down
102 changes: 52 additions & 50 deletions testing/jormungandr-testing-utils/src/testing/fragments/generator.rs
View file
Expand Up @@ -13,6 +13,7 @@ use chain_impl_mockchain::{
vote::Choice,
};
use chain_time::TimeEra;
use jormungandr_lib::crypto::hash::Hash;
use jormungandr_lib::interfaces::BlockDate as BlockDateDto;
use jortestkit::load::{Request, RequestFailure, RequestGenerator};
use rand::RngCore;
Expand Down Expand Up @@ -76,82 +77,83 @@ impl<'a, S: SyncNode + Send> FragmentGenerator<'a, S> {

pub fn prepare(&mut self, start_block_date: BlockDateDto) {
let time_era = start_block_date.time_era(self.slots_per_epoch);
let mut fragments = Vec::new();
let settings = self.node.rest().settings().unwrap();
let block0_hash = Hash::from_str(&settings.block0_hash).unwrap();
let fees = settings.fees;

let sender = self.sender.clone();

let stake_pools: Vec<StakePool> = iter::from_fn(|| Some(StakePool::new(&sender)))
let stake_pools: Vec<StakePool> = iter::from_fn(|| Some(StakePool::new(&self.sender)))
.take(self.stake_pools_count)
.map(|stake_pool| {
let fragment = self
.fragment_sender
.send_pool_registration(&mut self.sender, &stake_pool, &self.node)
.unwrap();

FragmentVerifier::wait_and_verify_is_in_block(
Duration::from_secs(2),
fragment,
&self.node,
)
.unwrap();

stake_pool
})
.collect();

let votes_plan_for_casting: Vec<VotePlan> = iter::from_fn(|| {
Some(
VotePlanBuilder::new()
.proposals_count(256)
.with_vote_start(start_block_date.into())
.with_vote_start(start_block_date.shift_slot(5, &time_era).into())
.with_tally_start(start_block_date.shift_epoch(5).into())
.with_tally_end(start_block_date.shift_epoch(6).into())
.build(),
)
})
.take(self.vote_plans_for_casting_count)
.map(|vote_plan| {
let fragment = self
.fragment_sender
.send_vote_plan(&mut self.sender, &vote_plan, &self.node)
.unwrap();

FragmentVerifier::wait_and_verify_is_in_block(
Duration::from_secs(2),
fragment,
&self.node,
)
.unwrap();

vote_plan
})
.collect();

let vote_plans_for_tally: Vec<VotePlan> = iter::from_fn(|| {
Some(
VotePlanBuilder::new()
.with_vote_start(start_block_date.into())
.with_tally_start(start_block_date.shift_slot(1, &time_era).into())
.with_vote_start(start_block_date.shift_slot(10, &time_era).into())
.with_tally_start(start_block_date.shift_slot(11, &time_era).into())
.with_tally_end(start_block_date.shift_epoch(5).into())
.build(),
)
})
.take(self.vote_plans_for_tally_count)
.map(|vote_plan| {
let fragment = self
.fragment_sender
.send_vote_plan(&mut self.sender, &vote_plan, &self.node)
.unwrap();
.collect();

FragmentVerifier::wait_and_verify_is_in_block(
Duration::from_secs(2),
fragment,
&self.node,
)
.unwrap();
for stake_pool in &stake_pools {
fragments.push(
self.sender
.issue_pool_registration_cert(
&block0_hash,
&fees,
self.fragment_sender.date(),
stake_pool,
)
.unwrap(),
);
}

vote_plan
})
.collect();
for vote_plan_for_casting in &votes_plan_for_casting {
fragments.push(
self.sender
.issue_vote_plan_cert(
&block0_hash,
&fees,
self.fragment_sender.date(),
vote_plan_for_casting,
)
.unwrap(),
);
}

for vote_plan_for_tally in &vote_plans_for_tally {
fragments.push(
self.sender
.issue_vote_plan_cert(
&block0_hash,
&fees,
self.fragment_sender.date(),
vote_plan_for_tally,
)
.unwrap(),
);
}

self.fragment_sender
.send_batch_fragments(fragments, true, &self.node)
.unwrap();
FragmentVerifier::wait_for_all_fragments(Duration::from_secs(10), &self.node).unwrap();

self.vote_plans_for_casting = votes_plan_for_casting;
self.vote_plans_for_tally = vote_plans_for_tally;
Expand Down
24 changes: 22 additions & 2 deletions testing/jormungandr-testing-utils/src/testing/fragments/sender.rs
View file
Expand Up @@ -39,15 +39,15 @@ pub enum FragmentSenderError {
TooManyAttemptsFailed { attempts: u8, alias: String },
#[error("fragment verifier error")]
FragmentVerifierError(#[from] super::FragmentVerifierError),
#[error("cannot send fragment")]
#[error(transparent)]
SendFragmentError(#[from] super::node::FragmentNodeError),
#[error("cannot sync node before sending fragment")]
SyncNodeError(#[from] crate::testing::SyncNodeError),
#[error("wallet error")]
WalletError(#[from] crate::wallet::WalletError),
#[error("wrong sender configuration: cannot use disable transaction auto confirm when sending more than one transaction")]
TransactionAutoConfirmDisabledError,
#[error("fragment exporter error")]
#[error(transparent)]
FragmentExporterError(#[from] FragmentExporterError),
}

Expand Down Expand Up @@ -132,6 +132,26 @@ impl<'a, S: SyncNode + Send> FragmentSender<'a, S> {
.map_err(|e| e.into())
}

pub fn send_batch_fragments_in_chunks<A: FragmentNode + SyncNode + Sized + Send>(
&self,
fragments: Vec<Fragment>,
chunks_size: usize,
fail_fast: bool,
node: &A,
) -> Result<FragmentsProcessingSummary, FragmentSenderError> {
let mut summary = FragmentsProcessingSummary {
accepted: Vec::new(),
rejected: Vec::new(),
};

for chunks in fragments.chunks(chunks_size) {
let chunk_summary = self.send_batch_fragments(chunks.to_vec(), fail_fast, node)?;
summary.accepted.extend(chunk_summary.accepted);
summary.rejected.extend(chunk_summary.rejected);
}
Ok(summary)
}

pub fn send_transaction<A: FragmentNode + SyncNode + Sized + Send>(
&self,
from: &mut Wallet,
Expand Down
10 changes: 2 additions & 8 deletions testing/jormungandr-testing-utils/src/testing/jormungandr/configuration_builder.rs
View file
Expand Up @@ -196,14 +196,8 @@ impl ConfigurationBuilder {
}

pub fn with_funds_split_if_needed(&mut self, initials: Vec<InitialUTxO>) -> &mut Self {
let mut funds = Vec::new();
for initial in initials.iter() {
funds.push(initial.clone());

if funds.len() >= 254 {
self.with_funds(funds.clone());
funds.clear();
}
for chunks in initials.chunks(254) {
self.with_funds(chunks.to_vec());
}
self
}
Expand Down

0 comments on commit 9f78821

Please sign in to comment.