Simplify tests

src/proto/issue_invite.rs

@@ -196,133 +196,18 @@ pub fn handle_response(
 #[cfg(all(test, feature = "bridgeauth"))]
 mod tests {
     use super::*;
-    use crate::bridge_table;
     use crate::mock_auth::TestHarness;
-    use crate::proto::{
-        issue_invite,
-        level_up::{self, LEVEL_INTERVAL},
-        migration, open_invite,
-        trust_promotion::{self, UNTRUSTED_INTERVAL},
-    };
 
     #[test]
     fn test_issue_invite() {
         let mut th = TestHarness::new();
         let rng = &mut rand::thread_rng();
-        let open_invitation_request = open_invite::request(rng, th.ba.lox_pub.clone());
-        assert!(
-            open_invitation_request.is_ok(),
-            "Open invitation request should succeed"
-        );
-        let (request, client_state) = open_invitation_request.unwrap();
-        let invite = th.bdb.invite();
-        let open_invitation_response = th.ba.open_invitation(request, &invite.unwrap());
-        assert!(
-            open_invitation_response.is_ok(),
-            "Open invitation response from server should succeed"
-        );
-        let (response, _) = open_invitation_response.unwrap();
-        let creds = open_invite::handle_response(client_state, response);
-        println!("{}", th.ba.today());
-        assert!(creds.is_ok(), "Handle response should succeed");
-        th.advance_days((UNTRUSTED_INTERVAL + 1).try_into().unwrap());
-        println!("{}", th.ba.today());
-        let lox_cred = creds.unwrap();
-        let trust_promo_request = trust_promotion::request(
-            rng,
-            lox_cred.clone(),
-            th.ba.migrationkey_pub.clone(),
-            th.ba.today(),
-        );
-        assert!(
-            trust_promo_request.is_ok(),
-            "Trust Promotion request should succeed"
-        );
-        let (tp_request, tp_client_state) = trust_promo_request.unwrap();
-        let trust_promo_response = th.ba.handle_trust_promotion(tp_request);
-        assert!(
-            trust_promo_response.is_ok(),
-            "Trust promotion response from server should succeed"
-        );
-        let (response, enc) = trust_promo_response.unwrap();
-        let mig_cred = trust_promotion::handle_response(
-            th.ba.migration_pub.clone(),
-            tp_client_state,
-            response,
-            enc,
-        );
-        assert!(mig_cred.is_ok(), "Handle response should succeed");
-        let migration_request = migration::request(
-            rng,
-            lox_cred.clone(),
-            mig_cred.unwrap(),
-            th.ba.lox_pub.clone(),
-        );
-        assert!(
-            migration_request.is_ok(),
-            "Migration request should succeed"
-        );
-        let (mig_request, mig_client_state) = migration_request.unwrap();
-        let migration_response = th.ba.handle_migration(mig_request);
-        assert!(
-            migration_response.is_ok(),
-            "Migration response from server should succeed"
-        );
-        let response = migration_response.unwrap();
-        let mut cred = migration::handle_response(mig_client_state, response);
-        assert!(cred.is_ok(), "Handle response should succeed");
-        let lox_cred = cred.unwrap();
-        let trust_level: u32 = scalar_u32(&lox_cred.clone().trust_level.unwrap()).unwrap();
-        th.advance_days(LEVEL_INTERVAL[trust_level as usize] + 1);
-        let (id, key) = bridge_table::from_scalar(lox_cred.bucket.unwrap()).unwrap();
-        let encbuckets = th.ba.enc_bridge_table().clone();
-        let reach_pub = th.ba.reachability_pub.clone();
-        let bucket = bridge_table::BridgeTable::decrypt_bucket(
-            id,
-            &key,
-            encbuckets.get(&id).unwrap(),
-            &reach_pub,
-        )
-        .unwrap();
-
-        let reachcred = bucket.1.unwrap();
-
-        let level_up_request = level_up::request(
-            rng,
-            lox_cred.clone(),
-            reachcred.clone(),
-            th.ba.lox_pub.clone(),
-            th.ba.today(),
-        );
-        assert!(level_up_request.is_ok(), "Level up request should succeed");
-        let (level_up_request, level_up_client_state) = level_up_request.unwrap();
-        let level_up_response = th.ba.handle_level_up(level_up_request);
-        assert!(
-            level_up_response.is_ok(),
-            "Level up response from server should succeed"
-        );
-        let response = level_up_response.unwrap();
-        cred = level_up::handle_response(level_up_client_state, response);
-        assert!(cred.is_ok(), "Handle response should succeed");
-        let level_up_cred = cred.unwrap();
-        let issue_invite_request = issue_invite::request(
-            rng,
-            level_up_cred.clone(),
-            th.ba.lox_pub.clone(),
-            reachcred.clone(),
-            th.ba.invitation_pub.clone(),
-            th.ba.today(),
-        );
-        let (issue_invite_request, issue_invite_client_state) = issue_invite_request.unwrap();
-        let issue_invite_response = th.ba.handle_issue_invite(issue_invite_request);
-        assert!(
-            issue_invite_response.is_ok(),
-            "Issue Invite response from server should succeed"
-        );
-        let response = issue_invite_response.unwrap();
-        let i_cred = issue_invite::handle_response(issue_invite_client_state, response);
-        assert!(i_cred.is_ok(), "Handle response should succeed");
-        let issue_invite_cred = i_cred.unwrap();
+        let invite = th.bdb.invite().unwrap();
+        let mut lox_cred = th.open_invite(rng, &invite);
+        let mig_cred = th.trust_promotion(rng, lox_cred.clone());
+        lox_cred = th.migration(rng, lox_cred.clone(), mig_cred.clone());
+        lox_cred = th.level_up(rng, lox_cred.clone());
+        let issue_invite_cred = th.issue_invite(rng, lox_cred.clone());
         th.verify_lox(&issue_invite_cred.clone().1);
         th.verify_invitation(&issue_invite_cred.clone().0);
     }

src/proto/level_up.rs

@@ -275,113 +275,17 @@ pub fn handle_response(
 #[cfg(all(test, feature = "bridgeauth"))]
 mod tests {
     use super::*;
-    use crate::bridge_table;
     use crate::mock_auth::TestHarness;
-    use crate::proto::{
-        level_up::{self, LEVEL_INTERVAL},
-        migration, open_invite,
-        trust_promotion::{self, UNTRUSTED_INTERVAL},
-    };
 
     #[test]
     fn test_level_up() {
         let mut th = TestHarness::new();
         let rng = &mut rand::thread_rng();
-        let open_invitation_request = open_invite::request(rng, th.ba.lox_pub.clone());
-        assert!(
-            open_invitation_request.is_ok(),
-            "Open invitation request should succeed"
-        );
-        let (request, client_state) = open_invitation_request.unwrap();
-        let invite = th.bdb.invite();
-        let open_invitation_response = th.ba.open_invitation(request, &invite.unwrap());
-        assert!(
-            open_invitation_response.is_ok(),
-            "Open invitation response from server should succeed"
-        );
-        let (response, _) = open_invitation_response.unwrap();
-        let creds = open_invite::handle_response(client_state, response);
-        println!("{}", th.ba.today());
-        assert!(creds.is_ok(), "Handle response should succeed");
-        th.advance_days((UNTRUSTED_INTERVAL + 1).try_into().unwrap());
-        println!("{}", th.ba.today());
-        let lox_cred = creds.unwrap();
-        let trust_promo_request = trust_promotion::request(
-            rng,
-            lox_cred.clone(),
-            th.ba.migrationkey_pub.clone(),
-            th.ba.today(),
-        );
-        assert!(
-            trust_promo_request.is_ok(),
-            "Trust Promotion request should succeed"
-        );
-        let (tp_request, tp_client_state) = trust_promo_request.unwrap();
-        let trust_promo_response = th.ba.handle_trust_promotion(tp_request);
-        assert!(
-            trust_promo_response.is_ok(),
-            "Trust promotion response from server should succeed"
-        );
-        let (response, enc) = trust_promo_response.unwrap();
-        let mig_cred = trust_promotion::handle_response(
-            th.ba.migration_pub.clone(),
-            tp_client_state,
-            response,
-            enc,
-        );
-        assert!(mig_cred.is_ok(), "Handle response should succeed");
-        let migration_request = migration::request(
-            rng,
-            lox_cred.clone(),
-            mig_cred.unwrap(),
-            th.ba.lox_pub.clone(),
-        );
-        assert!(
-            migration_request.is_ok(),
-            "Migration request should succeed"
-        );
-        let (mig_request, mig_client_state) = migration_request.unwrap();
-        let migration_response = th.ba.handle_migration(mig_request);
-        assert!(
-            migration_response.is_ok(),
-            "Migration response from server should succeed"
-        );
-        let response = migration_response.unwrap();
-        let mut cred = migration::handle_response(mig_client_state, response);
-        assert!(cred.is_ok(), "Handle response should succeed");
-        let lox_cred = cred.unwrap();
-        let trust_level: u32 = scalar_u32(&lox_cred.clone().trust_level.unwrap()).unwrap();
-        th.advance_days(LEVEL_INTERVAL[trust_level as usize] + 1);
-        let (id, key) = bridge_table::from_scalar(lox_cred.bucket.unwrap()).unwrap();
-        let encbuckets = th.ba.enc_bridge_table().clone();
-        let reach_pub = th.ba.reachability_pub.clone();
-        let bucket = bridge_table::BridgeTable::decrypt_bucket(
-            id,
-            &key,
-            encbuckets.get(&id).unwrap(),
-            &reach_pub,
-        )
-        .unwrap();
-
-        let reachcred = bucket.1.unwrap();
-
-        let level_up_request = level_up::request(
-            rng,
-            lox_cred.clone(),
-            reachcred,
-            th.ba.lox_pub.clone(),
-            th.ba.today(),
-        );
-        assert!(level_up_request.is_ok(), "Level up request should succeed");
-        let (level_up_request, level_up_client_state) = level_up_request.unwrap();
-        let level_up_response = th.ba.handle_level_up(level_up_request);
-        assert!(
-            level_up_response.is_ok(),
-            "Level up response from server should succeed"
-        );
-        let response = level_up_response.unwrap();
-        cred = level_up::handle_response(level_up_client_state, response);
-        assert!(cred.is_ok(), "Handle response should succeed");
-        th.verify_lox(&cred.unwrap());
+        let invite = th.bdb.invite().unwrap();
+        let mut lox_cred = th.open_invite(rng, &invite);
+        let mig_cred = th.trust_promotion(rng, lox_cred.clone());
+        lox_cred = th.migration(rng, lox_cred.clone(), mig_cred.clone());
+        lox_cred = th.level_up(rng, lox_cred.clone());
+        th.verify_lox(&lox_cred);
     }
 }

src/proto/migration.rs

@@ -162,77 +162,15 @@ pub fn handle_response(
 mod tests {
     use super::*;
     use crate::mock_auth::TestHarness;
-    use crate::proto::{
-        migration, open_invite,
-        trust_promotion::{self, UNTRUSTED_INTERVAL},
-    };
 
     #[test]
     fn test_trust_migration() {
         let mut th = TestHarness::new();
         let rng = &mut rand::thread_rng();
-        let open_invitation_request = open_invite::request(rng, th.ba.lox_pub.clone());
-        assert!(
-            open_invitation_request.is_ok(),
-            "Open invitation request should succeed"
-        );
-        let (request, client_state) = open_invitation_request.unwrap();
-        let invite = th.bdb.invite();
-        let open_invitation_response = th.ba.open_invitation(request, &invite.unwrap());
-        assert!(
-            open_invitation_response.is_ok(),
-            "Open invitation response from server should succeed"
-        );
-        let (response, _) = open_invitation_response.unwrap();
-        let creds = open_invite::handle_response(client_state, response);
-        println!("{}", th.ba.today());
-        assert!(creds.is_ok(), "Handle response should succeed");
-        th.advance_days((UNTRUSTED_INTERVAL + 1).try_into().unwrap());
-        println!("{}", th.ba.today());
-        let lox_cred = creds.unwrap();
-        let trust_promo_request = trust_promotion::request(
-            rng,
-            lox_cred.clone(),
-            th.ba.migrationkey_pub.clone(),
-            th.ba.today(),
-        );
-        assert!(
-            trust_promo_request.is_ok(),
-            "Trust Promotion request should succeed"
-        );
-        let (tp_request, tp_client_state) = trust_promo_request.unwrap();
-        let trust_promo_response = th.ba.handle_trust_promotion(tp_request);
-        assert!(
-            trust_promo_response.is_ok(),
-            "Trust promotion response from server should succeed"
-        );
-        let (response, enc) = trust_promo_response.unwrap();
-        let mig_cred = trust_promotion::handle_response(
-            th.ba.migration_pub.clone(),
-            tp_client_state,
-            response,
-            enc,
-        );
-        assert!(mig_cred.is_ok(), "Handle response should succeed");
-        let migration_request = migration::request(
-            rng,
-            lox_cred.clone(),
-            mig_cred.unwrap(),
-            th.ba.lox_pub.clone(),
-        );
-        assert!(
-            migration_request.is_ok(),
-            "Migration request should succeed"
-        );
-        let (mig_request, mig_client_state) = migration_request.unwrap();
-        let migration_response = th.ba.handle_migration(mig_request);
-        assert!(
-            migration_response.is_ok(),
-            "Migration response from server should succeed"
-        );
-        let response = migration_response.unwrap();
-        let cred = migration::handle_response(mig_client_state, response);
-        assert!(cred.is_ok(), "Handle response should succeed");
-        th.verify_lox(&cred.unwrap());
+        let invite = th.bdb.invite().unwrap();
+        let mut lox_cred = th.open_invite(rng, &invite);
+        let mig_cred = th.trust_promotion(rng, lox_cred.clone());
+        lox_cred = th.migration(rng, lox_cred.clone(), mig_cred.clone());
+        th.verify_lox(&lox_cred);
     }
 }

src/proto/open_invite.rs

@@ -166,21 +166,8 @@ mod tests {
     fn test_open_invitation() {
         let mut th = TestHarness::new();
         let rng = &mut rand::thread_rng();
-        let open_invitation_request = request(rng, th.ba.lox_pub.clone());
-        assert!(
-            open_invitation_request.is_ok(),
-            "Open invitation request should succeed"
-        );
-        let (request, client_state) = open_invitation_request.unwrap();
-        let invite = th.bdb.invite();
-        let open_invitation_response = th.ba.open_invitation(request, &invite.unwrap());
-        assert!(
-            open_invitation_response.is_ok(),
-            "Open invitation response from server should succeed"
-        );
-        let (response, _) = open_invitation_response.unwrap();
-        let creds = handle_response(client_state, response);
-        assert!(creds.is_ok(), "Handle response should succeed");
-        th.verify_lox(&creds.unwrap());
+        let invite = th.bdb.invite().unwrap();
+        let cred = th.open_invite(rng, &invite);
+        th.verify_lox(&cred);
     }
 }

src/proto/redeem_invite.rs

@@ -153,133 +153,19 @@ pub fn handle_response(
 #[cfg(all(test, feature = "bridgeauth"))]
 mod tests {
     use super::*;
-    use crate::bridge_table;
     use crate::mock_auth::TestHarness;
-    use crate::proto::{
-        issue_invite,
-        level_up::{self, LEVEL_INTERVAL},
-        migration, open_invite, redeem_invite,
-        trust_promotion::{self, UNTRUSTED_INTERVAL},
-    };
+    use crate::proto::redeem_invite;
 
     #[test]
     fn test_redeem_invite() {
         let mut th = TestHarness::new();
         let rng = &mut rand::thread_rng();
-        let open_invitation_request = open_invite::request(rng, th.ba.lox_pub.clone());
-        assert!(
-            open_invitation_request.is_ok(),
-            "Open invitation request should succeed"
-        );
-        let (request, client_state) = open_invitation_request.unwrap();
-        let invite = th.bdb.invite();
-        let open_invitation_response = th.ba.open_invitation(request, &invite.unwrap());
-        assert!(
-            open_invitation_response.is_ok(),
-            "Open invitation response from server should succeed"
-        );
-        let (response, _) = open_invitation_response.unwrap();
-        let creds = open_invite::handle_response(client_state, response);
-        println!("{}", th.ba.today());
-        assert!(creds.is_ok(), "Handle response should succeed");
-        th.advance_days((UNTRUSTED_INTERVAL + 1).try_into().unwrap());
-        println!("{}", th.ba.today());
-        let lox_cred = creds.unwrap();
-        let trust_promo_request = trust_promotion::request(
-            rng,
-            lox_cred.clone(),
-            th.ba.migrationkey_pub.clone(),
-            th.ba.today(),
-        );
-        assert!(
-            trust_promo_request.is_ok(),
-            "Trust Promotion request should succeed"
-        );
-        let (tp_request, tp_client_state) = trust_promo_request.unwrap();
-        let trust_promo_response = th.ba.handle_trust_promotion(tp_request);
-        assert!(
-            trust_promo_response.is_ok(),
-            "Trust promotion response from server should succeed"
-        );
-        let (response, enc) = trust_promo_response.unwrap();
-        let mig_cred = trust_promotion::handle_response(
-            th.ba.migration_pub.clone(),
-            tp_client_state,
-            response,
-            enc,
-        );
-        assert!(mig_cred.is_ok(), "Handle response should succeed");
-        let migration_request = migration::request(
-            rng,
-            lox_cred.clone(),
-            mig_cred.unwrap(),
-            th.ba.lox_pub.clone(),
-        );
-        assert!(
-            migration_request.is_ok(),
-            "Migration request should succeed"
-        );
-        let (mig_request, mig_client_state) = migration_request.unwrap();
-        let migration_response = th.ba.handle_migration(mig_request);
-        assert!(
-            migration_response.is_ok(),
-            "Migration response from server should succeed"
-        );
-        let response = migration_response.unwrap();
-        let mut cred = migration::handle_response(mig_client_state, response);
-        assert!(cred.is_ok(), "Handle response should succeed");
-        let lox_cred = cred.unwrap();
-        let trust_level: u32 = scalar_u32(&lox_cred.clone().trust_level.unwrap()).unwrap();
-        th.advance_days(LEVEL_INTERVAL[trust_level as usize] + 1);
-        let (id, key) = bridge_table::from_scalar(lox_cred.bucket.unwrap()).unwrap();
-        let encbuckets = th.ba.enc_bridge_table().clone();
-        let reach_pub = th.ba.reachability_pub.clone();
-        let bucket = bridge_table::BridgeTable::decrypt_bucket(
-            id,
-            &key,
-            encbuckets.get(&id).unwrap(),
-            &reach_pub,
-        )
-        .unwrap();
-
-        let reachcred = bucket.1.unwrap();
-
-        let level_up_request = level_up::request(
-            rng,
-            lox_cred.clone(),
-            reachcred.clone(),
-            th.ba.lox_pub.clone(),
-            th.ba.today(),
-        );
-        assert!(level_up_request.is_ok(), "Level up request should succeed");
-        let (level_up_request, level_up_client_state) = level_up_request.unwrap();
-        let level_up_response = th.ba.handle_level_up(level_up_request);
-        assert!(
-            level_up_response.is_ok(),
-            "Level up response from server should succeed"
-        );
-        let response = level_up_response.unwrap();
-        cred = level_up::handle_response(level_up_client_state, response);
-        assert!(cred.is_ok(), "Handle response should succeed");
-        let level_up_cred = cred.unwrap();
-        let issue_invite_request = issue_invite::request(
-            rng,
-            level_up_cred.clone(),
-            th.ba.lox_pub.clone(),
-            reachcred.clone(),
-            th.ba.invitation_pub.clone(),
-            th.ba.today(),
-        );
-        let (issue_invite_request, issue_invite_client_state) = issue_invite_request.unwrap();
-        let issue_invite_response = th.ba.handle_issue_invite(issue_invite_request);
-        assert!(
-            issue_invite_response.is_ok(),
-            "Issue Invite response from server should succeed"
-        );
-        let response = issue_invite_response.unwrap();
-        let i_cred = issue_invite::handle_response(issue_invite_client_state, response);
-        assert!(i_cred.is_ok(), "Handle response should succeed");
-        let issue_invite_cred = i_cred.unwrap();
+        let invite = th.bdb.invite().unwrap();
+        let mut lox_cred = th.open_invite(rng, &invite);
+        let mig_cred = th.trust_promotion(rng, lox_cred.clone());
+        lox_cred = th.migration(rng, lox_cred.clone(), mig_cred.clone());
+        lox_cred = th.level_up(rng, lox_cred.clone());
+        let issue_invite_cred = th.issue_invite(rng, lox_cred.clone());
         let redeem_invite_request = redeem_invite::request(
             rng,
             issue_invite_cred.clone().0,

src/proto/trust_promotion.rs

@@ -198,54 +198,14 @@ pub fn handle_response(
 mod tests {
     use super::*;
     use crate::mock_auth::TestHarness;
-    use crate::proto::{open_invite, trust_promotion};
 
     #[test]
     fn test_trust_promotion() {
         let mut th = TestHarness::new();
         let rng = &mut rand::thread_rng();
-        let open_invitation_request = open_invite::request(rng, th.ba.lox_pub.clone());
-        assert!(
-            open_invitation_request.is_ok(),
-            "Open invitation request should succeed"
-        );
-        let (request, client_state) = open_invitation_request.unwrap();
-        let invite = th.bdb.invite();
-        let open_invitation_response = th.ba.open_invitation(request, &invite.unwrap());
-        assert!(
-            open_invitation_response.is_ok(),
-            "Open invitation response from server should succeed"
-        );
-        let (response, _) = open_invitation_response.unwrap();
-        let creds = open_invite::handle_response(client_state, response);
-        println!("{}", th.ba.today());
-        assert!(creds.is_ok(), "Handle response should succeed");
-        th.advance_days((UNTRUSTED_INTERVAL + 1).try_into().unwrap());
-        println!("{}", th.ba.today());
-        let trust_promo_request = trust_promotion::request(
-            rng,
-            creds.unwrap(),
-            th.ba.migrationkey_pub.clone(),
-            th.ba.today(),
-        );
-        assert!(
-            trust_promo_request.is_ok(),
-            "Trust Promotion request should succeed"
-        );
-        let (tp_request, tp_client_state) = trust_promo_request.unwrap();
-        let trust_promo_response = th.ba.handle_trust_promotion(tp_request);
-        assert!(
-            trust_promo_response.is_ok(),
-            "Trust promotion response from server should succeed"
-        );
-        let (response, enc) = trust_promo_response.unwrap();
-        let creds = trust_promotion::handle_response(
-            th.ba.migration_pub.clone(),
-            tp_client_state,
-            response,
-            enc,
-        );
-        assert!(creds.is_ok(), "Handle response should succeed");
-        th.verify_migration(&creds.unwrap());
+        let invite = th.bdb.invite().unwrap();
+        let lox_cred = th.open_invite(rng, &invite);
+        let mig_cred = th.trust_promotion(rng, lox_cred.clone());
+        th.verify_migration(&mig_cred);
     }
 }

src/proto/update_cred.rs

@@ -156,30 +156,18 @@ pub fn handle_response(
 mod tests {
     use super::*;
     use crate::mock_auth::TestHarness;
-    use crate::proto::{open_invite, update_cred};
+    use crate::proto::update_cred;
 
     #[test]
     fn test_update_cred() {
         let mut th = TestHarness::new();
         let rng = &mut rand::thread_rng();
-        let open_invitation_request = open_invite::request(rng, th.ba.lox_pub.clone());
-        assert!(
-            open_invitation_request.is_ok(),
-            "Open invitation request should succeed"
-        );
-        let (request, client_state) = open_invitation_request.unwrap();
-        let invite = th.bdb.invite();
-        let open_invitation_response = th.ba.open_invitation(request, &invite.unwrap());
-        assert!(
-            open_invitation_response.is_ok(),
-            "Open invitation response from server should succeed"
-        );
-        let (response, _) = open_invitation_response.unwrap();
-        let creds = open_invite::handle_response(client_state, response);
-        assert!(creds.is_ok(), "Handle response should succeed");
+        let invite = th.bdb.invite().unwrap();
+        let lox_cred = th.open_invite(rng, &invite);
         let old_pub = th.ba.lox_pub.clone();
         th.ba.rotate_lox_keys(rng);
-        let update_cred_request = update_cred::request(rng, creds.unwrap(), th.ba.lox_pub.clone());
+        let update_cred_request =
+            update_cred::request(rng, lox_cred.clone(), th.ba.lox_pub.clone());
         assert!(
             update_cred_request.is_ok(),
             "Update credential request should succeed"

src/proto/update_invite.rs

@@ -144,136 +144,19 @@ pub fn handle_response(
 #[cfg(all(test, feature = "bridgeauth"))]
 mod tests {
     use super::*;
-    use crate::bridge_table;
     use crate::mock_auth::TestHarness;
-    use crate::proto::{
-        issue_invite,
-        level_up::{self, LEVEL_INTERVAL},
-        migration, open_invite,
-        trust_promotion::{self, UNTRUSTED_INTERVAL},
-        update_invite,
-    };
-    use crate::scalar_u32;
+    use crate::proto::update_invite;
 
     #[test]
     fn test_update_invite() {
         let mut th = TestHarness::new();
         let rng = &mut rand::thread_rng();
-        let open_invitation_request = open_invite::request(rng, th.ba.lox_pub.clone());
-        assert!(
-            open_invitation_request.is_ok(),
-            "Open invitation request should succeed"
-        );
-        let (request, client_state) = open_invitation_request.unwrap();
-        let invite = th.bdb.invite();
-        let open_invitation_response = th.ba.open_invitation(request, &invite.unwrap());
-        assert!(
-            open_invitation_response.is_ok(),
-            "Open invitation response from server should succeed"
-        );
-        let (response, _) = open_invitation_response.unwrap();
-        let creds = open_invite::handle_response(client_state, response);
-        println!("{}", th.ba.today());
-        assert!(creds.is_ok(), "Handle response should succeed");
-        th.advance_days((UNTRUSTED_INTERVAL + 1).try_into().unwrap());
-        println!("{}", th.ba.today());
-        let lox_cred = creds.unwrap();
-        let trust_promo_request = trust_promotion::request(
-            rng,
-            lox_cred.clone(),
-            th.ba.migrationkey_pub.clone(),
-            th.ba.today(),
-        );
-        assert!(
-            trust_promo_request.is_ok(),
-            "Trust Promotion request should succeed"
-        );
-        let (tp_request, tp_client_state) = trust_promo_request.unwrap();
-        let trust_promo_response = th.ba.handle_trust_promotion(tp_request);
-        assert!(
-            trust_promo_response.is_ok(),
-            "Trust promotion response from server should succeed"
-        );
-        let (response, enc) = trust_promo_response.unwrap();
-        let mig_cred = trust_promotion::handle_response(
-            th.ba.migration_pub.clone(),
-            tp_client_state,
-            response,
-            enc,
-        );
-        assert!(mig_cred.is_ok(), "Handle response should succeed");
-        let migration_request = migration::request(
-            rng,
-            lox_cred.clone(),
-            mig_cred.unwrap(),
-            th.ba.lox_pub.clone(),
-        );
-        assert!(
-            migration_request.is_ok(),
-            "Migration request should succeed"
-        );
-        let (mig_request, mig_client_state) = migration_request.unwrap();
-        let migration_response = th.ba.handle_migration(mig_request);
-        assert!(
-            migration_response.is_ok(),
-            "Migration response from server should succeed"
-        );
-        let response = migration_response.unwrap();
-        let mut cred = migration::handle_response(mig_client_state, response);
-        assert!(cred.is_ok(), "Handle response should succeed");
-        let lox_cred = cred.unwrap();
-        let trust_level: u32 = scalar_u32(&lox_cred.clone().trust_level.unwrap()).unwrap();
-        th.advance_days(LEVEL_INTERVAL[trust_level as usize] + 1);
-        let (id, key) = bridge_table::from_scalar(lox_cred.bucket.unwrap()).unwrap();
-        let encbuckets = th.ba.enc_bridge_table().clone();
-        let reach_pub = th.ba.reachability_pub.clone();
-        let bucket = bridge_table::BridgeTable::decrypt_bucket(
-            id,
-            &key,
-            encbuckets.get(&id).unwrap(),
-            &reach_pub,
-        )
-        .unwrap();
-
-        let reachcred = bucket.1.unwrap();
-
-        let level_up_request = level_up::request(
-            rng,
-            lox_cred.clone(),
-            reachcred.clone(),
-            th.ba.lox_pub.clone(),
-            th.ba.today(),
-        );
-        assert!(level_up_request.is_ok(), "Level up request should succeed");
-        let (level_up_request, level_up_client_state) = level_up_request.unwrap();
-        let level_up_response = th.ba.handle_level_up(level_up_request);
-        assert!(
-            level_up_response.is_ok(),
-            "Level up response from server should succeed"
-        );
-        let response = level_up_response.unwrap();
-        cred = level_up::handle_response(level_up_client_state, response);
-        assert!(cred.is_ok(), "Handle response should succeed");
-        let level_up_cred = cred.unwrap();
-        let issue_invite_request = issue_invite::request(
-            rng,
-            level_up_cred.clone(),
-            th.ba.lox_pub.clone(),
-            reachcred.clone(),
-            th.ba.invitation_pub.clone(),
-            th.ba.today(),
-        );
-        let (issue_invite_request, issue_invite_client_state) = issue_invite_request.unwrap();
-        let issue_invite_response = th.ba.handle_issue_invite(issue_invite_request);
-        assert!(
-            issue_invite_response.is_ok(),
-            "Issue Invite response from server should succeed"
-        );
-        let response = issue_invite_response.unwrap();
-        let i_cred = issue_invite::handle_response(issue_invite_client_state, response);
-        assert!(i_cred.is_ok(), "Handle response should succeed");
-        let issue_invite_cred = i_cred.unwrap();
-
+        let invite = th.bdb.invite().unwrap();
+        let mut lox_cred = th.open_invite(rng, &invite);
+        let mig_cred = th.trust_promotion(rng, lox_cred.clone());
+        lox_cred = th.migration(rng, lox_cred.clone(), mig_cred.clone());
+        lox_cred = th.level_up(rng, lox_cred.clone());
+        let issue_invite_cred = th.issue_invite(rng, lox_cred.clone());
         let old_pub = th.ba.invitation_pub.clone();
         th.ba.rotate_invitation_keys(rng);
         let update_invite_request = update_invite::request(