Separate out tests to improve readability

crates/lox-distributor/src/request_handler.rs

@@ -322,10 +322,8 @@ mod tests {
     }
 
     #[tokio::test]
-    async fn test_handle() {
+    async fn test_handle_not_found(){
-        let mut th = TestHarness::new();
+        let th = TestHarness::new();
-        let lc = LoxClientMock {};
-
         // Test Random page
         let four_oh_four_req = Request::builder()
                 .header("Content-Type", "application/json")
@@ -335,7 +333,11 @@ mod tests {
                 .unwrap();
         let not_found_response = handle(th.context.clone(), four_oh_four_req).await.unwrap();
         assert_eq!(not_found_response.status(), StatusCode::NOT_FOUND);
+    }
 
+    #[tokio::test]
+    async fn test_handle_bad_request(){
+        let th = TestHarness::new();
         // Test that empty request to a credential issuing endpoint fails
         let req = Request::builder()
             .method("POST")
@@ -344,27 +346,52 @@ mod tests {
             .unwrap();
         let not_found_response = handle(th.context.clone(), req).await.unwrap();
         assert_eq!(not_found_response.status(), StatusCode::BAD_REQUEST);
+    }
+
+    #[tokio::test]
+    async fn test_handle_invite(){
+        let th = TestHarness::new();
+        let lc = LoxClientMock {};
 
         // Test Invite
         let invite_request = lc.invite();
         let invite_response = handle(th.context.clone(), invite_request).await.unwrap();
         assert_eq!(invite_response.status(), StatusCode::OK);
+    }
 
+    #[tokio::test]
+    async fn test_handle_reachability(){
+        let th = TestHarness::new();
+        let lc = LoxClientMock {};
         // Test Reachability
         let reachability_request = lc.reachability();
         let reachability_response = handle(th.context.clone(), reachability_request)
             .await
             .unwrap();
         assert_eq!(reachability_response.status(), StatusCode::OK);
+    }
 
+    #[tokio::test]
+    async fn test_handle_pubkeys(){
+        let th = TestHarness::new();
+        let lc = LoxClientMock {};
         // Test Pubkeys
         let pubkey_request = lc.pubkeys();
         let pubkey_response = handle(th.context.clone(), pubkey_request).await.unwrap();
         assert_eq!(pubkey_response.status(), StatusCode::OK);
-        let pubkeys = body_to_string(pubkey_response).await;
+    }
-        let pubkeys_obj: lox_utils::PubKeys = serde_json::from_str(&pubkeys).unwrap();
 
-        // Test Open Invite
+    #[tokio::test]
+    async fn test_handle_lox_protocols(){
+        let mut th = TestHarness::new();
+        let lc = LoxClientMock {};
+        // Request Invite and pubkeys required for protocol tests
+
+        // Get Open Invitation
+        let invite_request = lc.invite();
+        let invite_response = handle(th.context.clone(), invite_request).await.unwrap();
+
+        // Test Open Invite and get response
         let invite_response_str = body_to_string(invite_response).await;
         let response_data: lox_utils::Invite = serde_json::from_str(&invite_response_str).unwrap();
         let token = match lox_utils::validate(&response_data.invite) {
@@ -375,23 +402,27 @@ mod tests {
         let open_request = lc.openinvite(request);
         let open_response = handle(th.context.clone(), open_request).await.unwrap();
         assert_eq!(open_response.status(), StatusCode::OK);
-
-        // Test Trust Promotion
         let open_resp = body_to_string(open_response).await;
         let open_response_obj = serde_json::from_str(&open_resp).unwrap();
-        let lox_cred = match lox::proto::open_invite::handle_response(
+
+        // Get pubkeys
+        let pubkey_request = lc.pubkeys();
+        let pubkey_response = handle(th.context.clone(), pubkey_request).await.unwrap();
+        let pubkeys = body_to_string(pubkey_response).await;
+        let pubkeys_obj: lox_utils::PubKeys = serde_json::from_str(&pubkeys).unwrap();
+
+         // Test Trust Promotion and get response
+        let lox_cred = lox::proto::open_invite::handle_response(
             state,
             open_response_obj,
             &pubkeys_obj.lox_pub,
-        ) {
+        ).unwrap();
-            Ok(lox_cred) => lox_cred,
-            Err(e) => panic!("Error: Lox credential error {:?}", e.to_string()),
-        };
         let lox_cred: lox_utils::LoxCredential = lox_utils::LoxCredential {
             lox_credential: lox_cred.0,
             bridgeline: Some(lox_cred.1),
             invitation: None,
         };
+
         // Advance the context to a day after the credential becomes eligible to upgrade
         th.advance_days(31);
         let trust_result = match proto::trust_promotion::request(
@@ -410,10 +441,10 @@ mod tests {
             .await
             .unwrap();
         assert_eq!(trustpromo_response.status(), StatusCode::OK);
-
-        // Test Trust Migration
         let trustpromo_resp = body_to_string(trustpromo_response).await;
         let trustpromo_response_obj = serde_json::from_str(&trustpromo_resp).unwrap();
+
+        // Test Trust Migration and get response
         let mig_cred = match lox::proto::trust_promotion::handle_response(
             trust_result.1,
             trustpromo_response_obj,
@@ -436,10 +467,10 @@ mod tests {
         let trustmig_request = lc.trustmigration(migration_result.0);
         let trustmig_response = handle(th.context.clone(), trustmig_request).await.unwrap();
         assert_eq!(trustmig_response.status(), StatusCode::OK);
-
-        // Test Level up
         let trustmig_resp = body_to_string(trustmig_response).await;
         let trustmig_response_obj = serde_json::from_str(&trustmig_resp).unwrap();
+
+        // Test Level up and get response
         let level_one_cred = match lox::proto::migration::handle_response(
             migration_result.1,
             trustmig_response_obj,
@@ -469,8 +500,6 @@ mod tests {
         let level_up_request = lc.levelup(level_up_result.0);
         let level_up_response = handle(th.context.clone(), level_up_request).await.unwrap();
         assert_eq!(level_up_response.status(), StatusCode::OK);
-
-        // Test Issue Invite
         let levelup_resp = body_to_string(level_up_response).await;
         let levelup_response_obj = serde_json::from_str(&levelup_resp).unwrap();
         let level_two_cred = match lox::proto::level_up::handle_response(
@@ -481,6 +510,8 @@ mod tests {
             Ok(level_two_cred) => level_two_cred,
             Err(e) => panic!("Error: Level two credential error {:?}", e.to_string()),
         };
+
+        // Test Issue Invite and get response
         let new_reachability_request = lc.reachability();
         let new_reachability_response = handle(th.context.clone(), new_reachability_request)
             .await
@@ -507,8 +538,6 @@ mod tests {
             .await
             .unwrap();
         assert_eq!(issue_invite_response.status(), StatusCode::OK);
-
-        // Test Redeem Invite
         let invite_resp = body_to_string(issue_invite_response).await;
         let invite_response_obj = serde_json::from_str(&invite_resp).unwrap();
         let issue_invite_cred = match lox::proto::issue_invite::handle_response(
@@ -520,6 +549,8 @@ mod tests {
             Ok(issue_invite_cred) => issue_invite_cred,
             Err(e) => panic!("Error: Issue invite credential error {:?}", e.to_string()),
         };
+
+        // Test Redeem Invite
         let new_invite = match proto::redeem_invite::request(
             &issue_invite_cred.1,
             &pubkeys_obj.invitation_pub,
@@ -548,7 +579,7 @@ mod tests {
             ),
         };
 
-        //Test Check Blockage
+        // Prepare for check blockage request
         th.advance_days(28); // First advance most recent credential to level 3
         let new_reachability_request = lc.reachability();
         let new_reachability_response = handle(th.context.clone(), new_reachability_request)
@@ -585,6 +616,7 @@ mod tests {
         th.advance_days(1);
         th.prep_next_day(passed_level_three_cred.1, passed_level_three_cred.2);
 
+        //Test Check Blockage and get response
         let migration_cred_request = match proto::check_blockage::request(
             &passed_level_three_cred.0,
             &pubkeys_obj.lox_pub,
@@ -597,8 +629,6 @@ mod tests {
             .await
             .unwrap();
         assert_eq!(migration_cred_response.status(), StatusCode::OK);
-
-        // Test Blockage Migration
         let migration_resp = body_to_string(migration_cred_response).await;
         let migration_response_obj = serde_json::from_str(&migration_resp).unwrap();
         let mig_cred = match lox::proto::check_blockage::handle_response(
@@ -608,6 +638,9 @@ mod tests {
             Ok(mig_cred) => mig_cred,
             Err(e) => panic!("Error: Migration token error {:?}", e.to_string()),
         };
+
+        // Test Blockage Migration
+
         let migration_result = match proto::blockage_migration::request(
             &passed_level_three_cred.0,
             &mig_cred,