486 lines
16 KiB
Rust
486 lines
16 KiB
Rust
use std::fs::File;
|
|
use std::io::Read;
|
|
|
|
use rocket::http::{ContentType, Status};
|
|
use rocket::local::Client;
|
|
use rocket_contrib::json;
|
|
|
|
use super::rocket;
|
|
use crate::json_api::build_json_response;
|
|
|
|
// helper function to test correct retrieval and content of a file
|
|
fn test_query_file<T>(path: &str, file: T, status: Status)
|
|
where
|
|
T: Into<Option<&'static str>>,
|
|
{
|
|
let client = Client::new(rocket()).unwrap();
|
|
let mut response = client.get(path).dispatch();
|
|
assert_eq!(response.status(), status);
|
|
|
|
let body_data = response.body().and_then(|body| body.into_bytes());
|
|
if let Some(filename) = file.into() {
|
|
let expected_data = read_file_content(filename);
|
|
assert!(body_data.map_or(false, |s| s == expected_data));
|
|
}
|
|
}
|
|
|
|
// helper function to return the content of a file, given a path
|
|
fn read_file_content(path: &str) -> Vec<u8> {
|
|
let mut fp = File::open(&path).expect(&format!("Can't open {}", path));
|
|
let mut file_content = vec![];
|
|
|
|
fp.read_to_end(&mut file_content)
|
|
.expect(&format!("Reading {} failed.", path));
|
|
file_content
|
|
}
|
|
|
|
// WEB PAGE ROUTES
|
|
|
|
#[test]
|
|
fn index_html() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client.get("/").dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("/peers"));
|
|
assert!(body.contains("/profile"));
|
|
assert!(body.contains("/messages"));
|
|
assert!(body.contains("/device"));
|
|
assert!(body.contains("/help"));
|
|
assert!(body.contains("/network"));
|
|
}
|
|
|
|
#[test]
|
|
fn network_card_html() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client.get("/network").dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("MODE"));
|
|
assert!(body.contains("SSID"));
|
|
assert!(body.contains("IP"));
|
|
assert!(body.contains("Add WiFi Network"));
|
|
assert!(body.contains("Deploy Access Point"));
|
|
assert!(body.contains("List WiFi Networks"));
|
|
assert!(body.contains("SIGNAL"));
|
|
assert!(body.contains("DOWNLOAD"));
|
|
assert!(body.contains("UPLOAD"));
|
|
}
|
|
|
|
#[test]
|
|
fn network_list_html() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client.get("/network/wifi").dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("WiFi Networks"));
|
|
assert!(body.contains("No saved or available networks found."));
|
|
}
|
|
|
|
// TODO: needs further testing once template has been refactored
|
|
#[test]
|
|
fn network_detail_html() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let response = client.get("/network/wifi?ssid=Home").dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
//let body = response.body_string().unwrap();
|
|
//assert!(body.contains("Network not found"));
|
|
}
|
|
|
|
#[test]
|
|
fn network_add_html() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client.get("/network/wifi/add").dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Add WiFi Network"));
|
|
assert!(body.contains("SSID"));
|
|
assert!(body.contains("Password"));
|
|
assert!(body.contains("Add"));
|
|
assert!(body.contains("Cancel"));
|
|
}
|
|
|
|
#[test]
|
|
fn network_add_ssid_html() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client.get("/network/wifi/add?ssid=Home").dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Add WiFi Network"));
|
|
assert!(body.contains("Home"));
|
|
assert!(body.contains("Password"));
|
|
assert!(body.contains("Add"));
|
|
assert!(body.contains("Cancel"));
|
|
}
|
|
|
|
#[test]
|
|
fn device_html() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client.get("/device").dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Device Status"));
|
|
assert!(body.contains("Networking"));
|
|
assert!(body.contains("Display"));
|
|
assert!(body.contains("Statistics"));
|
|
}
|
|
|
|
#[test]
|
|
fn help_html() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client.get("/help").dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Help"));
|
|
}
|
|
|
|
#[test]
|
|
fn login_html() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client.get("/login").dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Login"));
|
|
}
|
|
|
|
#[test]
|
|
fn messages_html() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client.get("/messages").dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Private Messages"));
|
|
}
|
|
|
|
#[test]
|
|
fn peers_html() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client.get("/peers").dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Scuttlebutt Peers"));
|
|
}
|
|
|
|
#[test]
|
|
fn profile_html() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client.get("/profile").dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Profile"));
|
|
}
|
|
|
|
#[test]
|
|
fn shutdown_html() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client.get("/shutdown").dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Shutdown Device"));
|
|
}
|
|
|
|
#[test]
|
|
fn network_usage_html() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client.get("/network/wifi/usage").dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Network Data Usage"));
|
|
assert!(body.contains("WARNING THRESHOLD"));
|
|
assert!(body.contains("Update"));
|
|
assert!(body.contains("Cancel"));
|
|
}
|
|
|
|
#[test]
|
|
fn add_credentials() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let response = client
|
|
.post("/network/wifi/add")
|
|
.header(ContentType::Form)
|
|
.body("ssid=Home&pass=Password")
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::HTML));
|
|
}
|
|
|
|
#[test]
|
|
fn forget_wifi() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let response = client
|
|
.post("/network/wifi/forget")
|
|
.header(ContentType::Form)
|
|
.body("ssid=Home")
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::SeeOther);
|
|
assert_eq!(response.content_type(), None);
|
|
}
|
|
|
|
#[test]
|
|
fn modify_password() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let response = client
|
|
.post("/network/wifi/modify")
|
|
.header(ContentType::Form)
|
|
.body("ssid=Home&pass=Password")
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::SeeOther);
|
|
assert_eq!(response.content_type(), None);
|
|
}
|
|
|
|
#[test]
|
|
fn deploy_ap() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let response = client.get("/network/ap/activate").dispatch();
|
|
// check for 303 status (redirect)
|
|
assert_eq!(response.status(), Status::SeeOther);
|
|
assert_eq!(response.content_type(), None);
|
|
}
|
|
|
|
#[test]
|
|
fn deploy_client() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let response = client.get("/network/wifi/activate").dispatch();
|
|
// check for 303 status (redirect)
|
|
assert_eq!(response.status(), Status::SeeOther);
|
|
assert_eq!(response.content_type(), None);
|
|
}
|
|
|
|
// JSON API ROUTES
|
|
|
|
#[test]
|
|
fn activate_ap() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let response = client
|
|
.post("/api/v1/network/activate_ap")
|
|
.header(ContentType::JSON)
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::JSON));
|
|
}
|
|
|
|
#[test]
|
|
fn activate_client() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let response = client
|
|
.post("/api/v1/network/activate_client")
|
|
.header(ContentType::JSON)
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::JSON));
|
|
}
|
|
|
|
#[test]
|
|
fn return_ip() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client
|
|
.get("/api/v1/network/ip")
|
|
.header(ContentType::JSON)
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::JSON));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("wlan0"));
|
|
assert!(body.contains("ap0"));
|
|
}
|
|
|
|
#[test]
|
|
fn return_rssi() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client
|
|
.get("/api/v1/network/rssi")
|
|
.header(ContentType::JSON)
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::JSON));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Not currently connected to an access point."));
|
|
}
|
|
|
|
#[test]
|
|
fn return_ssid() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client
|
|
.get("/api/v1/network/ssid")
|
|
.header(ContentType::JSON)
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::JSON));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Not currently connected to an access point."));
|
|
}
|
|
|
|
#[test]
|
|
fn return_state() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client
|
|
.get("/api/v1/network/state")
|
|
.header(ContentType::JSON)
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::JSON));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("ap0"));
|
|
assert!(body.contains("wlan0"));
|
|
assert!(body.contains("unavailable"));
|
|
}
|
|
|
|
#[test]
|
|
fn return_status() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client
|
|
.get("/api/v1/network/status")
|
|
.header(ContentType::JSON)
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::JSON));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Not currently connected to an access point."));
|
|
}
|
|
|
|
#[test]
|
|
fn scan_networks() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client
|
|
.get("/api/v1/network/wifi")
|
|
.header(ContentType::JSON)
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::JSON));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Unable to scan for networks. Interface may be deactivated."));
|
|
}
|
|
|
|
#[test]
|
|
fn add_wifi() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client
|
|
.post("/api/v1/network/wifi")
|
|
.header(ContentType::JSON)
|
|
.body(r#"{ "ssid": "Home", "pass": "Password" }"#)
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::JSON));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Failed to add WiFi credentials."));
|
|
}
|
|
|
|
#[test]
|
|
fn remove_wifi() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client
|
|
.post("/api/v1/network/wifi/forget")
|
|
.header(ContentType::JSON)
|
|
.body(r#"{ "ssid": "Home" }"#)
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::JSON));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Failed to remove WiFi network credentials."));
|
|
}
|
|
|
|
#[test]
|
|
fn new_password() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client
|
|
.post("/api/v1/network/wifi/modify")
|
|
.header(ContentType::JSON)
|
|
.body(r#"{ "ssid": "Home", "pass": "Password" }"#)
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::JSON));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("Failed to update WiFi password."));
|
|
}
|
|
|
|
#[test]
|
|
fn ping_pong() {
|
|
let client = Client::new(rocket()).expect("valid rocket instance");
|
|
let mut response = client
|
|
.get("/api/v1/ping")
|
|
.header(ContentType::JSON)
|
|
.dispatch();
|
|
assert_eq!(response.status(), Status::Ok);
|
|
assert_eq!(response.content_type(), Some(ContentType::JSON));
|
|
let body = response.body_string().unwrap();
|
|
assert!(body.contains("pong!"));
|
|
}
|
|
|
|
// HELPER FUNCTION TESTS
|
|
|
|
#[test]
|
|
fn test_build_json_response() {
|
|
let status = "success".to_string();
|
|
let data = json!("WiFi credentials added.".to_string());
|
|
let json = build_json_response(status, Some(data), None);
|
|
assert_eq!(json.status, "success");
|
|
assert_eq!(json.data, Some(json!("WiFi credentials added.")));
|
|
assert_eq!(json.msg, None);
|
|
}
|
|
|
|
// FILE TESTS
|
|
|
|
#[test]
|
|
fn nested_file() {
|
|
test_query_file(
|
|
"/images/placeholder.txt",
|
|
"static/images/placeholder.txt",
|
|
Status::Ok,
|
|
);
|
|
test_query_file(
|
|
"/images/placeholder.txt?v=1",
|
|
"static/images/placeholder.txt",
|
|
Status::Ok,
|
|
);
|
|
test_query_file(
|
|
"/images/placeholder.txt?v=1&a=b",
|
|
"static/images/placeholder.txt",
|
|
Status::Ok,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn icon_file() {
|
|
test_query_file(
|
|
"/icons/peach-icon.png",
|
|
"static/icons/peach-icon.png",
|
|
Status::Ok,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_path() {
|
|
test_query_file("/thou_shalt_not_exist", None, Status::NotFound);
|
|
test_query_file("/thou_shalt_not_exist", None, Status::NotFound);
|
|
test_query_file("/thou/shalt/not/exist?a=b&c=d", None, Status::NotFound);
|
|
}
|
|
|
|
#[test]
|
|
fn invalid_get_request() {
|
|
let client = Client::new(rocket()).unwrap();
|
|
|
|
// try to get a path that doesn't exist
|
|
let mut res = client
|
|
.get("/message/99")
|
|
.header(ContentType::JSON)
|
|
.dispatch();
|
|
assert_eq!(res.status(), Status::NotFound);
|
|
|
|
let body = res.body_string().unwrap();
|
|
assert!(body.contains("404: Page Not Found"));
|
|
assert!(body.contains("No PeachCloud resource exists for this URL."));
|
|
}
|