use std::sync::{Arc, PoisonError, RwLock, Weak};
use std::time::{Duration, SystemTime};
use reqwest::header::{
ACCEPT, CONTENT_TYPE, COOKIE, HeaderMap, HeaderName, LOCATION, RETRY_AFTER, USER_AGENT,
};
use reqwest::redirect::Policy;
use reqwest::{Client, Method, StatusCode};
use secrecy::SecretString;
use serde_json::Value;
use tokio::sync::watch;
use url::Url;
use crate::auth::Session;
use crate::consts;
use crate::envelope::Envelope;
use crate::error::Error;
use crate::errors;
use crate::redact;
use crate::routes::{self, ApiVersion, Nested, Resource};
use crate::storage::CredentialStore;
#[derive(Debug, Clone)]
pub enum RequestBody {
None,
Json(Value),
Form(Vec<(String, String)>),
EmptyJsonString,
}
#[derive(Debug)]
pub struct Transport {
http: Client,
api_host: Url,
session: RwLock<Option<Session>>,
store: Option<Arc<dyn CredentialStore>>,
storage_failures: StorageFailures,
user_agent: String,
accept_language: String,
send_legacy_cookie: bool,
get_retries: u32,
refresh_slot: tokio::sync::Mutex<Weak<watch::Sender<Option<bool>>>>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum StorageFailures {
#[default]
Warn,
Fatal,
}
impl Transport {
#[must_use]
pub fn builder() -> TransportBuilder {
TransportBuilder::default()
}
#[must_use]
pub fn api_host(&self) -> &Url {
&self.api_host
}
#[must_use]
pub fn session(&self) -> Option<Session> {
self.session_snapshot()
}
pub fn set_session(&self, session: Option<Session>) -> Result<(), Error> {
if let Some(ref s) = session {
crate::auth::session::validate_token_shape("token", s.expose_token())?;
}
let Some(store) = &self.store else {
self.replace_session(session);
return Ok(());
};
let for_store = session.clone();
self.replace_session(session);
let result = match &for_store {
Some(s) => store.save(s),
None => store.clear(),
};
match result {
Ok(()) => Ok(()),
Err(err) => match self.storage_failures {
StorageFailures::Warn => {
tracing::warn!(error = %err, "failed to persist session to credential store");
Ok(())
}
StorageFailures::Fatal => Err(err.into()),
},
}
}
#[must_use]
pub fn is_authenticated(&self) -> bool {
self.session_snapshot()
.is_some_and(|session| session.is_valid())
}
#[must_use]
pub(crate) fn storage_failures(&self) -> StorageFailures {
self.storage_failures
}
pub async fn request(
&self,
method: Method,
url: Url,
query: &[(&str, String)],
body: RequestBody,
) -> Result<Envelope, Error> {
let token = self.current_token().ok_or_else(not_authenticated)?;
let exchange = self
.execute_with_get_retry(method.clone(), &url, query, &body, Some(&token))
.await?;
if exchange.status.as_u16() == 401 && refresh_signal_detected(&exchange.body) {
let refreshed = self.refresh_session().await?;
if refreshed {
let retry_token = self.current_token().ok_or_else(not_authenticated)?;
let retry = self
.execute_with_get_retry(method, &url, query, &body, Some(&retry_token))
.await?;
return status_to_envelope(
retry.status,
&retry.body,
&retry.url,
retry.retry_after,
);
}
}
status_to_envelope(
exchange.status,
&exchange.body,
&exchange.url,
exchange.retry_after,
)
}
pub async fn resource(
&self,
route: &Resource,
id_or_url: &str,
parent: Option<&Value>,
query: &[(&str, String)],
body: RequestBody,
) -> Result<Envelope, Error> {
let url = route.resolve(self.api_host(), id_or_url, parent)?;
self.request(route.method.clone(), url, query, body).await
}
pub async fn nested(
&self,
route: &Nested,
network: &str,
child: &str,
parent: Option<&Value>,
query: &[(&str, String)],
body: RequestBody,
) -> Result<Envelope, Error> {
let url = route.resolve(self.api_host(), network, child, parent)?;
self.request(route.method.clone(), url, query, body).await
}
pub(crate) async fn request_with_token(
&self,
method: Method,
url: Url,
query: &[(&str, String)],
body: RequestBody,
token: Option<&SecretString>,
) -> Result<Envelope, Error> {
let exchange = self
.execute_with_get_retry(method, &url, query, &body, token)
.await?;
status_to_envelope(
exchange.status,
&exchange.body,
&exchange.url,
exchange.retry_after,
)
}
pub async fn refresh_session(&self) -> Result<bool, Error> {
enum Role {
Leader(Arc<watch::Sender<Option<bool>>>),
Waiter(watch::Receiver<Option<bool>>),
}
let role = {
let mut guard = self.refresh_slot.lock().await;
if let Some(sender) = guard.upgrade() {
let rx = sender.subscribe();
Role::Waiter(rx)
} else {
let (tx, _rx) = watch::channel(None);
let tx = Arc::new(tx);
*guard = Arc::downgrade(&tx);
Role::Leader(tx)
}
};
match role {
Role::Leader(tx) => {
let result = self.do_refresh().await;
let broadcast = match &result {
Ok(refreshed) => Some(*refreshed),
Err(_) => Some(false),
};
let _ = tx.send(broadcast);
result
}
Role::Waiter(mut rx) => {
let wait = async {
loop {
if let Some(value) = *rx.borrow_and_update() {
return value;
}
if rx.changed().await.is_err() {
return false;
}
}
};
match tokio::time::timeout(consts::SESSION_REFRESH_GUARD_TIMEOUT, wait).await {
Ok(value) => Ok(value),
Err(_elapsed) => Ok(false),
}
}
}
}
async fn do_refresh(&self) -> Result<bool, Error> {
let session = self.session_snapshot();
let Some(token) = session.filter(Session::is_valid).map(|s| s.token().clone()) else {
return Err(Error::authentication(
"No session token available. Login first.",
));
};
let url = routes::LOGIN_REFRESH.resolve(self.api_host(), "", None)?;
match self
.request_with_token(
Method::POST,
url,
&[],
RequestBody::EmptyJsonString,
Some(&token),
)
.await
{
Ok(_envelope) => {
tracing::debug!("Session refreshed; server-issued token ignored per SDK policy");
Ok(true)
}
Err(Error::Authentication { error_code, .. }) => {
let group = errors::classify_error_code(error_code.as_deref());
let retain = matches!(
group,
Some(errors::ErrorGroup::Verification | errors::ErrorGroup::SessionRefresh)
);
if !retain {
self.set_session(None)?;
}
Ok(false)
}
Err(err @ (Error::Network(_) | Error::Timeout)) => Err(err),
Err(_other) => Ok(false),
}
}
fn session_snapshot(&self) -> Option<Session> {
self.session
.read()
.unwrap_or_else(PoisonError::into_inner)
.clone()
}
fn current_token(&self) -> Option<SecretString> {
self.session_snapshot()
.filter(Session::is_valid)
.map(|session| session.token().clone())
}
fn replace_session(&self, session: Option<Session>) {
let mut guard = self.session.write().unwrap_or_else(PoisonError::into_inner);
*guard = session;
}
fn matches_configured_host(&self, url: &Url) -> bool {
let scheme_matches = url.scheme().eq_ignore_ascii_case(self.api_host.scheme());
let host_matches = matches!(
(url.host_str(), self.api_host.host_str()),
(Some(a), Some(b)) if a.eq_ignore_ascii_case(b)
);
let port_matches = url.port_or_known_default() == self.api_host.port_or_known_default();
scheme_matches && host_matches && port_matches
}
fn apply_credentials(
&self,
mut request: reqwest::RequestBuilder,
url: &Url,
token: Option<&SecretString>,
) -> reqwest::RequestBuilder {
let Some(token) = token else {
return request;
};
if !self.matches_configured_host(url) {
let scheme_matches = url.scheme().eq_ignore_ascii_case(self.api_host.scheme());
let host_matches = matches!(
(url.host_str(), self.api_host.host_str()),
(Some(a), Some(b)) if a.eq_ignore_ascii_case(b)
);
let reason = if host_matches && !scheme_matches {
"non-matching scheme"
} else {
"foreign host"
};
tracing::warn!(
reason,
scheme = url.scheme(),
host = url.host_str().unwrap_or(""),
"Session header withheld from a request to a {reason}: {}://{}",
url.scheme(),
url.host_str().unwrap_or("")
);
return request;
}
let token_str = Session::expose_secret_token(token);
request = request.header(user_token_header(), token_str);
if self.send_legacy_cookie {
request = request.header(
COOKIE,
format!("{}={}", consts::SESSION_COOKIE_NAME, token_str),
);
}
request
}
fn apply_body(request: reqwest::RequestBuilder, body: &RequestBody) -> reqwest::RequestBuilder {
match body {
RequestBody::None => request,
RequestBody::Json(value) => request.json(value),
RequestBody::Form(pairs) => {
let mut serializer = url::form_urlencoded::Serializer::new(String::new());
for (key, value) in pairs {
serializer.append_pair(key, value);
}
request
.header(CONTENT_TYPE, "application/x-www-form-urlencoded")
.body(serializer.finish())
}
RequestBody::EmptyJsonString => request
.header(CONTENT_TYPE, "application/json")
.body("\"\""),
}
}
async fn execute_with_get_retry(
&self,
method: Method,
url: &Url,
query: &[(&str, String)],
body: &RequestBody,
token: Option<&SecretString>,
) -> Result<RawExchange, Error> {
let mut attempt: u32 = 0;
loop {
let outcome = self
.execute_once(method.clone(), url.clone(), query, body, token)
.await;
let is_get = method == Method::GET;
let retryable = is_get
&& attempt < self.get_retries
&& match &outcome {
Ok(exchange) => exchange.status.as_u16() >= 500,
Err(Error::Network(_) | Error::Timeout) => true,
Err(_) => false,
};
if !retryable {
return outcome;
}
attempt += 1;
tracing::warn!(
attempt,
method = %method,
path = url.path(),
"retrying GET request"
);
tokio::time::sleep(consts::GET_RETRY_DELAY).await;
}
}
async fn execute_once(
&self,
method: Method,
url: Url,
query: &[(&str, String)],
body: &RequestBody,
token: Option<&SecretString>,
) -> Result<RawExchange, Error> {
let mut url = url;
if !query.is_empty() {
url.query_pairs_mut().extend_pairs(query);
}
let mut request = self.http.request(method.clone(), url.clone());
request = request.header(ACCEPT, "application/json");
request = request.header(USER_AGENT, &self.user_agent);
request = request.header(x_accept_language_header(), &self.accept_language);
request = self.apply_credentials(request, &url, token);
request = Self::apply_body(request, body);
let response = request.send().await.map_err(map_reqwest_error)?;
let status = response.status();
tracing::debug!(
method = %method,
path = url.path(),
status = status.as_u16(),
"eero transport request"
);
if response.url() != &url {
return Err(Error::Api {
status: status.as_u16(),
message: format!("Redirect followed unexpectedly: {status} at {}", url.path()),
envelope: None,
error_code: None,
url: Some(url.to_string()),
});
}
if status.is_redirection() {
let location_url = response
.headers()
.get(LOCATION)
.and_then(|value| value.to_str().ok())
.filter(|value| !value.is_empty())
.and_then(|value| Url::parse(value).ok().or_else(|| url.join(value).ok()));
let message = location_url.map_or_else(
|| {
format!(
"Redirect not followed: {} at {} (no Location header)",
status.as_u16(),
url.path()
)
},
|loc| {
format!(
"Redirect not followed: {} at {} -> {}",
status.as_u16(),
url.path(),
loc.host_str().unwrap_or("unknown host")
)
},
);
return Err(Error::Api {
status: status.as_u16(),
message,
envelope: None,
error_code: None,
url: Some(url.to_string()),
});
}
let retry_after = parse_retry_after(response.headers());
let body_text = read_capped_body(response).await?;
Ok(RawExchange {
status,
body: body_text,
retry_after,
url,
})
}
}
fn user_token_header() -> HeaderName {
HeaderName::from_static("x-user-token")
}
fn x_accept_language_header() -> HeaderName {
HeaderName::from_static("x-accept-language")
}
struct RawExchange {
status: StatusCode,
body: String,
retry_after: Option<Duration>,
url: Url,
}
fn not_authenticated() -> Error {
Error::authentication("Not authenticated")
}
fn status_to_envelope(
status: StatusCode,
body: &str,
url: &Url,
retry_after: Option<Duration>,
) -> Result<Envelope, Error> {
let code = status.as_u16();
if (200..300).contains(&code) {
if status == StatusCode::NO_CONTENT || body.trim().is_empty() {
return Ok(Envelope::empty());
}
return serde_json::from_str::<Value>(body)
.map(Envelope::from_value)
.map_err(|_| Error::Api {
status: code,
message: format!("Invalid JSON response ({} bytes)", body.len()),
envelope: None,
error_code: None,
url: Some(url.to_string()),
});
}
let envelope = errors::parse_envelope(body);
let error_code = envelope.as_ref().and_then(errors::error_code_from_envelope);
let redacted_envelope = envelope
.as_ref()
.map(|value| redact::redact_sensitive(value).to_string());
tracing::debug!(
status = code,
envelope = ?redacted_envelope,
"eero transport error response"
);
let mut err = errors::error_for_response(code, envelope, error_code, retry_after);
if let Error::Api { url: err_url, .. } = &mut err {
*err_url = Some(url.to_string());
}
Err(err)
}
async fn read_capped_body(mut response: reqwest::Response) -> Result<String, Error> {
let status = response.status();
let mut buffer: Vec<u8> = Vec::new();
while let Some(chunk) = response.chunk().await.map_err(map_reqwest_error)? {
if buffer.len() + chunk.len() > consts::MAX_RESPONSE_BYTES {
return Err(Error::Api {
status: status.as_u16(),
message: format!(
"Response body exceeded max size of {} bytes",
consts::MAX_RESPONSE_BYTES
),
envelope: None,
error_code: None,
url: Some(response.url().to_string()),
});
}
buffer.extend_from_slice(&chunk);
}
String::from_utf8(buffer).map_err(|err| Error::Api {
status: status.as_u16(),
message: format!("Response body is not valid UTF-8: {err}"),
envelope: None,
error_code: None,
url: Some(response.url().to_string()),
})
}
fn parse_retry_after(headers: &HeaderMap) -> Option<Duration> {
let raw = headers.get(RETRY_AFTER)?.to_str().ok()?.trim().to_owned();
if let Ok(seconds) = raw.parse::<u64>() {
return Some(Duration::from_secs(seconds));
}
let naive = jiff::civil::DateTime::strptime("%a, %d %b %Y %H:%M:%S GMT", &raw).ok()?;
let zoned = naive.to_zoned(jiff::tz::TimeZone::UTC).ok()?;
let target = SystemTime::from(zoned);
Some(
target
.duration_since(SystemTime::now())
.unwrap_or(Duration::ZERO),
)
}
fn refresh_signal_detected(body: &str) -> bool {
let Some(envelope) = errors::parse_envelope(body) else {
return false;
};
let error_code = errors::error_code_from_envelope(&envelope);
errors::classify_error_code(error_code.as_deref()) == Some(errors::ErrorGroup::SessionRefresh)
}
fn map_reqwest_error(err: reqwest::Error) -> Error {
if err.is_timeout() {
Error::Timeout
} else {
Error::Network(err)
}
}
fn parse_base(raw: &str) -> Result<Url, Error> {
let mut url = Url::parse(raw)
.map_err(|err| Error::validation("base_url", format!("not a valid URL: {err}")))?;
if url.path_segments_mut().is_err() {
return Err(Error::validation(
"base_url",
"must be an absolute URL that can be used as a base",
));
}
Ok(url)
}
fn validate_header_value(field: &str, value: &str) -> Result<(), Error> {
if value.bytes().all(|b| (0x20..=0x7E).contains(&b)) {
Ok(())
} else {
Err(Error::validation(
field,
"header value must be printable ASCII with no CR/LF",
))
}
}
#[derive(Debug)]
pub struct TransportBuilder {
http_builder: Option<reqwest::ClientBuilder>,
base_root: Option<String>,
user_agent: Option<String>,
accept_language: Option<String>,
send_legacy_cookie: bool,
get_retries: u32,
session: Option<Session>,
store: Option<Arc<dyn CredentialStore>>,
storage_failures: StorageFailures,
timeout: Duration,
read_timeout: Duration,
}
impl Default for TransportBuilder {
fn default() -> Self {
Self {
http_builder: None,
base_root: None,
user_agent: None,
accept_language: None,
send_legacy_cookie: true,
get_retries: 0,
session: None,
store: None,
storage_failures: StorageFailures::default(),
timeout: consts::REQUEST_TIMEOUT,
read_timeout: consts::READ_TIMEOUT,
}
}
}
impl TransportBuilder {
#[must_use]
pub fn http_builder(mut self, builder: reqwest::ClientBuilder) -> Self {
self.http_builder = Some(builder);
self
}
#[must_use]
pub fn base_url(mut self, base_url: impl Into<String>) -> Self {
self.base_root = Some(base_url.into());
self
}
#[must_use]
pub fn user_agent(mut self, user_agent: Option<String>) -> Self {
self.user_agent = user_agent;
self
}
#[must_use]
pub fn accept_language(mut self, accept_language: impl Into<String>) -> Self {
self.accept_language = Some(accept_language.into());
self
}
#[must_use]
pub fn send_legacy_cookie(mut self, send_legacy_cookie: bool) -> Self {
self.send_legacy_cookie = send_legacy_cookie;
self
}
#[must_use]
pub fn get_retries(mut self, get_retries: u32) -> Self {
self.get_retries = get_retries;
self
}
#[must_use]
pub fn session(mut self, session: Option<Session>) -> Self {
self.session = session;
self
}
#[must_use]
pub fn store(mut self, store: Option<Arc<dyn CredentialStore>>) -> Self {
self.store = store;
self
}
#[must_use]
pub fn storage_failures(mut self, storage_failures: StorageFailures) -> Self {
self.storage_failures = storage_failures;
self
}
#[must_use]
pub fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = timeout;
self
}
#[must_use]
pub fn read_timeout(mut self, read_timeout: Duration) -> Self {
self.read_timeout = read_timeout;
self
}
pub fn build(self) -> Result<Transport, Error> {
let (base_22, _base_23) = self.build_bases()?;
let api_host = {
let origin = base_22.origin().ascii_serialization();
Url::parse(&origin)
.map_err(|err| Error::validation("base_url", format!("not a valid URL: {err}")))?
};
let user_agent = self
.user_agent
.unwrap_or_else(|| consts::DEFAULT_USER_AGENT.to_owned());
validate_header_value("user_agent", &user_agent)?;
let accept_language = self
.accept_language
.unwrap_or_else(|| consts::DEFAULT_ACCEPT_LANGUAGE.to_owned());
validate_header_value("X-Accept-Language", &accept_language)?;
let http = if let Some(builder) = self.http_builder {
builder
.redirect(Policy::none())
.build()
.map_err(Error::Network)?
} else {
Client::builder()
.timeout(self.timeout)
.read_timeout(self.read_timeout)
.redirect(Policy::none())
.build()
.map_err(Error::Network)?
};
Ok(Transport {
http,
api_host,
session: RwLock::new(self.session),
store: self.store,
storage_failures: self.storage_failures,
user_agent,
accept_language,
send_legacy_cookie: self.send_legacy_cookie,
get_retries: self.get_retries,
refresh_slot: tokio::sync::Mutex::new(Weak::new()),
})
}
fn build_bases(&self) -> Result<(Url, Url), Error> {
let (raw_22, raw_23) = match &self.base_root {
Some(root) => {
let trimmed = root.trim_end_matches('/');
(
format!("{trimmed}/{}", ApiVersion::V2_2.segment()),
format!("{trimmed}/{}", ApiVersion::V2_3.segment()),
)
}
None => (
consts::API_BASE_22.to_owned(),
consts::API_BASE_23.to_owned(),
),
};
Ok((parse_base(&raw_22)?, parse_base(&raw_23)?))
}
}
#[cfg(test)]
mod tests {
use std::time::Duration;
use reqwest::header::{HeaderMap, HeaderValue, RETRY_AFTER};
use url::Url;
use super::{Transport, parse_retry_after, refresh_signal_detected, validate_header_value};
use crate::error::Error;
use crate::routes::{ACCOUNT, ApiVersion, Resource};
#[test]
fn retry_after_parses_delta_seconds_form() {
let mut headers = HeaderMap::new();
headers.insert(RETRY_AFTER, HeaderValue::from_static("120"));
assert_eq!(parse_retry_after(&headers), Some(Duration::from_secs(120)));
}
#[test]
fn retry_after_parses_delta_seconds_form_with_surrounding_whitespace() {
let mut headers = HeaderMap::new();
headers.insert(RETRY_AFTER, HeaderValue::from_static(" 30 "));
assert_eq!(parse_retry_after(&headers), Some(Duration::from_secs(30)));
}
#[test]
fn retry_after_parses_http_date_form_in_the_future() {
let mut headers = HeaderMap::new();
headers.insert(
RETRY_AFTER,
HeaderValue::from_static("Thu, 01 Jan 2099 00:00:00 GMT"),
);
let parsed = parse_retry_after(&headers).expect("valid HTTP-date form parses");
assert!(parsed > Duration::from_secs(0));
}
#[test]
fn retry_after_http_date_in_the_past_is_zero_not_none() {
let mut headers = HeaderMap::new();
headers.insert(
RETRY_AFTER,
HeaderValue::from_static("Wed, 01 Jan 2003 00:00:00 GMT"),
);
assert_eq!(parse_retry_after(&headers), Some(Duration::ZERO));
}
#[test]
fn retry_after_absent_header_is_none() {
let headers = HeaderMap::new();
assert_eq!(parse_retry_after(&headers), None);
}
#[test]
fn retry_after_garbage_value_is_none_not_an_error() {
let mut headers = HeaderMap::new();
headers.insert(
RETRY_AFTER,
HeaderValue::from_static("not a retry-after value"),
);
assert_eq!(parse_retry_after(&headers), None);
}
#[test]
fn retry_after_negative_number_is_none() {
let mut headers = HeaderMap::new();
headers.insert(RETRY_AFTER, HeaderValue::from_static("-5"));
assert_eq!(parse_retry_after(&headers), None);
}
#[test]
fn refresh_signal_detected_on_exact_match() {
assert!(refresh_signal_detected(
r#"{"meta":{"code":401,"error":"error.session.refresh"}}"#
));
}
#[test]
fn refresh_signal_not_detected_on_a_different_error_value() {
assert!(!refresh_signal_detected(
r#"{"meta":{"code":401,"error":"invalid_credentials"}}"#
));
}
#[test]
fn refresh_signal_not_detected_when_meta_is_absent() {
assert!(!refresh_signal_detected(r#"{"data":{}}"#));
}
#[test]
fn refresh_signal_not_detected_on_invalid_json() {
assert!(!refresh_signal_detected("not json at all"));
}
#[test]
fn validate_header_value_accepts_empty() {
validate_header_value("x", "").expect("empty header value matches the `*` rule");
}
#[test]
fn validate_header_value_rejects_crlf() {
let err = validate_header_value("x", "a\r\nb").unwrap_err();
assert!(matches!(err, Error::Validation { field, .. } if field == "x"));
}
#[test]
fn validate_header_value_accepts_printable_ascii() {
validate_header_value("x", "eero/3.0 (iPhone; iOS 17.0)").expect("printable ascii ok");
}
fn v2_3_resource() -> Resource {
Resource {
method: reqwest::Method::PUT,
version: ApiVersion::V2_3,
template: "networks/{id}/devices",
link: None,
}
}
#[test]
fn default_bases_resolve_against_the_real_eero_host() {
let transport = Transport::builder().build().expect("builds with defaults");
let url = ACCOUNT
.resolve(transport.api_host(), "", None)
.expect("a fixed path always resolves");
assert_eq!(url.as_str(), "https://api-user.e2ro.com/2.2/account");
}
#[test]
fn overridden_base_url_is_used_for_both_api_versions() {
let transport = Transport::builder()
.base_url("http://127.0.0.1:9999")
.build()
.expect("builds with an overridden base");
let v22 = ACCOUNT
.resolve(transport.api_host(), "", None)
.expect("v2.2 resource resolves");
assert_eq!(v22.as_str(), "http://127.0.0.1:9999/2.2/account");
let resource = v2_3_resource();
let v23 = resource
.resolve(transport.api_host(), "123", None)
.expect("v2.3 resource resolves");
assert_eq!(
v23.as_str(),
"http://127.0.0.1:9999/2.3/networks/123/devices"
);
}
#[test]
fn api_host_has_no_path_and_reflects_the_override() {
let transport = Transport::builder()
.base_url("http://127.0.0.1:9999")
.build()
.expect("builds with an overridden base");
assert_eq!(transport.api_host().as_str(), "http://127.0.0.1:9999/");
assert_eq!(transport.api_host().path(), "/");
}
#[test]
fn api_host_defaults_to_the_real_eero_host() {
let transport = Transport::builder().build().expect("builds with defaults");
assert_eq!(transport.api_host().host_str(), Some("api-user.e2ro.com"));
assert_eq!(transport.api_host().scheme(), "https");
}
#[test]
fn overridden_base_url_trailing_slash_is_not_doubled() {
let transport = Transport::builder()
.base_url("http://127.0.0.1:9999/")
.build()
.expect("builds with a trailing-slash base");
let url = ACCOUNT
.resolve(transport.api_host(), "", None)
.expect("resource resolves");
assert_eq!(url.as_str(), "http://127.0.0.1:9999/2.2/account");
}
#[test]
fn invalid_base_url_is_rejected_at_build_time() {
let err = Transport::builder()
.base_url("not a url")
.build()
.expect_err("malformed base URL must fail fast");
assert!(matches!(err, Error::Validation { field, .. } if field == "base_url"));
}
#[test]
fn no_session_means_not_authenticated_and_no_snapshot() {
let transport = Transport::builder().build().expect("builds with defaults");
assert!(!transport.is_authenticated());
assert!(transport.session().is_none());
}
#[test]
fn set_session_updates_the_snapshot_and_authentication_state() {
let transport = Transport::builder().build().expect("builds with defaults");
transport
.set_session(Some(crate::auth::Session::from_token("tok-123")))
.expect("no store configured, cannot fail");
assert!(transport.is_authenticated());
assert!(transport.session().is_some());
transport
.set_session(None)
.expect("clearing with no store cannot fail");
assert!(!transport.is_authenticated());
assert!(transport.session().is_none());
}
#[test]
fn set_session_rejects_an_empty_token() {
let transport = Transport::builder().build().expect("builds with defaults");
let err = transport
.set_session(Some(crate::auth::Session::from_token("")))
.expect_err("an empty token must be rejected");
assert!(matches!(err, Error::Validation { field, .. } if field == "token"));
assert!(!transport.is_authenticated());
}
#[test]
fn set_session_rejects_a_token_with_a_control_character() {
let transport = Transport::builder().build().expect("builds with defaults");
let err = transport
.set_session(Some(crate::auth::Session::from_token("tok\r\nX-Evil: 1")))
.expect_err("a control character in the token must be rejected");
assert!(matches!(err, Error::Validation { field, .. } if field == "token"));
}
#[test]
fn matches_configured_host_true_for_the_configured_scheme_host_and_port() {
let transport = Transport::builder()
.base_url("http://127.0.0.1:9999")
.build()
.expect("builds with an overridden base");
let url = Url::parse("http://127.0.0.1:9999/2.2/account").unwrap();
assert!(transport.matches_configured_host(&url));
}
#[test]
fn matches_configured_host_false_for_a_different_host() {
let transport = Transport::builder()
.base_url("http://127.0.0.1:9999")
.build()
.expect("builds with an overridden base");
let url = Url::parse("http://evil.example:9999/2.2/account").unwrap();
assert!(!transport.matches_configured_host(&url));
}
#[test]
fn matches_configured_host_false_for_a_different_port() {
let transport = Transport::builder()
.base_url("http://127.0.0.1:9999")
.build()
.expect("builds with an overridden base");
let url = Url::parse("http://127.0.0.1:8888/2.2/account").unwrap();
assert!(!transport.matches_configured_host(&url));
}
#[test]
fn matches_configured_host_false_for_a_different_scheme() {
let transport = Transport::builder()
.base_url("http://127.0.0.1:9999")
.build()
.expect("builds with an overridden base");
let url = Url::parse("https://127.0.0.1:9999/2.2/account").unwrap();
assert!(!transport.matches_configured_host(&url));
}
}