123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767 |
- /*! Unit tests that require access to the testing-only function
- BridgeLine::random() or private fields */
- use super::bridge_table::BridgeLine;
- use super::proto::*;
- use super::*;
- use chrono::{DateTime, NaiveTime, Timelike, Utc};
- use rand::Rng;
- use statistical::{mean, standard_deviation};
- use std::collections::HashSet;
- use std::thread;
- use std::time::{Duration, Instant};
- #[cfg(feature = "fast")]
- const USERS: usize = 100;
- #[cfg(not(feature = "fast"))]
- const USERS: usize = 10000;
- struct PerfStat {
- // Report performance metrics for each test
- req_len: usize,
- resp_len: usize,
- req_t: Duration,
- resp_t: Duration,
- resp_handle_t: Duration,
- }
- struct TestHarness {
- bdb: BridgeDb,
- pub ba: BridgeAuth,
- }
- impl TestHarness {
- fn new() -> Self {
- TestHarness::new_buckets(5, 5)
- }
- fn new_buckets(num_buckets: u16, hot_spare: u16) -> Self {
- // Create a BridegDb
- let mut bdb = BridgeDb::new();
- // Create a BridgeAuth
- let mut ba = BridgeAuth::new(bdb.pubkey);
- // Make 3 x num_buckets open invitation bridges, in sets of 3
- for _ in 0..num_buckets {
- let bucket = [
- BridgeLine::random(),
- BridgeLine::random(),
- BridgeLine::random(),
- ];
- ba.add_openinv_bridges(bucket, &mut bdb);
- }
- // Add hot_spare more hot spare buckets
- for _ in 0..hot_spare {
- let bucket = [
- BridgeLine::random(),
- BridgeLine::random(),
- BridgeLine::random(),
- ];
- ba.add_spare_bucket(bucket);
- }
- // Create the encrypted bridge table
- ba.enc_bridge_table();
- Self { bdb, ba }
- }
- fn advance_days(&mut self, days: u16) {
- self.ba.advance_days(days);
- }
- fn open_invite(&mut self) -> (PerfStat, (cred::Lox, bridge_table::BridgeLine)) {
- // Issue an open invitation
- let inv = self.bdb.invite();
- let req_start = Instant::now();
- // Use it to get a Lox credential
- let (req, state) = open_invite::request(&inv);
- let encoded: Vec<u8> = bincode::serialize(&req).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let resp = self.ba.handle_open_invite(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&resp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp = bincode::deserialize(&encoded_resp[..]).unwrap();
- let (cred, bridgeline) =
- open_invite::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- (cred, bridgeline),
- )
- }
- fn trust_promotion(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Migration) {
- let req_start = Instant::now();
- let (promreq, promstate) =
- trust_promotion::request(cred, &self.ba.lox_pub, self.ba.today()).unwrap();
- let encoded: Vec<u8> = bincode::serialize(&promreq).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let promresp = self.ba.handle_trust_promotion(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&promresp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp = bincode::deserialize(&encoded_resp[..]).unwrap();
- let migcred = trust_promotion::handle_response(promstate, decode_resp).unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- migcred,
- )
- }
- fn level0_migration(
- &mut self,
- loxcred: &cred::Lox,
- migcred: &cred::Migration,
- ) -> (PerfStat, cred::Lox) {
- let req_start = Instant::now();
- let (migreq, migstate) =
- migration::request(loxcred, migcred, &self.ba.lox_pub, &self.ba.migration_pub).unwrap();
- let encoded: Vec<u8> = bincode::serialize(&migreq).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let migresp = self.ba.handle_migration(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&migresp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp: migration::Response = bincode::deserialize(&encoded_resp[..]).unwrap();
- let cred = migration::handle_response(migstate, decode_resp, &self.ba.lox_pub).unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- cred,
- )
- }
- fn level_up(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Lox) {
- // Read the bucket in the credential to get today's Bucket
- // Reachability credential
- let (id, key) = bridge_table::from_scalar(cred.bucket).unwrap();
- let encbuckets = self.ba.enc_bridge_table();
- let bucket =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
- let reachcred = bucket.1.unwrap();
- // Use the Bucket Reachability credential to advance to the next
- // level
- let req_start = Instant::now();
- let (req, state) = level_up::request(
- cred,
- &reachcred,
- &self.ba.lox_pub,
- &self.ba.reachability_pub,
- self.ba.today(),
- )
- .unwrap();
- let encoded: Vec<u8> = bincode::serialize(&req).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let resp = self.ba.handle_level_up(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&resp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp = bincode::deserialize(&encoded_resp[..]).unwrap();
- let cred = level_up::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- cred,
- )
- }
- fn issue_invite(&mut self, cred: &cred::Lox) -> (PerfStat, (cred::Lox, cred::Invitation)) {
- // Read the bucket in the credential to get today's Bucket
- // Reachability credential
- let (id, key) = bridge_table::from_scalar(cred.bucket).unwrap();
- let encbuckets = self.ba.enc_bridge_table();
- let bucket =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
- let reachcred = bucket.1.unwrap();
- let req_start = Instant::now();
- let (req, state) = issue_invite::request(
- cred,
- &reachcred,
- &self.ba.lox_pub,
- &self.ba.reachability_pub,
- self.ba.today(),
- )
- .unwrap();
- let encoded: Vec<u8> = bincode::serialize(&req).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let resp = self.ba.handle_issue_invite(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&resp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp = bincode::deserialize(&encoded_resp[..]).unwrap();
- let (cred, invite) = issue_invite::handle_response(
- state,
- decode_resp,
- &self.ba.lox_pub,
- &self.ba.invitation_pub,
- )
- .unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- (cred, invite),
- )
- }
- fn redeem_invite(&mut self, inv: &cred::Invitation) -> (PerfStat, cred::Lox) {
- let req_start = Instant::now();
- let (req, state) =
- redeem_invite::request(inv, &self.ba.invitation_pub, self.ba.today()).unwrap();
- let encoded: Vec<u8> = bincode::serialize(&req).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let resp = self.ba.handle_redeem_invite(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&resp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp = bincode::deserialize(&encoded_resp[..]).unwrap();
- let cred = redeem_invite::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- cred,
- )
- }
- fn check_blockage(&mut self, cred: &cred::Lox) -> (PerfStat, cred::Migration) {
- let req_start = Instant::now();
- let (req, state) = check_blockage::request(cred, &self.ba.lox_pub).unwrap();
- let encoded: Vec<u8> = bincode::serialize(&req).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let resp = self.ba.handle_check_blockage(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&resp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp = bincode::deserialize(&encoded_resp[..]).unwrap();
- let migcred = check_blockage::handle_response(state, decode_resp).unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- migcred,
- )
- }
- fn blockage_migration(
- &mut self,
- cred: &cred::Lox,
- mig: &cred::Migration,
- ) -> (PerfStat, cred::Lox) {
- let req_start = Instant::now();
- let (req, state) =
- blockage_migration::request(cred, mig, &self.ba.lox_pub, &self.ba.migration_pub)
- .unwrap();
- let encoded: Vec<u8> = bincode::serialize(&req).unwrap();
- let req_t = req_start.elapsed();
- let req_len = encoded.len();
- let resp_start = Instant::now();
- let decoded = bincode::deserialize(&encoded[..]).unwrap();
- let resp = self.ba.handle_blockage_migration(decoded).unwrap();
- let encoded_resp: Vec<u8> = bincode::serialize(&resp).unwrap();
- let resp_t = resp_start.elapsed();
- let resp_len = encoded_resp.len();
- let resp_handle_start = Instant::now();
- let decode_resp: blockage_migration::Response =
- bincode::deserialize(&encoded_resp[..]).unwrap();
- let cred =
- blockage_migration::handle_response(state, decode_resp, &self.ba.lox_pub).unwrap();
- let resp_handle_t = resp_handle_start.elapsed();
- (
- PerfStat {
- req_len,
- resp_len,
- req_t,
- resp_t,
- resp_handle_t,
- },
- cred,
- )
- }
- }
- #[test]
- fn test_open_invite() {
- let mut th = TestHarness::new();
- // Join an untrusted user
- let (perf_stat, (cred, bridgeline)) = th.open_invite();
- // Check that we can use the credential to read a bucket
- let (id, key) = bridge_table::from_scalar(cred.bucket).unwrap();
- let encbuckets = th.ba.enc_bridge_table();
- let bucket =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
- print_test_results(perf_stat);
- println!("cred = {:?}", cred);
- println!("bucket = {:?}", bucket);
- println!("bridgeline = {:?}", bridgeline);
- assert!(bucket.1.is_none());
- assert!(th.ba.verify_lox(&cred));
- assert!(bridgeline == bucket.0[0]);
- }
- #[test]
- fn test_trust_promotion() {
- let mut th = TestHarness::new();
- let cred = th.open_invite().1 .0;
- assert!(th.ba.verify_lox(&cred));
- // Time passes
- th.advance_days(47);
- let (perf_stat, migcred) = th.trust_promotion(&cred);
- assert!(th.ba.verify_migration(&migcred));
- // Check that we can use the to_bucket in the Migration credenital
- // to read a bucket
- let (id, key) = bridge_table::from_scalar(migcred.to_bucket).unwrap();
- let encbuckets = th.ba.enc_bridge_table();
- let bucket =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
- print_test_results(perf_stat);
- println!("bucket = {:?}", bucket);
- assert!(th.ba.verify_reachability(&bucket.1.unwrap()));
- }
- #[test]
- fn test_level0_migration() {
- let mut th = TestHarness::new();
- let cred = th.open_invite().1 .0;
- assert!(th.ba.verify_lox(&cred));
- // Time passes
- th.advance_days(47);
- let (perf_stat, migcred) = th.trust_promotion(&cred);
- assert!(th.ba.verify_migration(&migcred));
- println!("--Trust Promotion to 1--\n");
- print_test_results(perf_stat);
- let (mperf_stat, newloxcred) = th.level0_migration(&cred, &migcred);
- println!("--Level 0 migration--\n");
- print_test_results(mperf_stat);
- assert!(th.ba.verify_lox(&newloxcred));
- println!("newloxcred = {:?}", newloxcred);
- // Check that we can use the credenital to read a bucket
- let (id, key) = bridge_table::from_scalar(newloxcred.bucket).unwrap();
- let encbuckets = th.ba.enc_bridge_table();
- let bucket =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
- println!("bucket = {:?}", bucket);
- assert!(th.ba.verify_reachability(&bucket.1.unwrap()));
- }
- #[test]
- fn test_level_up() {
- let mut th = TestHarness::new();
- // Join an untrusted user
- let cred = th.open_invite().1 .0;
- // Time passes
- th.advance_days(47);
- // Go up to level 1
- let (perf_stat, migcred) = th.trust_promotion(&cred);
- println!("--Trust Promotion to 1--\n");
- print_test_results(perf_stat);
- let (mperf_stat, cred1) = th.level0_migration(&cred, &migcred);
- println!("--New Level 1 Credential--\n");
- print_test_results(mperf_stat);
- assert!(scalar_u32(&cred1.trust_level).unwrap() == 1);
- // Time passes
- th.advance_days(20);
- let (two_perf_stat, cred2) = th.level_up(&cred1);
- assert!(scalar_u32(&cred2.trust_level).unwrap() == 2);
- println!("--Upgrade to Level 2--\n");
- print_test_results(two_perf_stat);
- println!("cred2 = {:?}", cred2);
- assert!(th.ba.verify_lox(&cred2));
- // Time passes
- th.advance_days(30);
- let (three_perf_stat, cred3) = th.level_up(&cred2);
- assert!(scalar_u32(&cred3.trust_level).unwrap() == 3);
- println!("--Upgrade to Level 3--\n");
- print_test_results(three_perf_stat);
- println!("cred3 = {:?}", cred3);
- assert!(th.ba.verify_lox(&cred3));
- // Time passes
- th.advance_days(60);
- let (four_perf_stat, cred4) = th.level_up(&cred3);
- assert!(scalar_u32(&cred3.trust_level).unwrap() == 3);
- println!("--Upgrade to Level 4--\n");
- print_test_results(four_perf_stat);
- println!("cred4 = {:?}", cred4);
- assert!(th.ba.verify_lox(&cred4));
- }
- #[test]
- fn test_issue_invite() {
- let mut th = TestHarness::new();
- // Join an untrusted user
- let cred = th.open_invite().1 .0;
- // Time passes
- th.advance_days(47);
- // Go up to level 1
- let (perf_stat, migcred) = th.trust_promotion(&cred);
- println!("--Trust Promotion to 1--\n");
- print_test_results(perf_stat);
- let (mperf_stat, cred1) = th.level0_migration(&cred, &migcred);
- println!("--New Level 1 Credential--\n");
- print_test_results(mperf_stat);
- assert!(scalar_u32(&cred1.trust_level).unwrap() == 1);
- // Time passes
- th.advance_days(20);
- // Go up to level 2
- let (two_perf_stat, cred2) = th.level_up(&cred1);
- println!("--Upgrade to Level 2--\n");
- print_test_results(two_perf_stat);
- assert!(scalar_u32(&cred2.trust_level).unwrap() == 2);
- println!("cred2 = {:?}", cred2);
- assert!(th.ba.verify_lox(&cred2));
- // Issue an invitation
- let (invite_perf_stat, (cred2a, invite)) = th.issue_invite(&cred2);
- println!("--Issue Invitation--\n");
- print_test_results(invite_perf_stat);
- assert!(th.ba.verify_lox(&cred2a));
- assert!(th.ba.verify_invitation(&invite));
- println!("cred2a = {:?}", cred2a);
- println!("invite = {:?}", invite);
- }
- #[test]
- fn test_redeem_invite() {
- let mut th = TestHarness::new();
- // Join an untrusted user
- let cred = th.open_invite().1 .0;
- // Time passes
- th.advance_days(47);
- // Go up to level 1
- let (perf_stat, migcred) = th.trust_promotion(&cred);
- println!("--Trust Promotion to 1--\n");
- print_test_results(perf_stat);
- let (mperf_stat, cred1) = th.level0_migration(&cred, &migcred);
- println!("--New Level 1 Credential--\n");
- print_test_results(mperf_stat);
- assert!(scalar_u32(&cred1.trust_level).unwrap() == 1);
- // Time passes
- th.advance_days(20);
- // Go up to level 2
- let (two_perf_stat, cred2) = th.level_up(&cred1);
- println!("--Upgrade to Level 2--\n");
- print_test_results(two_perf_stat);
- assert!(scalar_u32(&cred2.trust_level).unwrap() == 2);
- println!("cred2 = {:?}", cred2);
- assert!(th.ba.verify_lox(&cred2));
- // Issue an invitation to Bob
- let (invite_perf_stat, (cred2a, bob_invite)) = th.issue_invite(&cred2);
- println!("--Issue Invitation--\n");
- print_test_results(invite_perf_stat);
- assert!(th.ba.verify_lox(&cred2a));
- assert!(th.ba.verify_invitation(&bob_invite));
- println!("cred2a = {:?}", cred2a);
- println!("bob_invite = {:?}", bob_invite);
- // Time passes
- th.advance_days(12);
- // Bob joins the system
- let (bob_perf_stat, bob_cred) = th.redeem_invite(&bob_invite);
- println!("--Bob joins the system--\n");
- print_test_results(bob_perf_stat);
- assert!(th.ba.verify_lox(&bob_cred));
- println!("bob_cred = {:?}", bob_cred);
- }
- #[test]
- fn test_mark_unreachable() {
- let mut th = TestHarness::new();
- println!("spares = {:?}", th.ba.bridge_table.spares);
- println!("tmig = {:?}", th.ba.trustup_migration_table.table);
- println!("bmig = {:?}", th.ba.blockage_migration_table.table);
- println!("openinv = {:?}\n", th.bdb.openinv_buckets);
- // Mark a bridge in an untrusted bucket as unreachable
- let b6 = th.ba.bridge_table.buckets[6][0];
- th.ba.bridge_unreachable(&b6, &mut th.bdb);
- println!("spares = {:?}", th.ba.bridge_table.spares);
- println!("tmig = {:?}", th.ba.trustup_migration_table.table);
- println!("bmig = {:?}", th.ba.blockage_migration_table.table);
- println!("openinv = {:?}\n", th.bdb.openinv_buckets);
- // Mark another bridge grouped to the same trusted bucket as
- // unreachable
- let b7 = th.ba.bridge_table.buckets[7][0];
- th.ba.bridge_unreachable(&b7, &mut th.bdb);
- println!("spares = {:?}", th.ba.bridge_table.spares);
- println!("tmig = {:?}", th.ba.trustup_migration_table.table);
- println!("bmig = {:?}", th.ba.blockage_migration_table.table);
- println!("openinv = {:?}\n", th.bdb.openinv_buckets);
- // That will have introduced a blockage migration. Get the target
- let target: u32 = *th
- .ba
- .blockage_migration_table
- .table
- .iter()
- .next()
- .unwrap()
- .1;
- // Block two of the bridges in that target bucket
- let bt1 = th.ba.bridge_table.buckets[target as usize][1];
- let bt2 = th.ba.bridge_table.buckets[target as usize][2];
- th.ba.bridge_unreachable(&bt1, &mut th.bdb);
- th.ba.bridge_unreachable(&bt2, &mut th.bdb);
- println!("spares = {:?}", th.ba.bridge_table.spares);
- println!("tmig = {:?}", th.ba.trustup_migration_table.table);
- println!("bmig = {:?}", th.ba.blockage_migration_table.table);
- println!("openinv = {:?}\n", th.bdb.openinv_buckets);
- }
- #[test]
- fn test_blockage_migration() {
- let mut th = TestHarness::new();
- // Join an untrusted user
- let cred = th.open_invite().1 .0;
- // Time passes
- th.advance_days(47);
- // Go up to level 1
- let (_mperf_stat, migcred) = th.trust_promotion(&cred);
- let (_perf_stat, cred1) = th.level0_migration(&cred, &migcred);
- assert!(scalar_u32(&cred1.trust_level).unwrap() == 1);
- // Time passes
- th.advance_days(20);
- // Go up to level 2
- let (_two_perf_stat, cred2) = th.level_up(&cred1);
- assert!(scalar_u32(&cred2.trust_level).unwrap() == 2);
- println!("cred2 = {:?}", cred2);
- assert!(th.ba.verify_lox(&cred2));
- // Time passes
- th.advance_days(29);
- // Go up to level 3
- let (_three_perf_stat, cred3) = th.level_up(&cred2);
- assert!(scalar_u32(&cred3.trust_level).unwrap() == 3);
- println!("cred3 = {:?}", cred3);
- assert!(th.ba.verify_lox(&cred3));
- // Get our bridges
- let (id, key) = bridge_table::from_scalar(cred3.bucket).unwrap();
- let encbuckets = th.ba.enc_bridge_table();
- let bucket =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
- // We should have a Bridge Reachability credential
- assert!(bucket.1.is_some());
- // Oh, no! Two of our bridges are blocked!
- th.ba.bridge_unreachable(&bucket.0[0], &mut th.bdb);
- th.ba.bridge_unreachable(&bucket.0[2], &mut th.bdb);
- println!("spares = {:?}", th.ba.bridge_table.spares);
- println!("tmig = {:?}", th.ba.trustup_migration_table.table);
- println!("bmig = {:?}", th.ba.blockage_migration_table.table);
- println!("openinv = {:?}\n", th.bdb.openinv_buckets);
- // Time passes
- th.advance_days(1);
- let encbuckets2 = th.ba.enc_bridge_table();
- let bucket2 =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets2[id as usize]).unwrap();
- // We should no longer have a Bridge Reachability credential
- assert!(bucket2.1.is_none());
- // See about getting a Migration credential for the blockage
- let (_block_perf_stat, migration) = th.check_blockage(&cred3);
- println!("migration = {:?}", migration);
- // Migrate
- let (_four_perf_stat, cred4) = th.blockage_migration(&cred3, &migration);
- println!("cred4 = {:?}", cred4);
- assert!(th.ba.verify_lox(&cred4));
- }
- #[test]
- fn stats_test_trust_levels() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut promo_req_size: Vec<f64> = Vec::new();
- let mut promo_resp_size: Vec<f64> = Vec::new();
- let mut promo_req_time: Vec<f64> = Vec::new();
- let mut promo_resp_time: Vec<f64> = Vec::new();
- let mut promo_resp_handle_time: Vec<f64> = Vec::new();
- let mut mig_req_size: Vec<f64> = Vec::new();
- let mut mig_resp_size: Vec<f64> = Vec::new();
- let mut mig_req_time: Vec<f64> = Vec::new();
- let mut mig_resp_time: Vec<f64> = Vec::new();
- let mut mig_resp_handle_time: Vec<f64> = Vec::new();
- let mut sec_req_size: Vec<f64> = Vec::new();
- let mut sec_resp_size: Vec<f64> = Vec::new();
- let mut sec_req_time: Vec<f64> = Vec::new();
- let mut sec_resp_time: Vec<f64> = Vec::new();
- let mut sec_resp_handle_time: Vec<f64> = Vec::new();
- let mut three_req_size: Vec<f64> = Vec::new();
- let mut three_resp_size: Vec<f64> = Vec::new();
- let mut three_req_time: Vec<f64> = Vec::new();
- let mut three_resp_time: Vec<f64> = Vec::new();
- let mut three_resp_handle_time: Vec<f64> = Vec::new();
- let mut four_req_size: Vec<f64> = Vec::new();
- let mut four_resp_size: Vec<f64> = Vec::new();
- let mut four_req_time: Vec<f64> = Vec::new();
- let mut four_resp_time: Vec<f64> = Vec::new();
- let mut four_resp_handle_time: Vec<f64> = Vec::new();
- let mut open_req_size: Vec<f64> = Vec::new();
- let mut open_resp_size: Vec<f64> = Vec::new();
- let mut open_req_time: Vec<f64> = Vec::new();
- let mut open_resp_time: Vec<f64> = Vec::new();
- let mut open_resp_handle_time: Vec<f64> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let (open_perf_stat, cred) = th.open_invite();
- th.advance_days(30);
- let (tp_perf_stat, migcred) = th.trust_promotion(&cred.0);
- let (mig_perf_stat, cred1) = th.level0_migration(&cred.0, &migcred);
- th.advance_days(14);
- let (sec_perf_stat, cred2) = th.level_up(&cred1);
- th.advance_days(28);
- let (three_perf_stat, cred3) = th.level_up(&cred2);
- th.advance_days(56);
- let (four_perf_stat, _) = th.level_up(&cred3);
- open_req_size.push(open_perf_stat.req_len as f64);
- open_req_time.push(open_perf_stat.req_t.as_secs_f64());
- open_resp_size.push(open_perf_stat.resp_len as f64);
- open_resp_time.push(open_perf_stat.resp_t.as_secs_f64());
- open_resp_handle_time.push(open_perf_stat.resp_handle_t.as_secs_f64());
- promo_req_size.push(tp_perf_stat.req_len as f64);
- promo_req_time.push(tp_perf_stat.req_t.as_secs_f64());
- promo_resp_size.push(tp_perf_stat.resp_len as f64);
- promo_resp_time.push(tp_perf_stat.resp_t.as_secs_f64());
- promo_resp_handle_time.push(tp_perf_stat.resp_handle_t.as_secs_f64());
- mig_req_size.push(mig_perf_stat.req_len as f64);
- mig_req_time.push(mig_perf_stat.req_t.as_secs_f64());
- mig_resp_size.push(mig_perf_stat.resp_len as f64);
- mig_resp_time.push(mig_perf_stat.resp_t.as_secs_f64());
- mig_resp_handle_time.push(mig_perf_stat.resp_handle_t.as_secs_f64());
- sec_req_size.push(sec_perf_stat.req_len as f64);
- sec_req_time.push(sec_perf_stat.req_t.as_secs_f64());
- sec_resp_size.push(sec_perf_stat.resp_len as f64);
- sec_resp_time.push(sec_perf_stat.resp_t.as_secs_f64());
- sec_resp_handle_time.push(sec_perf_stat.resp_handle_t.as_secs_f64());
- three_req_size.push(three_perf_stat.req_len as f64);
- three_req_time.push(three_perf_stat.req_t.as_secs_f64());
- three_resp_size.push(three_perf_stat.resp_len as f64);
- three_resp_time.push(three_perf_stat.resp_t.as_secs_f64());
- three_resp_handle_time.push(three_perf_stat.resp_handle_t.as_secs_f64());
- four_req_size.push(four_perf_stat.req_len as f64);
- four_req_time.push(four_perf_stat.req_t.as_secs_f64());
- four_resp_size.push(four_perf_stat.resp_len as f64);
- four_resp_time.push(four_perf_stat.resp_t.as_secs_f64());
- four_resp_handle_time.push(four_perf_stat.resp_handle_t.as_secs_f64());
- }
- println!("\n***START: {}*3*2 BUCKETS LEVELS***\n", x);
- println!("\n----OPEN-INVITATION-{}---\n", x);
- print_stats_test_results(
- open_req_size,
- open_req_time,
- open_resp_size,
- open_resp_time,
- open_resp_handle_time,
- );
- println!("\n----TRUST-PROMOTION-1: 30 days-{}---\n", x);
- print_stats_test_results(
- promo_req_size,
- promo_req_time,
- promo_resp_size,
- promo_resp_time,
- promo_resp_handle_time,
- );
- println!("\n----TRUST-MIGRATION-0: 30 days-{}---\n", x);
- print_stats_test_results(
- mig_req_size,
- mig_req_time,
- mig_resp_size,
- mig_resp_time,
- mig_resp_handle_time,
- );
- println!("\n----LEVEL-UP-2: 44 days-{}---\n", x);
- print_stats_test_results(
- sec_req_size,
- sec_req_time,
- sec_resp_size,
- sec_resp_time,
- sec_resp_handle_time,
- );
- println!("\n----LEVEL-UP-3: 72 days---{}---\n", x);
- print_stats_test_results(
- three_req_size,
- three_req_time,
- three_resp_size,
- three_resp_time,
- three_resp_handle_time,
- );
- println!("\n----LEVEL-UP-4: 128 days---{}---\n", x);
- print_stats_test_results(
- four_req_size,
- four_req_time,
- four_resp_size,
- four_resp_time,
- four_resp_handle_time,
- );
- }
- }
- #[test]
- fn stats_test_invitations() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut req_size: Vec<f64> = Vec::new();
- let mut resp_size: Vec<f64> = Vec::new();
- let mut req_time: Vec<f64> = Vec::new();
- let mut resp_time: Vec<f64> = Vec::new();
- let mut resp_handle_time: Vec<f64> = Vec::new();
- let mut red_req_size: Vec<f64> = Vec::new();
- let mut red_resp_size: Vec<f64> = Vec::new();
- let mut red_req_time: Vec<f64> = Vec::new();
- let mut red_resp_time: Vec<f64> = Vec::new();
- let mut red_resp_handle_time: Vec<f64> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- th.advance_days(28);
- let (perf_stat, (_, invite)) = th.issue_invite(&cred2);
- let (bob_perf_stat, _) = th.redeem_invite(&invite);
- req_size.push(perf_stat.req_len as f64);
- req_time.push(perf_stat.req_t.as_secs_f64());
- resp_size.push(perf_stat.resp_len as f64);
- resp_time.push(perf_stat.resp_t.as_secs_f64());
- resp_handle_time.push(perf_stat.resp_handle_t.as_secs_f64());
- red_req_size.push(bob_perf_stat.req_len as f64);
- red_req_time.push(bob_perf_stat.req_t.as_secs_f64());
- red_resp_size.push(bob_perf_stat.resp_len as f64);
- red_resp_time.push(bob_perf_stat.resp_t.as_secs_f64());
- red_resp_handle_time.push(bob_perf_stat.resp_handle_t.as_secs_f64());
- }
- println!("\n***START: {}*3*2 BUCKETS INVITATIONS***\n", x);
- println!("\n----ISSUE-INVITATION-{}---\n", x);
- print_stats_test_results(req_size, req_time, resp_size, resp_time, resp_handle_time);
- println!("\n----REDEEM-INVITATION-{}---\n", x);
- print_stats_test_results(
- red_req_size,
- red_req_time,
- red_resp_size,
- red_resp_time,
- red_resp_handle_time,
- );
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_05() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 5***\n", x);
- block_bridges(&mut th, 5, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_010() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 10***\n", x);
- block_bridges(&mut th, 10, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_15() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 15***\n", x);
- block_bridges(&mut th, 15, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_20() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 20***\n", x);
- block_bridges(&mut th, 20, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_25() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 25***\n", x);
- block_bridges(&mut th, 25, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_30() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 30***\n", x);
- block_bridges(&mut th, 30, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_35() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 35***\n", x);
- block_bridges(&mut th, 35, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_40() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 40***\n", x);
- block_bridges(&mut th, 40, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_45() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 45***\n", x);
- block_bridges(&mut th, 45, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_50() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 50***\n", x);
- block_bridges(&mut th, 50, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_55() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 55***\n", x);
- block_bridges(&mut th, 55, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_60() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 60***\n", x);
- block_bridges(&mut th, 60, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_65() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 65***\n", x);
- block_bridges(&mut th, 65, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_70() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 70***\n", x);
- block_bridges(&mut th, 70, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_75() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 75***\n", x);
- block_bridges(&mut th, 75, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_80() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 80***\n", x);
- block_bridges(&mut th, 80, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_85() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 85***\n", x);
- block_bridges(&mut th, 85, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_90() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 90***\n", x);
- block_bridges(&mut th, 90, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_95() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 95***\n", x);
- block_bridges(&mut th, 95, credentials);
- }
- }
- #[test]
- fn stats_test_percent_blockage_migration_100() {
- let buckets: Vec<u16> = vec![150, 300, 450, 600, 750, 900, 1050, 1200, 1350, 1500];
- for x in buckets {
- let mut th = TestHarness::new_buckets(x, x);
- let mut credentials: Vec<cred::Lox> = Vec::new();
- for _ in 0..USERS {
- let h: NaiveTime = DateTime::time(&Utc::now());
- if h.hour() == 23 && h.minute() == 59 {
- println!("Wait for UTC 00:00");
- thread::sleep(Duration::new(60, 0));
- println!("Ready to work again");
- }
- let cred = th.open_invite().1 .0;
- th.advance_days(30);
- let (_, migcred) = th.trust_promotion(&cred);
- let (_, cred1) = th.level0_migration(&cred, &migcred);
- th.advance_days(14);
- let (_, cred2) = th.level_up(&cred1);
- let (_, (cred2a, invite)) = th.issue_invite(&cred2);
- let (_, bob_cred) = th.redeem_invite(&invite);
- th.advance_days(28);
- let (_, _) = th.level_up(&bob_cred);
- let (_, cred3) = th.level_up(&cred2a);
- credentials.push(cred3);
- }
- println!("\n***START: {}*3*2 BUCKETS 100***\n", x);
- block_bridges(&mut th, 100, credentials);
- }
- }
- /// Blocks a percentage of the bridges for the passed Test Harness
- /// excluding the hot spare buckets as they will not have been handed out.
- /// The logic assumes hot spare buckets are appended to the end of the bridge_table
- /// bucket list.
- fn block_bridges(th: &mut TestHarness, percentage: usize, credentials: Vec<cred::Lox>) {
- let blockable_num = th.ba.bridge_table.buckets.len()
- - th.ba.bridge_table.spares.len()
- - th.bdb.openinv_buckets.len();
- let blockable_range = th.ba.bridge_table.buckets.len() - th.ba.bridge_table.spares.len();
- let to_block: usize = blockable_num * percentage / 100;
- let mut block_index: HashSet<usize> = HashSet::new();
- let mut rng = rand::thread_rng();
- while block_index.len() < to_block {
- let rand_num = rng.gen_range(0, blockable_range);
- if !th.bdb.openinv_buckets.contains(&(rand_num as u32)) {
- block_index.insert(rand_num);
- }
- }
- for index in block_index {
- let b0 = th.ba.bridge_table.buckets[index][0];
- let b1 = th.ba.bridge_table.buckets[index][1];
- let b2 = th.ba.bridge_table.buckets[index][2];
- th.ba.bridge_unreachable(&b0, &mut th.bdb);
- th.ba.bridge_unreachable(&b1, &mut th.bdb);
- th.ba.bridge_unreachable(&b2, &mut th.bdb);
- }
- let mut req_size: Vec<f64> = Vec::new();
- let mut resp_size: Vec<f64> = Vec::new();
- let mut req_time: Vec<f64> = Vec::new();
- let mut resp_time: Vec<f64> = Vec::new();
- let mut resp_handle_time: Vec<f64> = Vec::new();
- let mut red_req_size: Vec<f64> = Vec::new();
- let mut red_resp_size: Vec<f64> = Vec::new();
- let mut red_req_time: Vec<f64> = Vec::new();
- let mut red_resp_time: Vec<f64> = Vec::new();
- let mut red_resp_handle_time: Vec<f64> = Vec::new();
- for cred in credentials {
- let (id, key) = bridge_table::from_scalar(cred.bucket).unwrap();
- let encbuckets = th.ba.enc_bridge_table();
- let bucket =
- bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
- let mut count = 0;
- for bridge_line in &bucket.0 {
- if th.ba.bridge_table.reachable.contains_key(bridge_line) {
- count += 1;
- }
- }
- if count < 2 {
- let (perf_stat, migration) = th.check_blockage(&cred);
- let (block_perf_stat, _) = th.blockage_migration(&cred, &migration);
- req_size.push(perf_stat.req_len as f64);
- req_time.push(perf_stat.req_t.as_secs_f64());
- resp_size.push(perf_stat.resp_len as f64);
- resp_time.push(perf_stat.resp_t.as_secs_f64());
- resp_handle_time.push(perf_stat.resp_handle_t.as_secs_f64());
- red_req_size.push(block_perf_stat.req_len as f64);
- red_req_time.push(block_perf_stat.req_t.as_secs_f64());
- red_resp_size.push(block_perf_stat.resp_len as f64);
- red_resp_time.push(block_perf_stat.resp_t.as_secs_f64());
- red_resp_handle_time.push(block_perf_stat.resp_handle_t.as_secs_f64());
- }
- }
- println!("\n----CHECK-BLOCKAGE-{}----\n", percentage);
- print_stats_test_results(req_size, req_time, resp_size, resp_time, resp_handle_time);
- println!("\n----BLOCKAGE-MIGRATION-{}----\n", percentage);
- print_stats_test_results(
- red_req_size,
- red_req_time,
- red_resp_size,
- red_resp_time,
- red_resp_handle_time,
- );
- }
- fn print_test_results(perf_stat: PerfStat) {
- println!("Request size = {:?} bytes", perf_stat.req_len);
- println!("Request time = {:?}", perf_stat.req_t);
- println!("Response size = {:?} bytes", perf_stat.resp_len);
- println!("Response time = {:?}", perf_stat.resp_t);
- println!("Response handle time = {:?}", perf_stat.resp_handle_t);
- }
- //fn print_time_test_results(perf_stat: PerfStat) {
- // println!("Request time = {:?}", perf_stat.req_t);
- // println!("Response time = {:?}", perf_stat.resp_t);
- // println!("Response handle time = {:?}", perf_stat.resp_handle_t);
- //}
- fn print_stats_test_results(
- req_size: Vec<f64>,
- req_time: Vec<f64>,
- resp_size: Vec<f64>,
- resp_time: Vec<f64>,
- resp_handle_time: Vec<f64>,
- ) {
- let mean_req_size = if req_size.len() > 0 {
- mean(&req_size)
- } else {
- 0.0
- };
- let req_std_dev = if req_size.len() > 1 {
- standard_deviation(&req_size, Some(mean_req_size))
- } else {
- 0.0
- };
- let mean_req_time = if req_time.len() > 0 {
- mean(&req_time)
- } else {
- 0.0
- };
- let req_time_std_dev = if req_time.len() > 1 {
- standard_deviation(&req_time, Some(mean_req_time))
- } else {
- 0.0
- };
- let mean_resp_size = if resp_size.len() > 0 {
- mean(&resp_size)
- } else {
- 0.0
- };
- let resp_std_dev = if resp_size.len() > 1 {
- standard_deviation(&resp_size, Some(mean_resp_size))
- } else {
- 0.0
- };
- let mean_resp_time = if resp_time.len() > 0 {
- mean(&resp_time)
- } else {
- 0.0
- };
- let resp_time_std_dev = if resp_time.len() > 1 {
- standard_deviation(&resp_time, Some(mean_resp_time))
- } else {
- 0.0
- };
- let mean_resp_handle_time = if resp_handle_time.len() > 0 {
- mean(&resp_handle_time)
- } else {
- 0.0
- };
- let resp_handle_time_std_dev = if resp_handle_time.len() > 1 {
- standard_deviation(&resp_handle_time, Some(mean_resp_handle_time))
- } else {
- 0.0
- };
- println!("Average request size = {} bytes", mean_req_size);
- println!("Request size standard deviation = {} bytes", req_std_dev);
- println!(
- "Average request time = {:?}",
- Duration::from_secs_f64(mean_req_time)
- );
- println!(
- "Request time standard deviation = {:?}",
- Duration::from_secs_f64(req_time_std_dev)
- );
- println!("Average response size = {} bytes", mean_resp_size);
- println!("Response standard deviation = {} bytes", resp_std_dev);
- println!(
- "Average response time = {:?}",
- Duration::from_secs_f64(mean_resp_time)
- );
- println!(
- "Response time standard deviation = {:?}",
- Duration::from_secs_f64(resp_time_std_dev)
- );
- println!(
- "Average response handling time = {:?}",
- Duration::from_secs_f64(mean_resp_handle_time)
- );
- println!(
- "Response handling time standard deviation = {:?}",
- Duration::from_secs_f64(resp_handle_time_std_dev)
- );
- }
|