diff --git a/crates/lox-distributor/src/request_handler.rs b/crates/lox-distributor/src/request_handler.rs index 5cffe12..e486eff 100644 --- a/crates/lox-distributor/src/request_handler.rs +++ b/crates/lox-distributor/src/request_handler.rs @@ -322,20 +322,22 @@ mod tests { } #[tokio::test] - async fn test_handle() { - let mut th = TestHarness::new(); - let lc = LoxClientMock {}; - + async fn test_handle_not_found(){ + let th = TestHarness::new(); // Test Random page let four_oh_four_req = Request::builder() - .header("Content-Type", "application/json") - .method("POST") - .uri("http://localhost/givemecreds") - .body(Body::empty()) - .unwrap(); + .header("Content-Type", "application/json") + .method("POST") + .uri("http://localhost/givemecreds") + .body(Body::empty()) + .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, - ) { - Ok(lox_cred) => lox_cred, - Err(e) => panic!("Error: Lox credential error {:?}", e.to_string()), - }; + ).unwrap(); 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,