vecna
/
lox
mirror of https://gitlab.torproject.org/vecna/lox.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Separate out tests to improve readability

This commit is contained in:
onyinyang 2023-06-16 11:59:33 -04:00
parent 9c959486be
commit 84d7691ab8
No known key found for this signature in database
GPG Key ID: 156A6435430C2036
1 changed files with 63 additions and 30 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

93
crates/lox-distributor/src/request_handler.rs
View File

@ -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,