use std::{
fmt,
future::Future,
path::PathBuf,
pin::Pin,
sync::{Arc, Mutex, MutexGuard},
time::{Duration, SystemTime, UNIX_EPOCH},
};
use futures_util::FutureExt;
use futures_util::future::Shared;
use reqwest::{RequestBuilder, Response, StatusCode, Url};
use serde::Deserialize;
use shardline_xet_adapter::{XET_READ_TOKEN_ROUTE, XET_WRITE_TOKEN_ROUTE};
use thiserror::Error;
use crate::config::{
Credential, CredentialResolutionError, read_token_file, resolve_credential_from_env,
};
pub const REFRESH_BUFFER_SECONDS: u64 = 30;
const MAX_TOKEN_RESPONSE_BYTES: usize = 1024 * 1024;
pub const PROVIDER_KEY_HEADER_NAME: &str = "x-shardline-provider-key";
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct RepositoryId {
pub provider: String,
pub owner: String,
pub repo: String,
pub revision: String,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct HttpConfig {
connect_timeout: Duration,
request_timeout: Duration,
}
impl HttpConfig {
#[must_use]
pub const fn new() -> Self {
Self {
connect_timeout: Duration::from_secs(60),
request_timeout: Duration::from_secs(60),
}
}
#[must_use]
pub const fn with_connect_timeout(mut self, timeout: Duration) -> Self {
self.connect_timeout = timeout;
self
}
#[must_use]
pub const fn with_request_timeout(mut self, timeout: Duration) -> Self {
self.request_timeout = timeout;
self
}
#[must_use]
pub const fn connect_timeout(&self) -> Duration {
self.connect_timeout
}
#[must_use]
pub const fn request_timeout(&self) -> Duration {
self.request_timeout
}
}
impl Default for HttpConfig {
fn default() -> Self {
Self::new()
}
}
#[derive(Clone)]
pub struct Auth {
base_url: Url,
repository: RepositoryId,
token: Option<String>,
api_key: Option<String>,
token_file: Option<PathBuf>,
subject: Option<String>,
http: HttpConfig,
}
impl fmt::Debug for Auth {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Auth")
.field("base_url", &self.base_url)
.field("repository", &self.repository)
.field("token", &"<redacted>")
.field("api_key", &"<redacted>")
.field("token_file", &self.token_file)
.field("subject", &self.subject)
.field("http", &self.http)
.finish()
}
}
impl Auth {
pub fn new(base_url: &str, repository: RepositoryId) -> Result<Self, AuthError> {
let base_url = Url::parse(base_url).map_err(|source| AuthError::InvalidBaseUrl {
url: base_url.to_owned(),
detail: source.to_string(),
})?;
if base_url.cannot_be_a_base() {
return Err(AuthError::InvalidBaseUrl {
url: base_url.to_string(),
detail: "URL cannot be used as a base URL".to_owned(),
});
}
Ok(Self {
base_url,
repository,
token: None,
api_key: None,
token_file: None,
subject: None,
http: HttpConfig::default(),
})
}
#[must_use]
pub fn base_url(&self) -> &str {
self.base_url.as_str()
}
#[must_use]
pub const fn repository(&self) -> &RepositoryId {
&self.repository
}
#[must_use]
#[allow(clippy::missing_const_for_fn)]
pub fn with_token(mut self, token: String) -> Self {
self.token = Some(token);
self
}
#[must_use]
#[allow(clippy::missing_const_for_fn)]
pub fn with_api_key(mut self, api_key: String) -> Self {
self.api_key = Some(api_key);
self
}
#[must_use]
#[allow(clippy::missing_const_for_fn)]
pub fn with_token_file(mut self, path: PathBuf) -> Self {
self.token_file = Some(path);
self
}
#[must_use]
#[allow(clippy::missing_const_for_fn)]
pub fn with_subject(mut self, subject: String) -> Self {
self.subject = Some(subject);
self
}
#[must_use]
pub const fn with_http(mut self, http: HttpConfig) -> Self {
self.http = http;
self
}
pub fn build(self) -> Result<TokenService, AuthError> {
let client = reqwest::Client::builder()
.connect_timeout(self.http.connect_timeout)
.timeout(self.http.request_timeout)
.redirect(token_redirect_policy(&self.base_url))
.build()
.map_err(|source| AuthError::Transport {
message: source.to_string(),
source: Arc::new(source),
})?;
Ok(TokenService::with_clock(
client,
self,
Arc::new(unix_now_seconds),
))
}
fn token_url(&self, scope: Scope) -> Url {
let mut url = self.base_url.clone();
let base_path = url.path().trim_end_matches('/');
let path = format!("{base_path}{}", self.token_path(scope));
url.set_path(&path);
if let Some(subject) = &self.subject {
url.query_pairs_mut().append_pair("subject", subject);
}
url
}
fn token_path(&self, scope: Scope) -> String {
let route = match scope {
Scope::Read => XET_READ_TOKEN_ROUTE,
Scope::Write => XET_WRITE_TOKEN_ROUTE,
};
route
.replace(
"{provider}",
&crate::tree::encode_path_segment(&self.repository.provider),
)
.replace(
"{owner}",
&crate::tree::encode_path_segment(&self.repository.owner),
)
.replace(
"{repo}",
&crate::tree::encode_path_segment(&self.repository.repo),
)
.replace(
"{rev}",
&crate::tree::encode_path_segment(&self.repository.revision),
)
}
fn resolve_credential(
&self,
env: &dyn Fn(&str) -> Option<String>,
) -> Result<Credential, AuthError> {
if let Some(token) = &self.token {
return Ok(Credential::Bearer(token.clone()));
}
if let Some(api_key) = &self.api_key {
return Ok(Credential::ProviderKey(api_key.clone()));
}
if let Some(path) = &self.token_file {
let contents = read_token_file(path).map_err(|source| AuthError::TokenFile {
path: path.clone(),
source: Arc::new(source),
})?;
return Ok(Credential::Bearer(contents));
}
let env_credential = resolve_credential_from_env(env)?;
env_credential.ok_or(AuthError::MissingCredential)
}
}
#[derive(Clone, PartialEq, Eq)]
pub struct ScopedToken {
pub token: String,
pub exp: u64,
pub cas_url: String,
}
impl fmt::Debug for ScopedToken {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ScopedToken")
.field("token", &"<redacted>")
.field("exp", &self.exp)
.field("cas_url", &self.cas_url)
.finish()
}
}
#[derive(Debug, Clone, Error)]
pub enum AuthError {
#[error(
"no credential available: set a token, api key, or token file (or SHARDLINE_TOKEN / \
SHARDLINE_API_KEY / SHARDLINE_TOKEN_FILE)"
)]
MissingCredential,
#[error("token issuance rejected (401 unauthorized): {message}")]
Unauthorized {
message: String,
},
#[error("token issuance denied (403 forbidden): {message}")]
Forbidden {
message: String,
},
#[error("token issuance failed with HTTP {status}: {message}")]
HttpStatus {
status: u16,
message: String,
},
#[error("token issued with expiration {exp} within the {buffer}s refresh buffer")]
ShortLivedToken {
exp: u64,
buffer: u64,
},
#[error("token issuance transport error: {message}")]
Transport {
message: String,
#[source]
source: Arc<reqwest::Error>,
},
#[error("failed to parse token issuance response: {message}")]
Parse {
message: String,
#[source]
source: Arc<serde_json::Error>,
},
#[error("failed to read token file {path:?}: {source}")]
TokenFile {
path: PathBuf,
#[source]
source: Arc<std::io::Error>,
},
#[error("invalid token issuance base URL {url:?}: {detail}")]
InvalidBaseUrl {
url: String,
detail: String,
},
}
impl From<reqwest::Error> for AuthError {
fn from(source: reqwest::Error) -> Self {
Self::Transport {
message: source.to_string(),
source: Arc::new(source),
}
}
}
impl From<serde_json::Error> for AuthError {
fn from(source: serde_json::Error) -> Self {
Self::Parse {
message: source.to_string(),
source: Arc::new(source),
}
}
}
impl From<CredentialResolutionError> for AuthError {
fn from(error: CredentialResolutionError) -> Self {
match error {
CredentialResolutionError::TokenFile { path, source } => AuthError::TokenFile {
path,
source: Arc::new(source),
},
}
}
}
type RefreshFuture = Pin<Box<dyn Future<Output = Result<ScopedToken, AuthError>> + Send>>;
type EnvLookup = Arc<dyn Fn(&str) -> Option<String> + Send + Sync>;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Scope {
Read,
Write,
}
#[derive(Default)]
struct CacheState {
read: Option<ScopedToken>,
write: Option<ScopedToken>,
read_inflight: Option<Shared<RefreshFuture>>,
write_inflight: Option<Shared<RefreshFuture>>,
}
#[derive(Clone)]
pub struct TokenService {
inner: Arc<TokenServiceInner>,
}
struct TokenServiceInner {
client: reqwest::Client,
auth: Auth,
env: EnvLookup,
clock: Arc<dyn Fn() -> u64 + Send + Sync>,
state: Mutex<CacheState>,
}
impl TokenService {
fn with_clock(
client: reqwest::Client,
auth: Auth,
clock: Arc<dyn Fn() -> u64 + Send + Sync>,
) -> Self {
Self::with_deps(client, auth, clock, Arc::new(process_env))
}
fn with_deps(
client: reqwest::Client,
auth: Auth,
clock: Arc<dyn Fn() -> u64 + Send + Sync>,
env: EnvLookup,
) -> Self {
Self {
inner: Arc::new(TokenServiceInner {
client,
auth,
env,
clock,
state: Mutex::new(CacheState::default()),
}),
}
}
pub async fn read_token(&self) -> Result<ScopedToken, AuthError> {
self.token(Scope::Read).await
}
pub async fn write_token(&self) -> Result<ScopedToken, AuthError> {
self.token(Scope::Write).await
}
#[must_use]
pub fn cas_url(&self) -> Option<String> {
let state = self.lock_state();
state
.read
.as_ref()
.or(state.write.as_ref())
.map(|token| token.cas_url.clone())
}
async fn token(&self, scope: Scope) -> Result<ScopedToken, AuthError> {
let now = self.now();
let shared = {
let mut state = self.lock_state();
if let Some(cached) = cached(scope, &state)
&& cached.exp.saturating_sub(now) >= REFRESH_BUFFER_SECONDS
{
return Ok(cached);
}
inflight(scope, &state).unwrap_or_else(|| {
let future = self.start_refresh(scope);
let started = future.shared();
*inflight_mut(scope, &mut state) = Some(started.clone());
started
})
};
let result = shared.clone().await;
let mut state = self.lock_state();
let owns_refresh = inflight(scope, &state).is_some_and(|current| current.ptr_eq(&shared));
if owns_refresh {
*inflight_mut(scope, &mut state) = None;
}
let token = result?;
let remaining = token.exp.saturating_sub(self.now());
if remaining < REFRESH_BUFFER_SECONDS {
return Err(AuthError::ShortLivedToken {
exp: token.exp,
buffer: REFRESH_BUFFER_SECONDS,
});
}
if owns_refresh {
*cached_mut(scope, &mut state) = Some(token.clone());
}
Ok(token)
}
fn start_refresh(&self, scope: Scope) -> RefreshFuture {
Box::pin(issue_token(
self.inner.client.clone(),
self.inner.auth.clone(),
self.inner.env.clone(),
scope,
))
}
pub(crate) fn invalidate_read(&self) {
self.invalidate(Scope::Read);
}
pub(crate) fn invalidate_write(&self) {
self.invalidate(Scope::Write);
}
fn invalidate(&self, scope: Scope) {
let mut state = self.lock_state();
*cached_mut(scope, &mut state) = None;
*inflight_mut(scope, &mut state) = None;
}
fn now(&self) -> u64 {
(self.inner.clock)()
}
fn lock_state(&self) -> MutexGuard<'_, CacheState> {
self.inner
.state
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
}
}
async fn issue_token(
client: reqwest::Client,
auth: Auth,
env: EnvLookup,
scope: Scope,
) -> Result<ScopedToken, AuthError> {
let credential = auth.resolve_credential(env.as_ref())?;
let url = auth.token_url(scope);
let request = client.get(url);
let request = apply_credential(request, credential);
let response = request.send().await?;
let status = response.status();
if !status.is_success() {
let message = error_message(response).await;
return Err(http_error(status, message));
}
let bytes = read_token_response(response).await?;
let parsed: XetCasTokenResponse = serde_json::from_slice(&bytes)?;
Ok(ScopedToken {
token: parsed.access_token,
exp: parsed.exp,
cas_url: parsed.cas_url,
})
}
fn cached(scope: Scope, state: &CacheState) -> Option<ScopedToken> {
match scope {
Scope::Read => state.read.clone(),
Scope::Write => state.write.clone(),
}
}
const fn cached_mut(scope: Scope, state: &mut CacheState) -> &mut Option<ScopedToken> {
match scope {
Scope::Read => &mut state.read,
Scope::Write => &mut state.write,
}
}
fn inflight(scope: Scope, state: &CacheState) -> Option<Shared<RefreshFuture>> {
match scope {
Scope::Read => state.read_inflight.clone(),
Scope::Write => state.write_inflight.clone(),
}
}
fn inflight_mut(scope: Scope, state: &mut CacheState) -> &mut Option<Shared<RefreshFuture>> {
match scope {
Scope::Read => &mut state.read_inflight,
Scope::Write => &mut state.write_inflight,
}
}
fn apply_credential(request: RequestBuilder, credential: Credential) -> RequestBuilder {
match credential {
Credential::Bearer(token) => request.bearer_auth(token),
Credential::ProviderKey(key) => request.header(PROVIDER_KEY_HEADER_NAME, key),
}
}
fn token_redirect_policy(base_url: &Url) -> reqwest::redirect::Policy {
let origin = base_url.origin();
reqwest::redirect::Policy::custom(move |attempt| {
if attempt.url().origin() != origin {
attempt.error("token issuance redirect leaves the configured origin")
} else {
reqwest::redirect::Policy::default().redirect(attempt)
}
})
}
const fn http_error(status: StatusCode, message: String) -> AuthError {
let code = status.as_u16();
match code {
401 => AuthError::Unauthorized { message },
403 => AuthError::Forbidden { message },
_ => AuthError::HttpStatus {
status: code,
message,
},
}
}
async fn read_token_response(mut response: Response) -> Result<Vec<u8>, AuthError> {
if response.content_length().is_some_and(|length| {
usize::try_from(length).unwrap_or(usize::MAX) > MAX_TOKEN_RESPONSE_BYTES
}) {
return Err(token_response_too_large());
}
let mut bytes = Vec::new();
while let Some(chunk) = response.chunk().await? {
if bytes.len().saturating_add(chunk.len()) > MAX_TOKEN_RESPONSE_BYTES {
return Err(token_response_too_large());
}
bytes.extend_from_slice(&chunk);
}
Ok(bytes)
}
fn token_response_too_large() -> AuthError {
<serde_json::Error as serde::de::Error>::custom(format!(
"token issuance response exceeds {MAX_TOKEN_RESPONSE_BYTES} bytes"
))
.into()
}
async fn error_message(response: Response) -> String {
match read_token_response(response).await {
Ok(bytes) => serde_json::from_slice::<ErrorBody>(&bytes)
.map(|parsed| parsed.error)
.unwrap_or_else(|_error| String::from_utf8_lossy(&bytes).into_owned()),
Err(error) => error.to_string(),
}
}
#[derive(Debug, Deserialize)]
struct ErrorBody {
error: String,
}
#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
struct XetCasTokenResponse {
cas_url: String,
exp: u64,
access_token: String,
}
fn process_env(name: &str) -> Option<String> {
std::env::var(name).ok()
}
fn unix_now_seconds() -> u64 {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap_or_default()
.as_secs()
}
#[cfg(test)]
mod tests {
use std::{
collections::HashMap,
sync::{
Arc,
atomic::{AtomicU64, Ordering},
},
time::Duration,
};
use serde_json::json;
use wiremock::{
Mock, MockServer, ResponseTemplate,
matchers::{header, method, path, query_param},
};
use super::{Auth, AuthError, EnvLookup, REFRESH_BUFFER_SECONDS, RepositoryId, TokenService};
use crate::config::{SHARDLINE_API_KEY_ENV, SHARDLINE_TOKEN_ENV, SHARDLINE_TOKEN_FILE_ENV};
const NOW: u64 = 1_000_000_000;
fn repository() -> RepositoryId {
RepositoryId {
provider: "github".to_owned(),
owner: "team".to_owned(),
repo: "assets".to_owned(),
revision: "main".to_owned(),
}
}
fn read_path() -> String {
"/api/github/team/assets/xet-read-token/main".to_owned()
}
fn write_path() -> String {
"/api/github/team/assets/xet-write-token/main".to_owned()
}
fn token_response(exp: u64, access_token: &str, cas_url: &str) -> ResponseTemplate {
ResponseTemplate::new(200).set_body_json(json!({
"casUrl": cas_url,
"exp": exp,
"accessToken": access_token,
}))
}
fn service(auth: Auth, now: &Arc<AtomicU64>) -> TokenService {
let clock: Arc<dyn Fn() -> u64 + Send + Sync> = {
let now = Arc::clone(now);
Arc::new(move || now.load(Ordering::Relaxed))
};
TokenService::with_clock(reqwest::Client::new(), auth, clock)
}
fn service_with_env(auth: Auth, env: HashMap<String, String>) -> TokenService {
let now = Arc::new(AtomicU64::new(NOW));
let clock: Arc<dyn Fn() -> u64 + Send + Sync> = {
let now = Arc::clone(&now);
Arc::new(move || now.load(Ordering::Relaxed))
};
let env: EnvLookup = Arc::new(move |name| env.get(name).cloned());
TokenService::with_deps(reqwest::Client::new(), auth, clock, env)
}
async fn request_count(server: &MockServer) -> usize {
server.received_requests().await.unwrap_or_default().len()
}
fn bearer_auth(token: &str) -> String {
format!("Bearer {token}")
}
#[tokio::test]
async fn read_token_uses_read_endpoint_with_interpolated_path() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(token_response(NOW + 3600, "read-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
let token = service.read_token().await.unwrap();
assert_eq!(token.token, "read-token");
assert_eq!(request_count(&server).await, 1);
}
#[tokio::test]
async fn write_token_uses_write_endpoint_with_interpolated_path() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(write_path()))
.respond_with(token_response(NOW + 3600, "write-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
let token = service.write_token().await.unwrap();
assert_eq!(token.token, "write-token");
assert_eq!(request_count(&server).await, 1);
}
#[tokio::test]
async fn read_and_write_scopes_issue_distinct_tokens() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(token_response(NOW + 3600, "read-token", &server.uri()))
.mount(&server)
.await;
Mock::given(method("GET"))
.and(path(write_path()))
.respond_with(token_response(NOW + 3600, "write-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
let read = service.read_token().await.unwrap();
let write = service.write_token().await.unwrap();
assert_eq!(read.token, "read-token");
assert_eq!(write.token, "write-token");
assert_ne!(read.token, write.token);
assert_eq!(request_count(&server).await, 2);
}
#[tokio::test]
async fn bearer_token_sent_via_authorization_header() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.and(header("authorization", &bearer_auth("server-token")))
.respond_with(token_response(NOW + 3600, "read-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
let token = service.read_token().await.unwrap();
assert_eq!(token.token, "read-token");
assert_eq!(request_count(&server).await, 1);
}
#[tokio::test]
async fn api_key_sent_via_provider_key_header() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.and(header("x-shardline-provider-key", "bootstrap-key"))
.respond_with(token_response(NOW + 3600, "read-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_api_key("bootstrap-key".to_owned());
let service = service(auth, &now);
let token = service.read_token().await.unwrap();
assert_eq!(token.token, "read-token");
assert_eq!(request_count(&server).await, 1);
}
#[tokio::test]
async fn provider_key_does_not_follow_redirect_to_another_origin() {
let issuer = MockServer::start().await;
let other_origin = MockServer::start().await;
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(
ResponseTemplate::new(302)
.insert_header("location", format!("{}/issued", other_origin.uri())),
)
.mount(&issuer)
.await;
Mock::given(method("GET"))
.and(header("x-shardline-provider-key", "test-bootstrap-key"))
.respond_with(token_response(
super::unix_now_seconds() + 3600,
"redirected-token",
&issuer.uri(),
))
.mount(&other_origin)
.await;
let tokens = Auth::new(&issuer.uri(), repository())
.unwrap()
.with_api_key("test-bootstrap-key".to_owned())
.build()
.unwrap();
assert!(tokens.read_token().await.is_err());
assert_eq!(request_count(&issuer).await, 1);
assert_eq!(request_count(&other_origin).await, 0);
}
#[tokio::test]
async fn provider_key_follows_same_origin_redirect() {
let issuer = MockServer::start().await;
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(ResponseTemplate::new(302).insert_header("location", "/issued"))
.mount(&issuer)
.await;
Mock::given(method("GET"))
.and(path("/issued"))
.and(header("x-shardline-provider-key", "test-bootstrap-key"))
.respond_with(token_response(
super::unix_now_seconds() + 3600,
"redirected-token",
&issuer.uri(),
))
.mount(&issuer)
.await;
let tokens = Auth::new(&issuer.uri(), repository())
.unwrap()
.with_api_key("test-bootstrap-key".to_owned())
.build()
.unwrap();
assert_eq!(tokens.read_token().await.unwrap().token, "redirected-token");
assert_eq!(request_count(&issuer).await, 2);
}
#[tokio::test]
async fn token_issuance_same_origin_redirect_loop_is_bounded() {
let issuer = MockServer::start().await;
Mock::given(method("GET"))
.respond_with(ResponseTemplate::new(302).insert_header("location", read_path()))
.mount(&issuer)
.await;
let tokens = Auth::new(&issuer.uri(), repository())
.unwrap()
.with_api_key("test-bootstrap-key".to_owned())
.build()
.unwrap();
let result = tokio::time::timeout(Duration::from_secs(2), tokens.read_token())
.await
.expect("redirect loop must not stall token issuance");
assert!(matches!(result, Err(AuthError::Transport { .. })));
let requests = request_count(&issuer).await;
assert!((2..=11).contains(&requests), "request count: {requests}");
}
#[tokio::test]
async fn parses_exact_camel_case_response_fields() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(ResponseTemplate::new(200).set_body_raw(
br#"{"casUrl":"http://cas.internal:8080/","exp":1700000000,"accessToken":"opaque-bearer"}"#,
"application/json",
))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
let token = service.read_token().await.unwrap();
assert_eq!(token.token, "opaque-bearer");
assert_eq!(token.exp, 1_700_000_000);
assert_eq!(token.cas_url, "http://cas.internal:8080/");
}
#[tokio::test]
async fn cas_url_surfaced_from_response() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(token_response(NOW + 3600, "read-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
let token = service.read_token().await.unwrap();
assert_eq!(token.cas_url, server.uri());
assert_eq!(service.cas_url(), Some(server.uri()));
}
#[tokio::test]
async fn caching_repeated_calls_issue_once() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(token_response(NOW + 3600, "cached-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
let first = service.read_token().await.unwrap();
let second = service.read_token().await.unwrap();
let third = service.read_token().await.unwrap();
assert_eq!(first.token, "cached-token");
assert_eq!(second.token, "cached-token");
assert_eq!(third.token, "cached-token");
assert_eq!(request_count(&server).await, 1);
}
#[tokio::test]
async fn refresh_token_within_buffer_reissues() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(token_response(NOW + 3600, "token-1", &server.uri()))
.up_to_n_times(1)
.mount(&server)
.await;
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(token_response(NOW + 7200, "token-2", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
let first = service.read_token().await.unwrap();
assert_eq!(first.token, "token-1");
assert_eq!(request_count(&server).await, 1);
now.store(NOW + 3600 - REFRESH_BUFFER_SECONDS + 1, Ordering::Relaxed);
let second = service.read_token().await.unwrap();
assert_eq!(second.token, "token-2");
assert_eq!(request_count(&server).await, 2);
}
#[tokio::test]
async fn cancelled_last_refresh_waiter_releases_inner_for_both_scopes() {
for scope in [super::Scope::Read, super::Scope::Write] {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.respond_with(
token_response(NOW + 3600, "token", &server.uri())
.set_delay(Duration::from_millis(100)),
)
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let unpolled = service(auth.clone(), &now);
let weak = Arc::downgrade(&unpolled.inner);
drop(unpolled);
assert!(weak.upgrade().is_none());
let tokens = service(auth.clone(), &now);
let weak = Arc::downgrade(&tokens.inner);
let mut first = Box::pin(tokens.token(scope));
let mut second = Box::pin(tokens.token(scope));
assert!(futures_util::poll!(&mut first).is_pending());
assert!(futures_util::poll!(&mut second).is_pending());
drop(first);
assert!(weak.upgrade().is_some());
drop(second);
drop(tokens);
assert!(weak.upgrade().is_none());
let completed = service(auth, &now);
let weak = Arc::downgrade(&completed.inner);
assert_eq!(completed.token(scope).await.unwrap().token, "token");
drop(completed);
assert!(weak.upgrade().is_none());
}
}
#[tokio::test]
async fn cancelled_refresh_can_resume_without_duplicate_issuance() {
for scope in [super::Scope::Read, super::Scope::Write] {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.respond_with(
token_response(NOW + 3600, "resumed-token", &server.uri())
.set_delay(Duration::from_millis(50)),
)
.mount(&server)
.await;
let tokens = service(
Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned()),
&now,
);
let mut initial = Box::pin(tokens.token(scope));
assert!(futures_util::poll!(&mut initial).is_pending());
drop(initial);
assert_eq!(tokens.token(scope).await.unwrap().token, "resumed-token");
assert_eq!(tokens.token(scope).await.unwrap().token, "resumed-token");
assert_eq!(request_count(&server).await, 1);
}
}
#[tokio::test]
async fn single_flight_concurrent_reads_one_request() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(
ResponseTemplate::new(200)
.set_delay(Duration::from_millis(200))
.set_body_json(json!({
"casUrl": server.uri(),
"exp": NOW + 3600,
"accessToken": "shared-token",
})),
)
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
let tasks: Vec<_> = (0..10)
.map(|_| {
let service = service.clone();
tokio::spawn(async move { service.read_token().await })
})
.collect();
let results = futures_util::future::join_all(tasks).await;
for result in results {
let token = result.unwrap().unwrap();
assert_eq!(token.token, "shared-token");
}
assert_eq!(request_count(&server).await, 1);
}
#[tokio::test]
async fn delayed_refresh_waiter_cannot_replace_a_newer_cached_token() {
for scope in [super::Scope::Read, super::Scope::Write] {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.respond_with(token_response(NOW + 3600, "old-token", &server.uri()))
.up_to_n_times(1)
.mount(&server)
.await;
Mock::given(method("GET"))
.respond_with(token_response(NOW + 3600, "new-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("test-credential".to_owned());
let tokens = service(auth, &now);
let mut delayed = Box::pin(tokens.token(scope));
assert!(futures_util::poll!(&mut delayed).is_pending());
assert_eq!(tokens.token(scope).await.unwrap().token, "old-token");
tokens.invalidate(scope);
assert_eq!(tokens.token(scope).await.unwrap().token, "new-token");
assert_eq!(delayed.await.unwrap().token, "old-token");
assert_eq!(tokens.token(scope).await.unwrap().token, "new-token");
assert_eq!(request_count(&server).await, 2);
}
}
#[tokio::test]
async fn invalidation_discards_an_inflight_refresh_without_recaching_its_result() {
for scope in [super::Scope::Read, super::Scope::Write] {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.respond_with(
token_response(NOW + 3600, "old-token", &server.uri())
.set_delay(Duration::from_millis(100)),
)
.up_to_n_times(1)
.mount(&server)
.await;
Mock::given(method("GET"))
.respond_with(token_response(NOW + 3600, "new-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("test-credential".to_owned());
let tokens = service(auth, &now);
let mut old_refresh = Box::pin(tokens.token(scope));
assert!(futures_util::poll!(&mut old_refresh).is_pending());
tokio::time::timeout(Duration::from_secs(2), async {
while request_count(&server).await == 0 {
assert!(futures_util::poll!(&mut old_refresh).is_pending());
tokio::task::yield_now().await;
}
})
.await
.expect("the old issuance request must reach the mock server");
tokens.invalidate(scope);
assert_eq!(tokens.token(scope).await.unwrap().token, "new-token");
assert_eq!(old_refresh.await.unwrap().token, "old-token");
assert_eq!(tokens.token(scope).await.unwrap().token, "new-token");
assert_eq!(request_count(&server).await, 2);
}
}
#[tokio::test]
async fn refresh_loop_guard_surfaces_error_and_stays_bounded() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(token_response(NOW + 5, "too-short", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
let first = service.read_token().await;
assert!(matches!(first, Err(AuthError::ShortLivedToken { .. })));
let second = service.read_token().await;
assert!(matches!(second, Err(AuthError::ShortLivedToken { .. })));
assert_eq!(request_count(&server).await, 2);
}
#[tokio::test]
async fn unauthorized_status_maps_to_typed_error() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(
ResponseTemplate::new(401).set_body_json(json!({"error": "missing provider key"})),
)
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
let err = service.read_token().await.unwrap_err();
assert!(matches!(err, AuthError::Unauthorized { .. }));
assert!(err.to_string().contains("missing provider key"));
}
#[tokio::test]
async fn forbidden_status_maps_to_typed_error() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(
ResponseTemplate::new(403).set_body_json(json!({"error": "insufficient scope"})),
)
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
let err = service.read_token().await.unwrap_err();
assert!(matches!(err, AuthError::Forbidden { .. }));
assert!(err.to_string().contains("insufficient scope"));
}
#[tokio::test]
async fn server_error_status_maps_to_typed_error() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(ResponseTemplate::new(500).set_body_json(json!({"error": "internal"})))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
let err = service.read_token().await.unwrap_err();
assert!(matches!(err, AuthError::HttpStatus { status: 500, .. }));
assert!(err.to_string().contains("internal"));
}
#[tokio::test]
async fn non_json_response_body_is_parse_error() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(
ResponseTemplate::new(200)
.set_body_raw(b"<html>not a token response</html>", "text/html"),
)
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
let err = service.read_token().await.unwrap_err();
assert!(matches!(err, AuthError::Parse { .. }));
}
#[tokio::test]
async fn oversized_token_responses_fail_with_and_without_content_length() {
for chunked in [false, true] {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
let mut response = ResponseTemplate::new(200).set_body_json(json!({
"casUrl": server.uri(),
"exp": NOW + 3600,
"accessToken": "test-token",
"padding": "x".repeat(super::MAX_TOKEN_RESPONSE_BYTES),
}));
if chunked {
response = response.insert_header("transfer-encoding", "chunked");
}
Mock::given(method("GET"))
.respond_with(response)
.mount(&server)
.await;
let probe = reqwest::get(server.uri()).await.unwrap();
assert_eq!(probe.content_length().is_none(), chunked);
drop(probe);
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("test-credential".to_owned());
let tokens = service(auth, &now);
assert!(matches!(
tokens.read_token().await,
Err(AuthError::Parse { .. })
));
assert!(tokens.cas_url().is_none());
}
}
#[tokio::test]
async fn oversized_error_response_keeps_status_with_a_bounded_message() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.respond_with(
ResponseTemplate::new(503)
.insert_header("transfer-encoding", "chunked")
.set_body_string("x".repeat(super::MAX_TOKEN_RESPONSE_BYTES + 1)),
)
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("test-credential".to_owned());
let tokens = service(auth, &now);
let error = tokens.read_token().await.unwrap_err();
assert!(matches!(&error, AuthError::HttpStatus { status: 503, .. }));
let message = error.to_string();
assert!(message.len() < 1024);
assert!(message.contains("exceeds"));
}
#[tokio::test]
async fn subject_query_param_transmitted_when_configured() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.and(query_param("subject", "alice"))
.respond_with(token_response(NOW + 3600, "read-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned())
.with_subject("alice".to_owned());
let service = service(auth, &now);
service.read_token().await.unwrap();
let requests = server.received_requests().await.unwrap_or_default();
assert_eq!(
requests[0].url.path(),
"/api/github/team/assets/xet-read-token/main"
);
assert_eq!(requests[0].url.query(), Some("subject=alice"));
}
#[tokio::test]
async fn no_subject_query_when_not_configured() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
Mock::given(method("GET"))
.and(path(read_path()))
.respond_with(token_response(NOW + 3600, "read-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("server-token".to_owned());
let service = service(auth, &now);
service.read_token().await.unwrap();
let requests = server.received_requests().await.unwrap_or_default();
assert_eq!(
requests[0].url.path(),
"/api/github/team/assets/xet-read-token/main"
);
assert_eq!(requests[0].url.query(), None);
}
#[tokio::test]
async fn explicit_token_beats_env_credentials() {
let server = MockServer::start().await;
let mut env = HashMap::new();
env.insert(SHARDLINE_TOKEN_ENV.to_owned(), "env-token".to_owned());
Mock::given(method("GET"))
.and(path(read_path()))
.and(header("authorization", &bearer_auth("explicit-token")))
.respond_with(token_response(NOW + 3600, "read-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token("explicit-token".to_owned());
let service = service_with_env(auth, env);
service.read_token().await.unwrap();
assert_eq!(request_count(&server).await, 1);
}
#[tokio::test]
async fn explicit_api_key_beats_env_token() {
let server = MockServer::start().await;
let mut env = HashMap::new();
env.insert(SHARDLINE_TOKEN_ENV.to_owned(), "env-token".to_owned());
Mock::given(method("GET"))
.and(path(read_path()))
.and(header("x-shardline-provider-key", "explicit-key"))
.respond_with(token_response(NOW + 3600, "read-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_api_key("explicit-key".to_owned());
let service = service_with_env(auth, env);
service.read_token().await.unwrap();
assert_eq!(request_count(&server).await, 1);
}
#[tokio::test]
async fn missing_credential_errors_before_any_request() {
let server = MockServer::start().await;
let auth = Auth::new(&server.uri(), repository()).unwrap();
let service = service_with_env(auth, HashMap::new());
let err = service.read_token().await.unwrap_err();
assert!(matches!(err, AuthError::MissingCredential));
assert_eq!(request_count(&server).await, 0);
}
#[tokio::test]
async fn token_file_credential_reads_and_sends_bearer() {
let server = MockServer::start().await;
let now = Arc::new(AtomicU64::new(NOW));
let dir = tempfile::tempdir().unwrap();
let token_file = dir.path().join("token");
std::fs::write(&token_file, " file-token\n").unwrap();
Mock::given(method("GET"))
.and(path(read_path()))
.and(header("authorization", &bearer_auth("file-token")))
.respond_with(token_response(NOW + 3600, "read-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository())
.unwrap()
.with_token_file(token_file);
let service = service(auth, &now);
service.read_token().await.unwrap();
assert_eq!(request_count(&server).await, 1);
}
#[tokio::test]
async fn env_token_used_when_no_explicit_credential() {
let server = MockServer::start().await;
let mut env = HashMap::new();
env.insert(SHARDLINE_TOKEN_ENV.to_owned(), "env-token".to_owned());
Mock::given(method("GET"))
.and(path(read_path()))
.and(header("authorization", &bearer_auth("env-token")))
.respond_with(token_response(NOW + 3600, "read-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository()).unwrap();
let service = service_with_env(auth, env);
service.read_token().await.unwrap();
assert_eq!(request_count(&server).await, 1);
}
#[tokio::test]
async fn env_api_key_used_when_no_explicit_credential() {
let server = MockServer::start().await;
let mut env = HashMap::new();
env.insert(SHARDLINE_API_KEY_ENV.to_owned(), "env-key".to_owned());
Mock::given(method("GET"))
.and(path(read_path()))
.and(header("x-shardline-provider-key", "env-key"))
.respond_with(token_response(NOW + 3600, "read-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository()).unwrap();
let service = service_with_env(auth, env);
service.read_token().await.unwrap();
assert_eq!(request_count(&server).await, 1);
}
#[tokio::test]
async fn env_token_file_credential_reads_and_sends_bearer() {
let server = MockServer::start().await;
let dir = tempfile::tempdir().unwrap();
let token_file = dir.path().join("token");
std::fs::write(&token_file, " env-file-token\n").unwrap();
let mut env = HashMap::new();
env.insert(
SHARDLINE_TOKEN_FILE_ENV.to_owned(),
token_file.to_string_lossy().into_owned(),
);
Mock::given(method("GET"))
.and(path(read_path()))
.and(header("authorization", &bearer_auth("env-file-token")))
.respond_with(token_response(NOW + 3600, "read-token", &server.uri()))
.mount(&server)
.await;
let auth = Auth::new(&server.uri(), repository()).unwrap();
let service = service_with_env(auth, env);
service.read_token().await.unwrap();
assert_eq!(request_count(&server).await, 1);
}
#[test]
fn invalid_base_url_rejected_at_construction() {
let error = Auth::new("not a url", repository()).unwrap_err();
assert!(matches!(error, AuthError::InvalidBaseUrl { .. }));
}
#[test]
fn non_base_url_rejected_at_construction() {
let error = Auth::new("mailto:user@example.com", repository()).unwrap_err();
assert!(matches!(error, AuthError::InvalidBaseUrl { .. }));
}
}