Make an easier to use test harness

src/tests.rs

@@ -5,272 +5,301 @@ use super::bridge_table::BridgeLine;
 use super::proto::*;
 use super::*;
 
-#[test]
-fn test_open_invite() {
-    // Create a BridegDb
-    let bdb = BridgeDb::new(20);
-    // Create a BridgeAuth
-    let mut ba = BridgeAuth::new(bdb.pubkey);
-
-    // Make 20 buckets with one random bridge each
-    for _ in 0..20 {
-        let bucket: [BridgeLine; 3] =
-            [BridgeLine::random(), Default::default(), Default::default()];
-        ba.bridge_table.new_bucket(bucket);
-    }
-    // And 20 more with three random bridges each
-    for _ in 0..20 {
-        let bucket: [BridgeLine; 3] = [
-            BridgeLine::random(),
-            BridgeLine::random(),
-            BridgeLine::random(),
-        ];
-        ba.bridge_table.new_bucket(bucket);
+struct TestHarness {
+    bdb: BridgeDb,
+    pub ba: BridgeAuth,
+}
+
+impl TestHarness {
+    fn new() -> Self {
+        // Create a BridegDb
+        let bdb = BridgeDb::new(15);
+        // Create a BridgeAuth
+        let mut ba = BridgeAuth::new(bdb.pubkey);
+
+        // Make 15 buckets with one random bridge each
+        for _ in 0..15 {
+            let bucket: [BridgeLine; 3] =
+                [BridgeLine::random(), Default::default(), Default::default()];
+            ba.bridge_table.new_bucket(bucket);
+        }
+        // Make 5 more buckets, each containing 3 of the previously
+        // created bridges
+        for i in 0u32..5 {
+            let iusize = i as usize;
+            let bucket: [BridgeLine; 3] = [
+                ba.bridge_table.buckets[3 * iusize][0],
+                ba.bridge_table.buckets[3 * iusize + 1][0],
+                ba.bridge_table.buckets[3 * iusize + 2][0],
+            ];
+            ba.bridge_table.new_bucket(bucket);
+            // Add the allowed migrations to the migration table
+            ba.migration_table.table.insert(3 * i, 15 + i);
+            ba.migration_table.table.insert(3 * i + 1, 15 + i);
+            ba.migration_table.table.insert(3 * i + 2, 15 + i);
+        }
+        // Create the encrypted bridge table
+        ba.enc_bridge_table();
+
+        Self { bdb, ba }
     }
-    // Create the encrypted bridge table
-    ba.enc_bridge_table();
 
-    // Issue an open invitation
-    let inv = bdb.invite();
+    fn advance_days(&mut self, days: u16) {
+        self.ba.advance_days(days);
+    }
 
-    // Use it to get a Lox credential
-    let (req, state) = open_invite::request(&inv);
-    let resp = ba.handle_open_invite(req).unwrap();
-    let cred = open_invite::handle_response(state, resp, &ba.lox_pub).unwrap();
+    fn open_invite(&mut self) -> cred::Lox {
+        // Issue an open invitation
+        let inv = self.bdb.invite();
 
-    // Check that we can use the credential to read a bucket
-    let (id, key) = bridge_table::from_scalar(cred.bucket).unwrap();
-    let encbuckets = ba.enc_bridge_table();
-    let bucket =
-        bridge_table::BridgeTable::decrypt_bucket(id, &key, &encbuckets[id as usize]).unwrap();
-    println!("cred = {:?}", cred);
-    println!("bucket = {:?}", bucket);
-    assert!(bucket.1.is_none());
-    assert!(ba.verify_lox(&cred));
-}
+        // Use it to get a Lox credential
+        let (req, state) = open_invite::request(&inv);
+        let resp = self.ba.handle_open_invite(req).unwrap();
+        open_invite::handle_response(state, resp, &self.ba.lox_pub).unwrap()
+    }
 
-fn setup() -> (BridgeDb, BridgeAuth) {
-    // Create a BridegDb
-    let bdb = BridgeDb::new(15);
-    // Create a BridgeAuth
-    let mut ba = BridgeAuth::new(bdb.pubkey);
-
-    // Make 15 buckets with one random bridge each
-    for _ in 0..15 {
-        let bucket: [BridgeLine; 3] =
-            [BridgeLine::random(), Default::default(), Default::default()];
-        ba.bridge_table.new_bucket(bucket);
+    fn trust_promotion(&mut self, cred: &cred::Lox) -> cred::Migration {
+        let (promreq, promstate) =
+            trust_promotion::request(&cred, &self.ba.lox_pub, self.ba.today()).unwrap();
+        let promresp = self.ba.handle_trust_promotion(promreq).unwrap();
+        trust_promotion::handle_response(promstate, promresp).unwrap()
     }
-    // Make 5 more buckets, each containing 3 of the previously
-    // created bridges
-    for i in 0u32..5 {
-        let iusize = i as usize;
-        let bucket: [BridgeLine; 3] = [
-            ba.bridge_table.buckets[3 * iusize][0],
-            ba.bridge_table.buckets[3 * iusize + 1][0],
-            ba.bridge_table.buckets[3 * iusize + 2][0],
-        ];
-        ba.bridge_table.new_bucket(bucket);
-        // Add the allowed migrations to the migration table
-        ba.migration_table.table.insert(3 * i, 15 + i);
-        ba.migration_table.table.insert(3 * i + 1, 15 + i);
-        ba.migration_table.table.insert(3 * i + 2, 15 + i);
+
+    fn level0_migration(&mut self, loxcred: &cred::Lox, migcred: &cred::Migration) -> cred::Lox {
+        let (migreq, migstate) =
+            migration::request(loxcred, migcred, &self.ba.lox_pub, &self.ba.migration_pub).unwrap();
+        let migresp = self.ba.handle_migration(migreq).unwrap();
+        migration::handle_response(migstate, migresp, &self.ba.lox_pub).unwrap()
     }
-    // Create the encrypted bridge table
-    ba.enc_bridge_table();
 
-    (bdb, ba)
-}
+    fn level_up(&mut self, cred: &cred::Lox) -> 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, state) = level_up::request(
+            &cred,
+            &reachcred,
+            &self.ba.lox_pub,
+            &self.ba.reachability_pub,
+            self.ba.today(),
+        )
+        .unwrap();
+        let resp = self.ba.handle_level_up(req).unwrap();
+        level_up::handle_response(state, resp, &self.ba.lox_pub).unwrap()
+    }
 
-fn trust_promotion(bdb: &BridgeDb, ba: &mut BridgeAuth) -> (cred::Lox, cred::Migration) {
-    // Issue an open invitation
-    let inv = bdb.invite();
+    fn issue_invite(&mut self, cred: &cred::Lox) -> (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, state) = issue_invite::request(
+            &cred,
+            &reachcred,
+            &self.ba.lox_pub,
+            &self.ba.reachability_pub,
+            self.ba.today(),
+        )
+        .unwrap();
+        let resp = self.ba.handle_issue_invite(req).unwrap();
+        issue_invite::handle_response(state, resp, &self.ba.lox_pub, &self.ba.invitation_pub)
+            .unwrap()
+    }
 
-    // Use it to get a Lox credential
-    let (req, state) = open_invite::request(&inv);
-    let resp = ba.handle_open_invite(req).unwrap();
-    let cred = open_invite::handle_response(state, resp, &ba.lox_pub).unwrap();
-    assert!(ba.verify_lox(&cred));
+    fn redeem_invite(&mut self, inv: &cred::Invitation) -> cred::Lox {
+        let (req, state) =
+            redeem_invite::request(&inv, &self.ba.invitation_pub, self.ba.today()).unwrap();
+        let resp = self.ba.handle_redeem_invite(req).unwrap();
+        redeem_invite::handle_response(state, resp, &self.ba.lox_pub).unwrap()
+    }
+}
 
-    // Time passes
-    ba.advance_days(47);
+#[test]
+fn test_open_invite() {
+    let mut th = TestHarness::new();
 
-    let (promreq, promstate) = trust_promotion::request(&cred, &ba.lox_pub, ba.today()).unwrap();
-    let promresp = ba.handle_trust_promotion(promreq).unwrap();
-    let migcred = trust_promotion::handle_response(promstate, promresp).unwrap();
+    // Join an untrusted user
+    let cred = th.open_invite();
 
-    (cred, migcred)
+    // 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();
+    println!("cred = {:?}", cred);
+    println!("bucket = {:?}", bucket);
+    assert!(bucket.1.is_none());
+    assert!(th.ba.verify_lox(&cred));
 }
 
 #[test]
 fn test_trust_promotion() {
-    let (bdb, mut ba) = setup();
+    let mut th = TestHarness::new();
 
-    let (_loxcred, migcred) = trust_promotion(&bdb, &mut ba);
+    let cred = th.open_invite();
+    assert!(th.ba.verify_lox(&cred));
+
+    // Time passes
+    th.advance_days(47);
+
+    let migcred = th.trust_promotion(&cred);
+    assert!(th.ba.verify_migration(&migcred));
 
-    assert!(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 = ba.enc_bridge_table();
+    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!(ba.verify_reachability(&bucket.1.unwrap()));
-}
-
-fn level0_migration(bdb: &BridgeDb, ba: &mut BridgeAuth) -> cred::Lox {
-    let (loxcred, migcred) = trust_promotion(bdb, ba);
-
-    let (migreq, migstate) =
-        migration::request(&loxcred, &migcred, &ba.lox_pub, &ba.migration_pub).unwrap();
-    let migresp = ba.handle_migration(migreq).unwrap();
-    let newloxcred = migration::handle_response(migstate, migresp, &ba.lox_pub).unwrap();
-    newloxcred
+    assert!(th.ba.verify_reachability(&bucket.1.unwrap()));
 }
 
 #[test]
 fn test_level0_migration() {
-    let (bdb, mut ba) = setup();
+    let mut th = TestHarness::new();
+
+    let cred = th.open_invite();
+    assert!(th.ba.verify_lox(&cred));
+
+    // Time passes
+    th.advance_days(47);
 
-    let newloxcred = level0_migration(&bdb, &mut ba);
+    let migcred = th.trust_promotion(&cred);
+    assert!(th.ba.verify_migration(&migcred));
 
-    assert!(ba.verify_lox(&newloxcred));
+    let newloxcred = th.level0_migration(&cred, &migcred);
+
+    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 = ba.enc_bridge_table();
+    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!(ba.verify_reachability(&bucket.1.unwrap()));
-}
-
-fn level_up(ba: &mut BridgeAuth, cred: &cred::Lox) -> 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 = 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, state) = level_up::request(
-        &cred,
-        &reachcred,
-        &ba.lox_pub,
-        &ba.reachability_pub,
-        ba.today(),
-    )
-    .unwrap();
-    let resp = ba.handle_level_up(req).unwrap();
-    let cred = level_up::handle_response(state, resp, &ba.lox_pub).unwrap();
-    cred
+    assert!(th.ba.verify_reachability(&bucket.1.unwrap()));
 }
 
 #[test]
 fn test_level_up() {
-    let (bdb, mut ba) = setup();
-    let cred1 = level0_migration(&bdb, &mut ba);
+    let mut th = TestHarness::new();
+
+    // Join an untrusted user
+    let cred = th.open_invite();
+
+    // Time passes
+    th.advance_days(47);
+
+    // Go up to level 1
+    let migcred = th.trust_promotion(&cred);
+    let cred1 = th.level0_migration(&cred, &migcred);
     assert!(scalar_u32(&cred1.trust_level).unwrap() == 1);
 
     // Time passes
-    ba.advance_days(20);
+    th.advance_days(20);
 
-    let cred2 = level_up(&mut ba, &cred1);
+    let cred2 = th.level_up(&cred1);
     assert!(scalar_u32(&cred2.trust_level).unwrap() == 2);
     println!("cred2 = {:?}", cred2);
-    assert!(ba.verify_lox(&cred2));
+    assert!(th.ba.verify_lox(&cred2));
 
     // Time passes
-    ba.advance_days(30);
+    th.advance_days(30);
 
-    let cred3 = level_up(&mut ba, &cred2);
+    let cred3 = th.level_up(&cred2);
     assert!(scalar_u32(&cred3.trust_level).unwrap() == 3);
     println!("cred3 = {:?}", cred3);
-    assert!(ba.verify_lox(&cred3));
+    assert!(th.ba.verify_lox(&cred3));
 
     // Time passes
-    ba.advance_days(60);
+    th.advance_days(60);
 
-    let cred4 = level_up(&mut ba, &cred3);
+    let cred4 = th.level_up(&cred3);
     assert!(scalar_u32(&cred3.trust_level).unwrap() == 3);
     println!("cred4 = {:?}", cred4);
-    assert!(ba.verify_lox(&cred4));
-}
-
-fn issue_invite(ba: &mut BridgeAuth, cred: &cred::Lox) -> (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 = 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, state) = issue_invite::request(
-        &cred,
-        &reachcred,
-        &ba.lox_pub,
-        &ba.reachability_pub,
-        ba.today(),
-    )
-    .unwrap();
-    let resp = ba.handle_issue_invite(req).unwrap();
-    issue_invite::handle_response(state, resp, &ba.lox_pub, &ba.invitation_pub).unwrap()
+    assert!(th.ba.verify_lox(&cred4));
 }
 
 #[test]
 fn test_issue_invite() {
-    let (bdb, mut ba) = setup();
-    let cred1 = level0_migration(&bdb, &mut ba);
+    let mut th = TestHarness::new();
+
+    // Join an untrusted user
+    let cred = th.open_invite();
+
+    // Time passes
+    th.advance_days(47);
+
+    // Go up to level 1
+    let migcred = th.trust_promotion(&cred);
+    let cred1 = th.level0_migration(&cred, &migcred);
     assert!(scalar_u32(&cred1.trust_level).unwrap() == 1);
 
     // Time passes
-    ba.advance_days(20);
+    th.advance_days(20);
 
-    let cred2 = level_up(&mut ba, &cred1);
+    // Go up to level 2
+    let cred2 = th.level_up(&cred1);
     assert!(scalar_u32(&cred2.trust_level).unwrap() == 2);
     println!("cred2 = {:?}", cred2);
-    assert!(ba.verify_lox(&cred2));
+    assert!(th.ba.verify_lox(&cred2));
 
-    let (cred3, invite) = issue_invite(&mut ba, &cred2);
-    assert!(ba.verify_lox(&cred3));
-    assert!(ba.verify_invitation(&invite));
-    println!("cred3 = {:?}", cred3);
+    // Issue an invitation
+    let (cred2a, invite) = th.issue_invite(&cred2);
+    assert!(th.ba.verify_lox(&cred2a));
+    assert!(th.ba.verify_invitation(&invite));
+    println!("cred2a = {:?}", cred2a);
     println!("invite = {:?}", invite);
 }
 
