vecna
/
lox-simulation
mirror of https://git-crysp.uwaterloo.ca/vvecna/lox-simulation.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Add tests for direct_scan_server

This commit is contained in:
Vecna 2025-05-23 17:20:58 -04:00
parent 76cd49208b
commit d4f6380d77
1 changed files with 210 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

210
src/direct_scan_server.rs
View File

@ -175,3 +175,213 @@ fn prepare_header(response: String) -> Response<Body> {
.insert("Access-Control-Allow-Origin", HeaderValue::from_static("*")); .insert("Access-Control-Allow-Origin", HeaderValue::from_static("*"));
resp resp
} }
#[tokio::test]
async fn test_direct_scan_server() {
use lox_cli::networking::*;
// Start web server
spawn(async move {
server().await;
});
// Give server time to start
sleep(Duration::new(1, 0)).await;
let scan_net = HyperNet {
hostname: "http://localhost:8006".to_string(),
};
// Initially there should be no guessed bridges
let guessed_bridges_resp = scan_net
.request("/get_guessed_bridges".to_string(), vec![])
.await
.unwrap();
let guessed_bridges: HashMap<String, HashSet<String>> =
serde_json::from_slice(&guessed_bridges_resp).unwrap();
assert!(guessed_bridges.is_empty());
// Let's guess a bridge
let mut guesses = HashMap::<String, HashSet<String>>::new();
let mut guess_0 = HashSet::<String>::new();
guess_0.insert("ru".to_string());
guesses.insert(
"0000000000000000000000000000000000000000".to_string(),
guess_0,
);
let verify_bridges_resp = scan_net
.request(
"/verify_blocked_bridges".to_string(),
serde_json::to_string(&guesses).unwrap().into(),
)
.await
.unwrap();
let correct_guesses: HashMap<String, HashSet<String>> =
serde_json::from_slice(&verify_bridges_resp).unwrap();
assert!(correct_guesses.is_empty());
// We should have a new guessed bridge now
let guessed_bridges_resp = scan_net
.request("/get_guessed_bridges".to_string(), vec![])
.await
.unwrap();
let guessed_bridges: HashMap<String, HashSet<String>> =
serde_json::from_slice(&guessed_bridges_resp).unwrap();
assert!(guessed_bridges.len() == 1);
assert!(guessed_bridges.contains_key("0000000000000000000000000000000000000000"));
assert!(!guessed_bridges.contains_key("1111111111111111111111111111111111111111"));
// Reset the guessed bridges (new day)
let _ = scan_net
.request("/reset_guessed_bridges".to_string(), vec![])
.await
.unwrap();
// We should have no guessed bridges
let guessed_bridges_resp = scan_net
.request("/get_guessed_bridges".to_string(), vec![])
.await
.unwrap();
let guessed_bridges: HashMap<String, HashSet<String>> =
serde_json::from_slice(&guessed_bridges_resp).unwrap();
assert!(guessed_bridges.is_empty());
// Add two blocked bridges
let mut blocked_bridges = HashSet::<String>::new();
blocked_bridges.insert("0000000000000000000000000000000000000000".to_string());
blocked_bridges.insert("1111111111111111111111111111111111111111".to_string());
let _ = scan_net
.request(
"/add_blocked_bridges".to_string(),
serde_json::to_string(&blocked_bridges).unwrap().into(),
)
.await
.unwrap();
// Guess one of the bridges
let mut guesses = HashMap::<String, HashSet<String>>::new();
let mut guess_1 = HashSet::<String>::new();
guess_1.insert("ru".to_string());
guesses.insert(
"1111111111111111111111111111111111111111".to_string(),
guess_1,
);
let verify_bridges_resp = scan_net
.request(
"/verify_blocked_bridges".to_string(),
serde_json::to_string(&guesses).unwrap().into(),
)
.await
.unwrap();
let correct_guesses: HashMap<String, HashSet<String>> =
serde_json::from_slice(&verify_bridges_resp).unwrap();
assert!(correct_guesses.len() == 1);
assert!(!correct_guesses.contains_key("0000000000000000000000000000000000000000"));
assert!(correct_guesses.contains_key("1111111111111111111111111111111111111111"));
// We should have one guessed bridge
let guessed_bridges_resp = scan_net
.request("/get_guessed_bridges".to_string(), vec![])
.await
.unwrap();
let guessed_bridges: HashMap<String, HashSet<String>> =
serde_json::from_slice(&guessed_bridges_resp).unwrap();
assert!(guessed_bridges.len() == 1);
assert!(!guessed_bridges.contains_key("0000000000000000000000000000000000000000"));
assert!(guessed_bridges.contains_key("1111111111111111111111111111111111111111"));
// Guess both bridges
let mut guesses = HashMap::<String, HashSet<String>>::new();
let mut guess_0 = HashSet::<String>::new();
guess_0.insert("ru".to_string());
guesses.insert(
"0000000000000000000000000000000000000000".to_string(),
guess_0,
);
let mut guess_1 = HashSet::<String>::new();
guess_1.insert("ru".to_string());
guesses.insert(
"1111111111111111111111111111111111111111".to_string(),
guess_1,
);
let verify_bridges_resp = scan_net
.request(
"/verify_blocked_bridges".to_string(),
serde_json::to_string(&guesses).unwrap().into(),
)
.await
.unwrap();
let correct_guesses: HashMap<String, HashSet<String>> =
serde_json::from_slice(&verify_bridges_resp).unwrap();
assert!(correct_guesses.len() == 2);
assert!(correct_guesses.contains_key("0000000000000000000000000000000000000000"));
assert!(correct_guesses.contains_key("1111111111111111111111111111111111111111"));
// We should have two guessed bridges
let guessed_bridges_resp = scan_net
.request("/get_guessed_bridges".to_string(), vec![])
.await
.unwrap();
let guessed_bridges: HashMap<String, HashSet<String>> =
serde_json::from_slice(&guessed_bridges_resp).unwrap();
assert!(guessed_bridges.len() == 2);
assert!(guessed_bridges.contains_key("0000000000000000000000000000000000000000"));
assert!(guessed_bridges.contains_key("1111111111111111111111111111111111111111"));
// Try guessing a third bridge
let mut guesses = HashMap::<String, HashSet<String>>::new();
let mut guess_0 = HashSet::<String>::new();
guess_0.insert("ru".to_string());
guesses.insert(
"0000000000000000000000000000000000000000".to_string(),
guess_0,
);
let mut guess_2 = HashSet::<String>::new();
guess_2.insert("ru".to_string());
guesses.insert(
"2222222222222222222222222222222222222222".to_string(),
guess_2,
);
let verify_bridges_resp = scan_net
.request(
"/verify_blocked_bridges".to_string(),
serde_json::to_string(&guesses).unwrap().into(),
)
.await
.unwrap();
let correct_guesses: HashMap<String, HashSet<String>> =
serde_json::from_slice(&verify_bridges_resp).unwrap();
assert!(correct_guesses.len() == 1);
assert!(correct_guesses.contains_key("0000000000000000000000000000000000000000"));
assert!(!correct_guesses.contains_key("1111111111111111111111111111111111111111"));
assert!(!correct_guesses.contains_key("2222222222222222222222222222222222222222"));
// We should have three guessed bridges
let guessed_bridges_resp = scan_net
.request("/get_guessed_bridges".to_string(), vec![])
.await
.unwrap();
let guessed_bridges: HashMap<String, HashSet<String>> =
serde_json::from_slice(&guessed_bridges_resp).unwrap();
assert!(guessed_bridges.len() == 2);
assert!(guessed_bridges.contains_key("0000000000000000000000000000000000000000"));
assert!(!guessed_bridges.contains_key("1111111111111111111111111111111111111111"));
assert!(guessed_bridges.contains_key("2222222222222222222222222222222222222222"));
// Reset guesses again
let _ = scan_net
.request("/reset_guessed_bridges".to_string(), vec![])
.await
.unwrap();
// We should have no guessed bridges
let guessed_bridges_resp = scan_net
.request("/get_guessed_bridges".to_string(), vec![])
.await
.unwrap();
let guessed_bridges: HashMap<String, HashSet<String>> =
serde_json::from_slice(&guessed_bridges_resp).unwrap();
assert!(guessed_bridges.is_empty());
assert!(!guessed_bridges.contains_key("0000000000000000000000000000000000000000"));
assert!(!guessed_bridges.contains_key("1111111111111111111111111111111111111111"));
}