use serde::{Deserialize, Serialize};
use uuid::Uuid;
use super::discovery::OidcConfiguration;
use super::exchange::{OidcTokenSet, oauth2_error_or_fallback};
use crate::client::AxiamClient;
use crate::error::AxiamError;
use crate::sensitive::Sensitive;
pub const DEVICE_CODE_GRANT_TYPE: &str = "urn:ietf:params:oauth:grant-type:device_code";
pub const DEFAULT_POLL_INTERVAL_SECS: u64 = 5;
pub const SLOW_DOWN_INCREMENT_SECS: u64 = 5;
#[derive(Serialize)]
struct DeviceAuthorizationForm<'a> {
client_id: &'a str,
#[serde(skip_serializing_if = "Option::is_none")]
client_secret: Option<&'a str>,
#[serde(skip_serializing_if = "Option::is_none")]
scope: Option<&'a str>,
}
#[derive(Serialize)]
struct DeviceTokenForm<'a> {
grant_type: &'a str,
device_code: &'a str,
client_id: &'a str,
#[serde(skip_serializing_if = "Option::is_none")]
client_secret: Option<&'a str>,
}
#[derive(Deserialize)]
struct DeviceAuthorizationResponseWire {
device_code: String,
user_code: String,
verification_uri: String,
#[serde(default)]
verification_uri_complete: Option<String>,
expires_in: u64,
#[serde(default)]
interval: Option<u64>,
}
#[derive(Debug, Clone)]
pub struct DeviceAuthorization {
pub device_code: Sensitive<String>,
pub user_code: String,
pub verification_uri: String,
pub verification_uri_complete: Option<String>,
pub expires_in: u64,
pub interval: u64,
}
#[derive(Debug, Default, Clone)]
pub struct DeviceAuthorizeParams {
pub scope: Option<String>,
pub tenant_id: Option<Uuid>,
pub configuration: Option<OidcConfiguration>,
}
#[derive(Debug, Clone)]
pub struct DevicePollParams {
pub device_code: Sensitive<String>,
pub tenant_id: Option<Uuid>,
pub configuration: Option<OidcConfiguration>,
}
#[derive(Debug, Default, Clone)]
pub struct DeviceLoginParams {
pub scope: Option<String>,
pub tenant_id: Option<Uuid>,
pub configuration: Option<OidcConfiguration>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum PollOutcome {
Pending,
SlowDown,
RateLimited,
Transient,
Terminal,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct PollSchedule {
interval_secs: u64,
remaining_secs: u64,
}
impl PollSchedule {
pub fn new(interval_secs: u64, expires_in_secs: u64) -> Self {
Self {
interval_secs: if interval_secs == 0 {
DEFAULT_POLL_INTERVAL_SECS
} else {
interval_secs
},
remaining_secs: expires_in_secs,
}
}
pub fn interval_secs(&self) -> u64 {
self.interval_secs
}
pub fn slow_down(&mut self) {
self.interval_secs += SLOW_DOWN_INCREMENT_SECS;
}
pub fn tick(&mut self) -> bool {
self.tick_for(self.interval_secs)
}
pub fn tick_for(&mut self, wait_secs: u64) -> bool {
if wait_secs >= self.remaining_secs {
self.remaining_secs = 0;
return false;
}
self.remaining_secs -= wait_secs;
true
}
}
fn is_connect_error(e: &reqwest::Error) -> bool {
#[cfg(not(target_arch = "wasm32"))]
{
e.is_connect()
}
#[cfg(target_arch = "wasm32")]
{
let _ = e;
false
}
}
fn device_expired() -> AxiamError {
AxiamError::oauth_protocol_error(
"expired_token",
"the device authorization expired before the user completed it \
(client-side deadline from expires_in; CONTRACT.md §14.2 rule 4)",
)
}
struct PollFailure {
err: AxiamError,
retry_after: Option<std::time::Duration>,
status: Option<u16>,
}
impl From<AxiamError> for PollFailure {
fn from(err: AxiamError) -> Self {
Self {
err,
retry_after: None,
status: None,
}
}
}
fn classify(err: &AxiamError) -> PollOutcome {
match err.oauth_error_code() {
Some("authorization_pending") => PollOutcome::Pending,
Some("slow_down") => PollOutcome::SlowDown,
Some("rate_limit_exceeded") => PollOutcome::RateLimited,
_ => PollOutcome::Terminal,
}
}
fn classify_failure(failure: &PollFailure) -> PollOutcome {
match failure.status {
Some(s) if s >= 500 => PollOutcome::Transient,
Some(429) => PollOutcome::RateLimited,
Some(400) | None => classify(&failure.err),
Some(_) => PollOutcome::Terminal,
}
}
impl AxiamClient {
pub async fn device_authorize(
&self,
params: DeviceAuthorizeParams,
) -> Result<DeviceAuthorization, AxiamError> {
let configuration = match params.configuration {
Some(c) => c,
None => self.oidc_discover().await?,
};
let tenant_id = self.resolve_oidc_tenant_id(params.tenant_id).await?;
let client_id = self.oidc_client_id_or_err()?.to_string();
let endpoint = self
.mtls_preferred_opt(
&configuration,
|a| a.device_authorization_endpoint.as_deref(),
configuration.device_authorization_endpoint.as_deref(),
)?
.ok_or_else(|| {
AxiamError::Auth {
message:
"the authorization server's discovery document advertises no device_authorization_endpoint: this server does not support the device grant (CONTRACT.md §14.1)"
.into(),
oauth: None,
reason: None,
set_reason: None,
retry_after: None,
}
})?;
let url = self.oidc_endpoint_url(endpoint, tenant_id)?;
let client_secret = self.oidc_client_secret().map(|s| s.expose().clone());
let form = DeviceAuthorizationForm {
client_id: &client_id,
client_secret: client_secret.as_deref(),
scope: params.scope.as_deref(),
};
let response = self
.idp_form_post(url)
.form(&form)
.send()
.await
.map_err(|e| AxiamError::Network {
message: format!("device authorization request failed: {e}"),
source: Some(Box::new(e)),
})?;
if !response.status().is_success() {
return Err(oauth2_error_or_fallback(response).await);
}
let wire: DeviceAuthorizationResponseWire =
response.json().await.map_err(|e| AxiamError::Network {
message: format!("failed to parse device authorization response: {e}"),
source: Some(Box::new(e)),
})?;
Ok(DeviceAuthorization {
device_code: Sensitive::new(wire.device_code),
user_code: wire.user_code,
verification_uri: wire.verification_uri,
verification_uri_complete: wire.verification_uri_complete,
expires_in: wire.expires_in,
interval: wire
.interval
.filter(|i| *i > 0)
.unwrap_or(DEFAULT_POLL_INTERVAL_SECS),
})
}
pub async fn device_poll(&self, params: DevicePollParams) -> Result<OidcTokenSet, AxiamError> {
self.device_poll_step(params, None).await.map_err(|f| f.err)
}
async fn device_poll_step(
&self,
params: DevicePollParams,
bound: Option<&crate::retry::RetryBound<'_>>,
) -> Result<OidcTokenSet, PollFailure> {
use crate::retry::{
Attempt, RetryRunner, ThreadRngJitter, TokioSleeper, parse_retry_after,
};
let configuration = match params.configuration {
Some(c) => c,
None => self.oidc_discover().await.map_err(PollFailure::from)?,
};
let tenant_id = self
.resolve_oidc_tenant_id(params.tenant_id)
.await
.map_err(PollFailure::from)?;
let client_id = self
.oidc_client_id_or_err()
.map_err(PollFailure::from)?
.to_string();
let endpoint = self
.mtls_preferred(
&configuration,
|a| a.token_endpoint.as_deref(),
&configuration.token_endpoint,
)
.map_err(PollFailure::from)?;
let url = self
.oidc_endpoint_url(endpoint, tenant_id)
.map_err(PollFailure::from)?;
let client_secret = self.oidc_client_secret().map(|s| s.expose().clone());
let form = DeviceTokenForm {
grant_type: DEVICE_CODE_GRANT_TYPE,
device_code: params.device_code.expose().as_str(),
client_id: &client_id,
client_secret: client_secret.as_deref(),
};
let runner = RetryRunner {
enabled: self.retry_enabled(),
operation: "device_poll",
telemetry: self.telemetry(),
jitter: &ThreadRngJitter,
sleeper: &TokioSleeper,
};
let (url, form) = (&url, &form);
let wire = runner
.run_until(bound, |_| async move {
let response = self
.idp_form_post(url.clone())
.form(form)
.send()
.await
.map_err(|e| {
let kind = if e.is_timeout() {
"timed out"
} else if is_connect_error(&e) {
"could not connect"
} else {
"transport error"
};
Attempt::bare(AxiamError::Network {
message: format!("device token request failed: {kind}"),
source: Some(Box::new(e)),
})
})?;
if !response.status().is_success() {
let retry_after = response
.headers()
.get(reqwest::header::RETRY_AFTER)
.and_then(|v| v.to_str().ok())
.and_then(parse_retry_after);
let status = response.status().as_u16();
if status >= 500 {
return Err(Attempt {
err: AxiamError::from_http_status(
status,
format!("device token request failed: HTTP {status}"),
),
retry_after,
});
}
return Ok(Err(PollFailure {
err: oauth2_error_or_fallback(response).await,
retry_after,
status: Some(status),
}));
}
Ok(response
.json::<super::exchange::TokenResponseWire>()
.await
.map_err(|e| {
PollFailure::from(AxiamError::Network {
message: format!("failed to parse device token response: {e}"),
source: Some(Box::new(e)),
})
}))
})
.await
.map_err(|ended| {
if ended.at_deadline {
return PollFailure::from(device_expired());
}
PollFailure {
err: ended.err,
retry_after: ended.retry_after,
status: None,
}
})??;
self.to_token_set(wire, &configuration, None)
.await
.map_err(PollFailure::from)
}
pub async fn device_login<F>(
&self,
params: DeviceLoginParams,
on_user_code: F,
) -> Result<OidcTokenSet, AxiamError>
where
F: FnOnce(&DeviceAuthorization),
{
self.device_login_with(
params,
on_user_code,
&crate::retry::TokioSleeper,
&crate::time::Instant::now,
)
.await
}
pub(crate) async fn device_login_with<F>(
&self,
params: DeviceLoginParams,
on_user_code: F,
sleeper: &dyn crate::retry::Sleeper,
now: &(dyn Fn() -> crate::time::Instant + Send + Sync),
) -> Result<OidcTokenSet, AxiamError>
where
F: FnOnce(&DeviceAuthorization),
{
let configuration = match params.configuration {
Some(c) => c,
None => self.oidc_discover().await?,
};
let authorization = self
.device_authorize(DeviceAuthorizeParams {
scope: params.scope,
tenant_id: params.tenant_id,
configuration: Some(configuration.clone()),
})
.await?;
on_user_code(&authorization);
let deadline = now() + std::time::Duration::from_secs(authorization.expires_in);
let mut schedule = PollSchedule::new(authorization.interval, authorization.expires_in);
let retry_bound = crate::retry::RetryBound {
deadline,
now,
sleeper,
};
let mut retry_after_secs = 0;
loop {
let wait_secs = schedule.interval_secs().max(retry_after_secs);
retry_after_secs = 0;
let wait = std::time::Duration::from_secs(wait_secs);
if now() + wait >= deadline {
return Err(device_expired());
}
sleeper.sleep(wait).await;
if now() >= deadline {
return Err(device_expired());
}
match self
.device_poll_step(
DevicePollParams {
device_code: authorization.device_code.clone(),
tenant_id: params.tenant_id,
configuration: Some(configuration.clone()),
},
Some(&retry_bound),
)
.await
{
Ok(tokens) => return Ok(tokens),
Err(failure) => match classify_failure(&failure) {
PollOutcome::Pending | PollOutcome::Transient => continue,
PollOutcome::SlowDown => {
schedule.slow_down();
continue;
}
PollOutcome::RateLimited => {
retry_after_secs = failure.retry_after.map_or(0, |d| d.as_secs());
continue;
}
PollOutcome::Terminal => {
let (e, retry_after) = (failure.err, failure.retry_after);
if e.oauth_error_code().is_none() && e.is_retryable_transport() {
retry_after_secs = retry_after.map_or(0, |d| d.as_secs());
continue;
}
return Err(e);
}
},
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn zero_or_absent_interval_falls_back_to_the_rfc_default() {
assert_eq!(
PollSchedule::new(0, 600).interval_secs(),
DEFAULT_POLL_INTERVAL_SECS
);
assert_eq!(PollSchedule::new(7, 600).interval_secs(), 7);
}
#[test]
fn slow_down_is_cumulative_and_never_resets() {
let mut s = PollSchedule::new(5, 1800);
s.slow_down();
assert_eq!(s.interval_secs(), 10);
s.slow_down();
assert_eq!(s.interval_secs(), 15);
s.tick();
s.tick();
assert_eq!(
s.interval_secs(),
15,
"the raised interval persists across polls"
);
}
#[test]
fn tick_reports_the_deadline_and_stops() {
let mut s = PollSchedule::new(5, 12);
assert!(s.tick(), "t=5");
assert!(s.tick(), "t=10");
assert!(!s.tick(), "t=15 is past the 12 s deadline");
}
#[test]
fn a_slowed_interval_can_exhaust_the_grant_early() {
let mut s = PollSchedule::new(5, 20);
assert!(s.tick());
s.slow_down();
s.slow_down();
assert_eq!(s.interval_secs(), 15);
assert!(!s.tick(), "15 s does not fit in the 15 s remaining");
}
#[test]
fn an_interval_equal_to_the_whole_grant_never_polls() {
let mut s = PollSchedule::new(30, 30);
assert!(
!s.tick(),
"the first poll would land exactly on the deadline"
);
}
#[test]
fn classification_covers_the_five_rfc_8628_answers() {
let cases = [
("authorization_pending", PollOutcome::Pending),
("slow_down", PollOutcome::SlowDown),
("expired_token", PollOutcome::Terminal),
("access_denied", PollOutcome::Terminal),
("invalid_grant", PollOutcome::Terminal),
];
for (code, want) in cases {
let err = AxiamError::oauth_protocol_error(code, "d");
assert_eq!(classify(&err), want, "{code}");
}
}
#[test]
fn a_transport_failure_is_neither_pending_nor_a_protocol_answer() {
let err = AxiamError::network("connection reset");
assert_eq!(err.oauth_error_code(), None);
assert!(err.is_retryable_transport());
assert_eq!(classify(&err), PollOutcome::Terminal);
}
use crate::client::AxiamClient;
use crate::oidc::DeviceLoginParams;
use crate::retry::Sleeper;
use serde_json::json;
use std::sync::Mutex;
use std::time::Duration;
use wiremock::matchers::{method, path};
use wiremock::{Mock, MockServer, ResponseTemplate};
#[derive(Default)]
struct Recorded(Mutex<Vec<Duration>>);
impl Sleeper for Recorded {
fn sleep(&self, d: Duration) -> std::pin::Pin<Box<dyn Future<Output = ()> + Send + '_>> {
self.0.lock().unwrap().push(d);
Box::pin(std::future::ready(()))
}
}
async fn device_fixture(
script: Vec<ResponseTemplate>,
expires_in: u64,
) -> (
MockServer,
AxiamClient,
std::sync::Arc<std::sync::atomic::AtomicUsize>,
) {
device_fixture_with(script, expires_in, std::sync::Arc::new(|| {}), true).await
}
async fn device_fixture_with(
script: Vec<ResponseTemplate>,
expires_in: u64,
on_poll: std::sync::Arc<dyn Fn() + Send + Sync>,
retry: bool,
) -> (
MockServer,
AxiamClient,
std::sync::Arc<std::sync::atomic::AtomicUsize>,
) {
use std::sync::atomic::{AtomicUsize, Ordering};
let server = MockServer::start().await;
let base = server.uri();
Mock::given(method("GET"))
.and(path("/.well-known/openid-configuration"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"issuer": "https://iam.example.com",
"authorization_endpoint": format!("{base}/oauth2/authorize"),
"token_endpoint": format!("{base}/oauth2/token"),
"userinfo_endpoint": format!("{base}/oauth2/userinfo"),
"jwks_uri": format!("{base}/oauth2/jwks"),
"revocation_endpoint": format!("{base}/oauth2/revoke"),
"introspection_endpoint": format!("{base}/oauth2/introspect"),
"scopes_supported": ["openid"],
"token_endpoint_auth_methods_supported": ["client_secret_post"],
"claims_supported": ["sub"],
"grant_types_supported": ["urn:ietf:params:oauth:grant-type:device_code"],
"device_authorization_endpoint": format!("{base}/oauth2/device_authorization"),
"response_types_supported": ["code"],
"subject_types_supported": ["public"],
"id_token_signing_alg_values_supported": ["EdDSA"],
})))
.mount(&server)
.await;
Mock::given(method("POST"))
.and(path("/oauth2/device_authorization"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"device_code": "dc",
"user_code": "WDJB-MJHT",
"verification_uri": "https://iam.example.com/device",
"expires_in": expires_in,
"interval": 5,
})))
.mount(&server)
.await;
let polls = std::sync::Arc::new(AtomicUsize::new(0));
let seen = std::sync::Arc::clone(&polls);
let script = Mutex::new(script);
let on_poll = std::sync::Arc::clone(&on_poll);
Mock::given(method("POST"))
.and(path("/oauth2/token"))
.respond_with(move |_: &wiremock::Request| {
on_poll();
let i = seen.fetch_add(1, Ordering::SeqCst);
let script = script.lock().unwrap();
script
.get(i)
.or(script.last())
.cloned()
.expect("non-empty script")
})
.mount(&server)
.await;
let client = AxiamClient::builder()
.base_url(&base)
.expect("valid base url")
.tenant_id(uuid::Uuid::nil())
.org_id(uuid::Uuid::nil())
.oidc_client_id("axiam-rp")
.retry_enabled(retry)
.build()
.expect("client builds");
(server, client, polls)
}
fn rate_limited(retry_after: &str) -> ResponseTemplate {
ResponseTemplate::new(429)
.insert_header("Retry-After", retry_after)
.set_body_json(json!({"error": "rate_limit_exceeded"}))
}
fn pending() -> ResponseTemplate {
ResponseTemplate::new(400).set_body_json(json!({"error": "authorization_pending"}))
}
fn tokens() -> ResponseTemplate {
ResponseTemplate::new(200).set_body_json(json!({
"access_token": "device-access-token",
"token_type": "Bearer",
"expires_in": 900,
}))
}
#[tokio::test]
async fn a_429_on_a_poll_is_waited_out_and_the_interval_is_unchanged() {
let (_server, client, polls) =
device_fixture(vec![rate_limited("12"), pending(), tokens()], 600).await;
let sleeps = Recorded::default();
let set = client
.device_login_with(
DeviceLoginParams::default(),
|_| {},
&sleeps,
&crate::time::Instant::now,
)
.await
.expect("the loop completes after the 429");
assert_eq!(set.access_token.expose(), "device-access-token");
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 3);
let secs: Vec<u64> = sleeps
.0
.lock()
.unwrap()
.iter()
.map(|d| d.as_secs())
.collect();
assert_eq!(secs, [5, 12, 5]);
}
#[tokio::test]
async fn a_short_retry_after_never_goes_below_the_interval() {
let (_server, client, _) = device_fixture(vec![rate_limited("1"), tokens()], 600).await;
let sleeps = Recorded::default();
client
.device_login_with(
DeviceLoginParams::default(),
|_| {},
&sleeps,
&crate::time::Instant::now,
)
.await
.expect("completes");
let secs: Vec<u64> = sleeps
.0
.lock()
.unwrap()
.iter()
.map(|d| d.as_secs())
.collect();
assert_eq!(secs, [5, 5]);
}
#[tokio::test]
async fn a_retry_after_past_the_deadline_ends_in_expired_token() {
let (_server, client, polls) =
device_fixture(vec![rate_limited("3600"), tokens()], 60).await;
let sleeps = Recorded::default();
let err = client
.device_login_with(
DeviceLoginParams::default(),
|_| {},
&sleeps,
&crate::time::Instant::now,
)
.await
.expect_err("the deadline wins");
assert_eq!(err.oauth_error_code(), Some("expired_token"));
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 1);
let secs: Vec<u64> = sleeps
.0
.lock()
.unwrap()
.iter()
.map(|d| d.as_secs())
.collect();
assert_eq!(secs, [5], "no wait is served past the deadline");
}
#[test]
fn a_retry_after_wait_counts_as_one_interval_and_keeps_the_interval() {
let mut s = PollSchedule::new(5, 100);
assert!(s.tick_for(30));
assert_eq!(s.interval_secs(), 5);
assert!(!s.tick_for(70), "the wait that reaches the deadline stops");
}
fn server_error() -> ResponseTemplate {
ResponseTemplate::new(500)
.set_body_json(json!({"error": "server_error", "error_description": "db"}))
}
#[tokio::test]
async fn a_500_with_an_error_body_mid_poll_is_not_terminal() {
let (_server, client, polls) =
device_fixture(vec![server_error(), pending(), tokens()], 600).await;
let sleeps = Recorded::default();
client
.device_login_with(
DeviceLoginParams::default(),
|_| {},
&sleeps,
&crate::time::Instant::now,
)
.await
.expect("a 500 mid-poll does not lose the grant");
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 3);
let waits = sleeps.0.lock().unwrap().clone();
assert_eq!(waits.len(), 3);
assert_eq!(waits[0], Duration::from_secs(5));
assert!(
waits[1] <= Duration::from_millis(200),
"unexpected retry waits"
);
assert_eq!(waits[2], Duration::from_secs(5));
}
#[tokio::test]
async fn a_429_slow_down_waits_and_does_not_raise_the_interval() {
let slow = ResponseTemplate::new(429)
.insert_header("Retry-After", "1")
.set_body_json(json!({"error": "slow_down"}));
let (_server, client, _) = device_fixture(vec![slow, pending(), tokens()], 600).await;
let sleeps = Recorded::default();
client
.device_login_with(
DeviceLoginParams::default(),
|_| {},
&sleeps,
&crate::time::Instant::now,
)
.await
.expect("completes");
let secs: Vec<u64> = sleeps
.0
.lock()
.unwrap()
.iter()
.map(|d| d.as_secs())
.collect();
assert_eq!(secs, [5, 5, 5]);
}
#[tokio::test]
async fn a_400_slow_down_still_raises_the_interval() {
let slow = ResponseTemplate::new(400).set_body_json(json!({"error": "slow_down"}));
let (_server, client, _) = device_fixture(vec![slow, tokens()], 600).await;
let sleeps = Recorded::default();
client
.device_login_with(
DeviceLoginParams::default(),
|_| {},
&sleeps,
&crate::time::Instant::now,
)
.await
.expect("completes");
let secs: Vec<u64> = sleeps
.0
.lock()
.unwrap()
.iter()
.map(|d| d.as_secs())
.collect();
assert_eq!(secs, [5, 10]);
}
#[tokio::test]
async fn a_bodiless_429_honours_retry_after() {
let bare = ResponseTemplate::new(429).insert_header("Retry-After", "12");
let (_server, client, _) = device_fixture(vec![bare, tokens()], 600).await;
let sleeps = Recorded::default();
client
.device_login_with(
DeviceLoginParams::default(),
|_| {},
&sleeps,
&crate::time::Instant::now,
)
.await
.expect("completes");
let secs: Vec<u64> = sleeps
.0
.lock()
.unwrap()
.iter()
.map(|d| d.as_secs())
.collect();
assert_eq!(secs, [5, 12]);
}
struct FakeClock {
base: crate::time::Instant,
offset_secs: std::sync::atomic::AtomicU64,
waits: Mutex<Vec<Duration>>,
}
impl FakeClock {
fn now(&self) -> crate::time::Instant {
self.base
+ Duration::from_secs(self.offset_secs.load(std::sync::atomic::Ordering::SeqCst))
}
}
impl Sleeper for FakeClock {
fn sleep(&self, d: Duration) -> std::pin::Pin<Box<dyn Future<Output = ()> + Send + '_>> {
self.waits.lock().unwrap().push(d);
self.offset_secs
.fetch_add(d.as_secs(), std::sync::atomic::Ordering::SeqCst);
Box::pin(std::future::ready(()))
}
}
#[tokio::test]
async fn the_time_a_poll_takes_counts_against_the_deadline() {
let clock = std::sync::Arc::new(FakeClock {
base: crate::time::Instant::now(),
offset_secs: std::sync::atomic::AtomicU64::new(0),
waits: Mutex::new(Vec::new()),
});
let tick = std::sync::Arc::clone(&clock);
let (_server, client, polls) = device_fixture_with(
vec![pending()],
60,
std::sync::Arc::new(move || {
tick.offset_secs
.fetch_add(30, std::sync::atomic::Ordering::SeqCst);
}),
true,
)
.await;
let reader = std::sync::Arc::clone(&clock);
let err = client
.device_login_with(DeviceLoginParams::default(), |_| {}, &*clock, &move || {
reader.now()
})
.await
.expect_err("the deadline wins");
assert_eq!(err.oauth_error_code(), Some("expired_token"));
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 2);
let secs: Vec<u64> = clock
.waits
.lock()
.unwrap()
.iter()
.map(|d| d.as_secs())
.collect();
assert_eq!(secs, [5, 5]);
}
fn run_params() -> DeviceLoginParams {
DeviceLoginParams::default()
}
async fn login_recording(
client: &AxiamClient,
sleeps: &Recorded,
) -> Result<crate::oidc::OidcTokenSet, AxiamError> {
client
.device_login_with(run_params(), |_| {}, sleeps, &crate::time::Instant::now)
.await
}
fn waits_of(sleeps: &Recorded) -> Vec<Duration> {
sleeps.0.lock().unwrap().clone()
}
#[tokio::test]
async fn a_5xx_is_retried_inside_the_poll() {
let (_server, client, polls) =
device_fixture(vec![server_error(), server_error(), tokens()], 600).await;
let sleeps = Recorded::default();
login_recording(&client, &sleeps).await.expect("completes");
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 3);
let waits = waits_of(&sleeps);
assert_eq!(waits.len(), 3, "unexpected retry waits");
assert_eq!(waits[0], Duration::from_secs(5), "the one interval");
assert!(
waits[1] <= Duration::from_millis(200),
"unexpected retry waits"
);
assert!(
waits[2] <= Duration::from_millis(400),
"unexpected retry waits"
);
}
#[tokio::test]
async fn with_retry_off_a_5xx_costs_an_interval() {
let (_server, client, polls) = device_fixture_with(
vec![server_error(), server_error(), tokens()],
600,
std::sync::Arc::new(|| {}),
false,
)
.await;
let sleeps = Recorded::default();
login_recording(&client, &sleeps).await.expect("completes");
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 3);
assert_eq!(waits_of(&sleeps), [Duration::from_secs(5); 3]);
}
#[tokio::test]
async fn a_5xx_retry_after_is_a_floor_inside_the_poll() {
let busy = ResponseTemplate::new(503)
.insert_header("Retry-After", "9")
.set_body_json(json!({"error": "temporarily_unavailable"}));
let (_server, client, _) = device_fixture(vec![busy, tokens()], 600).await;
let sleeps = Recorded::default();
login_recording(&client, &sleeps).await.expect("completes");
assert_eq!(
waits_of(&sleeps),
[Duration::from_secs(5), Duration::from_secs(9)]
);
}
#[tokio::test]
async fn a_retry_wait_is_capped_at_the_deadline_and_ends_in_expired_token() {
let busy = ResponseTemplate::new(503).insert_header("Retry-After", "3600");
let (_server, client, polls) = device_fixture(vec![busy, tokens()], 60).await;
let sleeps = Recorded::default();
let err = login_recording(&client, &sleeps)
.await
.expect_err("the deadline wins");
assert_eq!(err.oauth_error_code(), Some("expired_token"));
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 1);
let waits = waits_of(&sleeps);
assert_eq!(waits.len(), 2, "unexpected retry waits");
assert_eq!(waits[0], Duration::from_secs(5));
assert!(waits[1] < Duration::from_secs(60), "unexpected retry waits");
assert!(waits[1] > Duration::from_secs(50), "unexpected retry waits");
}
fn poll_params() -> DevicePollParams {
DevicePollParams {
device_code: crate::Sensitive::new("dc".to_string()),
tenant_id: None,
configuration: None,
}
}
#[tokio::test]
async fn a_single_device_poll_types_a_5xx_as_a_network_error() {
for answer in [
server_error(),
ResponseTemplate::new(503).set_body_json(json!({"error": "temporarily_unavailable"})),
] {
let (_server, client, polls) =
device_fixture_with(vec![answer], 600, std::sync::Arc::new(|| {}), false).await;
let err = client
.device_poll(poll_params())
.await
.expect_err("a 5xx is an error");
assert!(
matches!(err, AxiamError::Network { .. }),
"expected a network error"
);
assert_eq!(err.oauth_error_code(), None);
assert!(err.is_retryable_transport());
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 1);
}
}
#[tokio::test]
async fn a_single_device_poll_retries_a_5xx_but_not_a_429() {
let (_server, client, polls) =
device_fixture(vec![server_error(), server_error(), tokens()], 600).await;
let set = client.device_poll(poll_params()).await.expect("recovers");
assert_eq!(set.access_token.expose(), "device-access-token");
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 3);
let (_server, client, polls) = device_fixture(vec![rate_limited("1"), tokens()], 600).await;
let err = client.device_poll(poll_params()).await.expect_err("429");
assert_eq!(err.oauth_error_code(), Some("rate_limit_exceeded"));
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 1);
}
#[tokio::test]
async fn three_5xx_exhaust_the_attempt_cap() {
let (_server, client, polls) = device_fixture(
vec![server_error(), server_error(), server_error(), tokens()],
600,
)
.await;
let err = client
.device_poll(poll_params())
.await
.expect_err("three attempts, all 5xx");
assert!(
matches!(err, AxiamError::Network { .. }),
"expected a network error"
);
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 3);
let sleeps = Recorded::default();
login_recording(&client, &sleeps).await.expect("completes");
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 4);
assert_eq!(waits_of(&sleeps), [Duration::from_secs(5)]);
}
#[tokio::test]
async fn an_exhausted_budget_keeps_the_last_retry_after_as_the_next_polls_floor() {
let busy = || {
ResponseTemplate::new(503)
.insert_header("Retry-After", "40")
.set_body_json(json!({"error": "temporarily_unavailable"}))
};
let (_server, client, polls) =
device_fixture(vec![busy(), busy(), busy(), tokens()], 600).await;
let sleeps = Recorded::default();
login_recording(&client, &sleeps).await.expect("completes");
assert_eq!(polls.load(std::sync::atomic::Ordering::SeqCst), 4);
assert_eq!(
waits_of(&sleeps),
[
Duration::from_secs(5),
Duration::from_secs(40),
Duration::from_secs(40),
Duration::from_secs(40),
],
"the two in-poll retries, then the next poll at the floor"
);
}
async fn raw_token_server(
drops: usize,
) -> (
std::net::SocketAddr,
std::sync::Arc<std::sync::atomic::AtomicUsize>,
) {
use std::sync::atomic::{AtomicUsize, Ordering};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
.await
.expect("bind");
let addr = listener.local_addr().expect("addr");
let connections = std::sync::Arc::new(AtomicUsize::new(0));
let seen = std::sync::Arc::clone(&connections);
tokio::spawn(async move {
loop {
let Ok((mut stream, _)) = listener.accept().await else {
return;
};
let n = seen.fetch_add(1, Ordering::SeqCst);
tokio::spawn(async move {
let mut buf = Vec::new();
let mut chunk = [0u8; 1024];
loop {
let Ok(read) = stream.read(&mut chunk).await else {
return;
};
if read == 0 {
return;
}
buf.extend_from_slice(&chunk[..read]);
let Some(head_end) = buf.windows(4).position(|w| w == b"\r\n\r\n") else {
continue;
};
let head = String::from_utf8_lossy(&buf[..head_end]).to_lowercase();
let wanted = head
.lines()
.find_map(|l| l.strip_prefix("content-length:"))
.and_then(|v| v.trim().parse::<usize>().ok())
.unwrap_or(0);
if buf.len() >= head_end + 4 + wanted {
break;
}
}
if n < drops {
drop(stream);
return;
}
let body = r#"{"access_token":"device-access-token","token_type":"Bearer","expires_in":900}"#;
let response = format!(
"HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: {}\r\nConnection: close\r\n\r\n{body}",
body.len()
);
let _ = stream.write_all(response.as_bytes()).await;
let _ = stream.shutdown().await;
});
}
});
(addr, connections)
}
async fn raw_client(raw: std::net::SocketAddr, retry: bool) -> (MockServer, AxiamClient) {
let server = MockServer::start().await;
let base = server.uri();
Mock::given(method("GET"))
.and(path("/.well-known/openid-configuration"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"issuer": "https://iam.example.com",
"authorization_endpoint": format!("{base}/oauth2/authorize"),
"token_endpoint": format!("http://{raw}/oauth2/token"),
"userinfo_endpoint": format!("{base}/oauth2/userinfo"),
"jwks_uri": format!("{base}/oauth2/jwks"),
"revocation_endpoint": format!("{base}/oauth2/revoke"),
"introspection_endpoint": format!("{base}/oauth2/introspect"),
"scopes_supported": ["openid"],
"token_endpoint_auth_methods_supported": ["client_secret_post"],
"claims_supported": ["sub"],
"grant_types_supported": ["urn:ietf:params:oauth:grant-type:device_code"],
"device_authorization_endpoint": format!("{base}/oauth2/device_authorization"),
"response_types_supported": ["code"],
"subject_types_supported": ["public"],
"id_token_signing_alg_values_supported": ["EdDSA"],
})))
.mount(&server)
.await;
Mock::given(method("POST"))
.and(path("/oauth2/device_authorization"))
.respond_with(ResponseTemplate::new(200).set_body_json(json!({
"device_code": "dc",
"user_code": "WDJB-MJHT",
"verification_uri": "https://iam.example.com/device",
"expires_in": 600,
"interval": 5,
})))
.mount(&server)
.await;
let client = AxiamClient::builder()
.base_url(&base)
.expect("valid base url")
.tenant_id(uuid::Uuid::nil())
.org_id(uuid::Uuid::nil())
.oidc_client_id("axiam-rp")
.retry_enabled(retry)
.build()
.expect("client builds");
(server, client)
}
#[tokio::test]
async fn a_transport_failure_is_retried_inside_the_poll() {
use std::sync::atomic::Ordering;
let (raw, connections) = raw_token_server(2).await;
let (_server, client) = raw_client(raw, true).await;
let set = client
.device_poll(poll_params())
.await
.expect("two drops, then the tokens");
assert_eq!(set.access_token.expose(), "device-access-token");
assert_eq!(connections.load(Ordering::SeqCst), 3);
let (raw, connections) = raw_token_server(3).await;
let (_server, client) = raw_client(raw, true).await;
let err = client
.device_poll(poll_params())
.await
.expect_err("three drops exhaust the cap");
assert!(matches!(err, AxiamError::Network { .. }));
assert!(err.is_retryable_transport());
assert_eq!(connections.load(Ordering::SeqCst), 3);
let (raw, connections) = raw_token_server(1).await;
let (_server, client) = raw_client(raw, false).await;
client
.device_poll(poll_params())
.await
.expect_err("retry off: one request");
assert_eq!(connections.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn device_login_completes_within_one_interval_over_a_flaky_transport() {
let (raw, connections) = raw_token_server(2).await;
let (_server, client) = raw_client(raw, true).await;
let sleeps = Recorded::default();
login_recording(&client, &sleeps).await.expect("completes");
assert_eq!(connections.load(std::sync::atomic::Ordering::SeqCst), 3);
let waits = waits_of(&sleeps);
assert_eq!(waits.len(), 3, "the interval and two backoff waits");
assert_eq!(waits[0], Duration::from_secs(5));
assert!(waits[1] <= Duration::from_millis(200));
assert!(waits[2] <= Duration::from_millis(400));
}
}
#[cfg(test)]
mod wire_redaction_tests {
#[test]
fn no_wire_struct_holding_a_secret_is_debug() {
assert!(
!crate::sensitive::implements_debug!(super::DeviceAuthorizationResponseWire),
"DeviceAuthorizationResponseWire is Debug"
);
}
}