-fn redeem_invite(ba: &mut BridgeAuth, inv: &cred::Invitation) -> cred::Lox {
-    let (req, state) = redeem_invite::request(&inv, &ba.invitation_pub, ba.today()).unwrap();
-    let resp = ba.handle_redeem_invite(req).unwrap();
-    redeem_invite::handle_response(state, resp, &ba.lox_pub).unwrap()
-}
-
 #[test]
 fn test_redeem_invite() {
-    let (bdb, mut ba) = setup();
-    let cred1 = level0_migration(&bdb, &mut ba);
+    let mut th = TestHarness::new();
+
+    // Join an untrusted user
+    let cred = th.open_invite();
+
+    // Time passes
+    th.advance_days(47);
+
+    // Go up to level 1
+    let migcred = th.trust_promotion(&cred);
+    let cred1 = th.level0_migration(&cred, &migcred);
     assert!(scalar_u32(&cred1.trust_level).unwrap() == 1);
 
     // Time passes
-    ba.advance_days(20);
+    th.advance_days(20);
 
-    let cred2 = level_up(&mut ba, &cred1);
+    // Go up to level 2
+    let cred2 = th.level_up(&cred1);
     assert!(scalar_u32(&cred2.trust_level).unwrap() == 2);
     println!("cred2 = {:?}", cred2);
-    assert!(ba.verify_lox(&cred2));
+    assert!(th.ba.verify_lox(&cred2));
 
-    let (cred3, invite) = issue_invite(&mut ba, &cred2);
-    println!("cred3 = {:?}", cred3);
-    println!("invite = {:?}", invite);
+    // Issue an invitation to Bob
+    let (cred2a, bob_invite) = th.issue_invite(&cred2);
+    assert!(th.ba.verify_lox(&cred2a));
+    assert!(th.ba.verify_invitation(&bob_invite));
+    println!("cred2a = {:?}", cred2a);
+    println!("bob_invite = {:?}", bob_invite);
 
     // Time passes
-    ba.advance_days(12);
+    th.advance_days(12);
 
-    let cred4 = redeem_invite(&mut ba, &invite);
-    assert!(ba.verify_lox(&cred4));
-    println!("cred4 = {:?}", cred4);
+    // Bob joins the system
+    let bob_cred = th.redeem_invite(&bob_invite);
+    assert!(th.ba.verify_lox(&bob_cred));
+    println!("bob_cred = {:?}", bob_cred);
 }