Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.
TypeScript agentaiai-agentsall-in-onecrmcrm-systememaillinearmcpmessagingnotesnotionofficerustslackslack-alternativestartupstartup-toolstypescriptworkspace
use std::{
borrow::Cow,
sync::{Arc, Mutex},
};
use ::axum::{
Json, Router,
body::Body,
extract::FromRef,
http::{HeaderValue, Request, StatusCode},
response::IntoResponse,
routing::get,
};
use bot_id::BotId;
use http_body_util::BodyExt;
use rootcause::Report;
use serde_json::{Value, json};
use tower::ServiceExt;
use uuid::Uuid;
use super::*;
use crate::{
AccountManagerCredential, AuthorizedUserApiKey, BotActingUserClaims, BotAuthentication,
BotScope, InternalIdentityClaims, MacroAuthorization, MacroAuthorizationError,
MacroAuthorizationService, MacroUserAuthentication,
};
const VALID_USER_ID: &str = "macro|[email protected]";
const COOKIE_USER_ID: &str = "macro|[email protected]";
const QUERY_USER_ID: &str = "macro|[email protected]";
const BEARER_USER_ID: &str = "macro|[email protected]";
const OPTIONAL_USER_ID: &str = "macro|[email protected]";
const STANDARD_INTERNAL_USER_ID: &str = "macro|[email protected]";
const LEGACY_INTERNAL_USER_ID: &str = "macro|[email protected]";
const BOT_ACTING_USER_ID: &str = "macro|[email protected]";
const VALID_INTERNAL_KEY: &str = "valid-internal-key";
const BOT_ID: BotId = BotId::new_from_uuid(Uuid::from_u128(1));
const BOT_TOKEN_ID: Uuid = Uuid::from_u128(2);
const BOT_TEAM_ID: Uuid = Uuid::from_u128(3);
const ACCESS_TOKEN_COOKIE: &str = "macro-access-token";
const API_KEY_USER_ID: &str = "macro|[email protected]";
const VALID_USER_API_KEY: &str = "mak_valid";
const MANAGER_API_KEY: &str = "mak_manager";
#[derive(Clone, Debug, Eq, PartialEq)]
enum AuthorizationCall {
Jwt(String),
UserApiKey(String),
Bot {
token: String,
bot_scope: BotScope,
claims: Option<BotActingUserClaims>,
},
Internal {
provided_key: String,
claims: InternalIdentityClaims,
},
}
#[derive(Clone, Default)]
struct FakeAuthorizationService {
calls: Arc<Mutex<Vec<AuthorizationCall>>>,
}
impl FakeAuthorizationService {
fn calls(&self) -> Vec<AuthorizationCall> {
self.calls.lock().expect("calls lock poisoned").clone()
}
}
impl MacroAuthorizationService for FakeAuthorizationService {
async fn authorize(&self, jwt: &str) -> Result<UserContext, Report<MacroAuthorizationError>> {
self.calls
.lock()
.expect("calls lock poisoned")
.push(AuthorizationCall::Jwt(jwt.to_string()));
match jwt {
"valid" => Ok(user_context(VALID_USER_ID, None)),
"cookie" => Ok(user_context(COOKIE_USER_ID, None)),
"query" => Ok(user_context(QUERY_USER_ID, None)),
"bearer" => Ok(user_context(BEARER_USER_ID, None)),
"optional" => Ok(user_context(OPTIONAL_USER_ID, None)),
"organization" => Ok(user_context(VALID_USER_ID, Some(42))),
"malformed-user" => Ok(user_context("not-a-macro-user-id", None)),
"empty-user" => Ok(user_context("", None)),
"expired" => Err(Report::new(MacroAuthorizationError::CredentialsExpired)),
_ => Err(Report::new(MacroAuthorizationError::InvalidCredentials)),
}
}
async fn authorize_identity(
&self,
jwt: &str,
) -> Result<crate::ValidatedCredential, Report<MacroAuthorizationError>> {
self.authorize(jwt)
.await
.map(crate::ValidatedCredential::session)
}
async fn authorize_user_api_key(
&self,
api_key: &str,
) -> Result<AuthorizedUserApiKey, Report<MacroAuthorizationError>> {
self.calls
.lock()
.expect("calls lock poisoned")
.push(AuthorizationCall::UserApiKey(api_key.to_string()));
match api_key {
VALID_USER_API_KEY => Ok(AuthorizedUserApiKey {
user_context: user_context(API_KEY_USER_ID, Some(42)),
account_manager: None,
}),
MANAGER_API_KEY => Ok(AuthorizedUserApiKey {
user_context: user_context(API_KEY_USER_ID, Some(42)),
account_manager: Some(AccountManagerCredential {
grant_id: Uuid::nil(),
manager_user_id: MacroUserIdStr::parse_from_str("macro|[email protected]")
.expect("valid Macro user id")
.into_owned(),
}),
}),
"mak_unavailable" => Err(Report::new(MacroAuthorizationError::Unavailable)),
_ => Err(Report::new(MacroAuthorizationError::InvalidCredentials)),
}
}
async fn authorize_bot(
&self,
token: &str,
bot_scope: BotScope,
claims: Option<BotActingUserClaims>,
) -> Result<BotAuthentication, Report<MacroAuthorizationError>> {
self.calls
.lock()
.expect("calls lock poisoned")
.push(AuthorizationCall::Bot {
token: token.to_owned(),
bot_scope,
claims: claims.clone(),
});
match token {
"bot-bare" => Ok(bot_authentication(bot_scope, None)),
"bot-acting" => Ok(bot_authentication(bot_scope, Some(BOT_ACTING_USER_ID))),
"bot-expired" => Err(Report::new(MacroAuthorizationError::CredentialsExpired)),
"bot-forbidden" => Err(Report::new(
MacroAuthorizationError::ActingUserNotAuthorized,
)),
"bot-scope-forbidden" => {
Err(Report::new(MacroAuthorizationError::BotScopeNotAuthorized))
}
"bot-unavailable" => Err(Report::new(MacroAuthorizationError::Unavailable)),
_ => Err(Report::new(MacroAuthorizationError::InvalidCredentials)),
}
}
async fn authorize_internal(
&self,
provided_key: &str,
claims: InternalIdentityClaims,
) -> Result<Option<UserContext>, Report<MacroAuthorizationError>> {
self.calls
.lock()
.expect("calls lock poisoned")
.push(AuthorizationCall::Internal {
provided_key: provided_key.to_string(),
claims: claims.clone(),
});
if provided_key != VALID_INTERNAL_KEY {
return Err(Report::new(MacroAuthorizationError::InvalidCredentials));
}
let Some(user_id) = claims.user_id else {
return Ok(None);
};
Ok(Some(UserContext {
user_id,
fusion_user_id: claims.fusion_user_id.unwrap_or_default(),
permissions: None,
organization_id: claims.organization_id,
}))
}
}
fn user_context(user_id: &str, organization_id: Option<i32>) -> UserContext {
UserContext {
user_id: user_id.to_string(),
fusion_user_id: "fusion-user-id".to_string(),
permissions: None,
organization_id,
}
}
fn bot_authentication(bot_scope: BotScope, acting_user_id: Option<&str>) -> BotAuthentication {
BotAuthentication {
bot_id: BOT_ID,
token_id: BOT_TOKEN_ID,
bot_scope,
team_id: (bot_scope == BotScope::Team).then_some(BOT_TEAM_ID),
acting_user: acting_user_id.map(|user_id| MacroUserAuthentication {
origin: crate::CredentialOrigin::Bot,
agent_id: None,
agent_via: None,
macro_user_id: MacroUserIdStr::try_from(user_id.to_owned())
.expect("valid bot acting user id"),
user_context: user_context(user_id, Some(42)),
}),
}
}
#[derive(Clone)]
struct TestState {
authorization: MacroAuthorizationState<FakeAuthorizationService>,
_unrelated_state: &'static str,
}
impl FromRef<TestState> for MacroAuthorizationState<FakeAuthorizationService> {
fn from_ref(state: &TestState) -> Self {
state.authorization.clone()
}
}
async fn required_handler(
extractor: MacroAuthorizationExtractor<FakeAuthorizationService, UserOrInternal>,
) -> Json<Value> {
let extractor = extractor.clone();
let acting_entity = extractor.acting_entity().to_string();
let authorization = &extractor.authorization;
let variant = match authorization.caller {
UserOrInternalCaller::User => "user",
UserOrInternalCaller::Internal => "internal",
};
Json(json!({
"authorization": {
"variant": variant,
"macro_user_id": authorization.user.macro_user_id.to_string(),
"user_context": authorization.user.user_context,
},
"acting_entity": acting_entity,
"macro_user_id": authorization.user.macro_user_id.to_string(),
"user_context": authorization.user.user_context,
"is_internal_access": authorization.caller == UserOrInternalCaller::Internal,
}))
}
async fn optional_handler(
extractor: OptionalMacroAuthorizationExtractor<FakeAuthorizationService, UserOrInternalService>,
) -> Json<Value> {
let extractor = extractor.clone();
let acting_entity = extractor
.acting_entity()
.map(|acting_entity| acting_entity.to_string());
let authorization = extractor
.authorization
.as_ref()
.map(user_or_internal_service_json);
let acting_user = extractor
.authorization
.as_ref()
.and_then(UserOrInternalServiceAuthorization::acting_user);
Json(json!({
"authorization": authorization,
"acting_entity": acting_entity,
"macro_user_id": acting_user.map(|user| user.macro_user_id.to_string()),
"user_context": acting_user.map(|user| user.user_context.clone()).unwrap_or_default(),
"is_internal_access": extractor
.authorization
.as_ref()
.is_some_and(UserOrInternalServiceAuthorization::is_internal),
}))
}
fn user_or_internal_service_json(authorization: &UserOrInternalServiceAuthorization) -> Value {
let variant = if authorization.is_internal() {
"internal"
} else {
"user"
};
let acting_user = authorization.acting_user();
json!({
"variant": variant,
"macro_user_id": acting_user.map(|user| user.macro_user_id.to_string()),
"user_context": acting_user.map(|user| &user.user_context),
})
}
async fn user_handler(
extractor: MacroAuthorizationExtractor<FakeAuthorizationService, UserOnly>,
) -> Json<Value> {
let extractor = extractor.clone();
let acting_entity = extractor.acting_entity().to_string();
Json(json!({
"acting_entity": acting_entity,
"macro_user_id": extractor.authorization.macro_user_id.to_string(),
"user_context": extractor.authorization.user_context,
"origin": format!("{:?}", extractor.authorization.origin),
}))
}
async fn internal_handler(
extractor: MacroAuthorizationExtractor<FakeAuthorizationService, InternalOnly>,
) -> Json<Value> {
let extractor = extractor.clone();
Json(json!({
"acting_entity": extractor.acting_entity().to_string(),
"authorized": true,
}))
}
async fn bot_handler(
extractor: MacroAuthorizationExtractor<FakeAuthorizationService, BotOnly>,
) -> Json<Value> {
let extractor = extractor.clone();
let acting_entity = extractor.acting_entity().to_string();
Json(bot_json(&extractor.authorization, &acting_entity))
}
async fn optional_bot_handler(
extractor: OptionalMacroAuthorizationExtractor<FakeAuthorizationService, BotOnly>,
) -> Json<Value> {
Json(
extractor
.authorization
.map(|bot| bot_json(&bot, &bot.bot_id.to_string()))
.unwrap_or(Value::Null),
)
}
async fn policy_handler<Policy>(
extractor: MacroAuthorizationExtractor<FakeAuthorizationService, Policy>,
) -> Json<Value>
where
Policy: AuthorizationPolicy,
{
Json(json!({ "acting_entity": extractor.acting_entity().to_string() }))
}
async fn optional_policy_handler<Policy>(
extractor: OptionalMacroAuthorizationExtractor<FakeAuthorizationService, Policy>,
) -> Json<Value>
where
Policy: AuthorizationPolicy,
{
Json(json!({
"acting_entity": extractor
.acting_entity()
.map(|acting_entity| acting_entity.to_string()),
}))
}
fn bot_json(bot: &BotAuthentication, acting_entity: &str) -> Value {
json!({
"acting_entity": acting_entity,
"bot_id": bot.bot_id.to_string(),
"token_id": bot.token_id.to_string(),
"bot_scope": bot.bot_scope.as_str(),
"team_id": bot.team_id.map(|team_id| team_id.to_string()),
"acting_user_id": bot
.acting_user
.as_ref()
.map(|user| user.macro_user_id.to_string()),
})
}
fn test_router() -> (Router, FakeAuthorizationService) {
let service = FakeAuthorizationService::default();
let state = TestState {
authorization: MacroAuthorizationState::new(Arc::new(service.clone())),
_unrelated_state: "composite state",
};
let router = Router::new()
.route("/required", get(required_handler))
.route("/optional", get(optional_handler))
.route("/user", get(user_handler))
.route("/internal", get(internal_handler))
.route("/bot", get(bot_handler))
.route("/optional-bot", get(optional_bot_handler))
.route(
"/required/user-or-internal",
get(policy_handler::<UserOrInternal>),
)
.route(
"/required/account-holder",
get(policy_handler::<AccountHolderOrInternal>),
)
.route(
"/required/user-or-internal-service",
get(policy_handler::<UserOrInternalService>),
)
.route("/required/acting-user", get(policy_handler::<ActingUser>))
.route("/required/user-only", get(policy_handler::<UserOnly>))
.route("/required/user-or-bot", get(policy_handler::<UserOrBot>))
.route("/required/bot-only", get(policy_handler::<BotOnly>))
.route(
"/required/internal-only",
get(policy_handler::<InternalOnly>),
)
.route(
"/required/any-principal",
get(policy_handler::<AnyPrincipal>),
)
.route(
"/optional/user-or-internal",
get(optional_policy_handler::<UserOrInternal>),
)
.route(
"/optional/user-or-internal-service",
get(optional_policy_handler::<UserOrInternalService>),
)
.route(
"/optional/acting-user",
get(optional_policy_handler::<ActingUser>),
)
.route(
"/optional/user-only",
get(optional_policy_handler::<UserOnly>),
)
.route(
"/optional/user-or-bot",
get(optional_policy_handler::<UserOrBot>),
)
.route(
"/optional/bot-only",
get(optional_policy_handler::<BotOnly>),
)
.route(
"/optional/internal-only",
get(optional_policy_handler::<InternalOnly>),
)
.route(
"/optional/any-principal",
get(optional_policy_handler::<AnyPrincipal>),
)
.with_state(state);
(router, service)
}
async fn send(router: &Router, request: Request<Body>) -> (StatusCode, Value) {
let response = router.clone().oneshot(request).await.unwrap();
let status = response.status();
let body = response.into_body().collect().await.unwrap().to_bytes();
let body = serde_json::from_slice(&body).expect("response should contain JSON");
(status, body)
}
fn request(path: &str) -> ::axum::http::request::Builder {
Request::get(path)
}
fn bot_request(path: &str, token: &str) -> ::axum::http::request::Builder {
request(path)
.header(BOT_TOKEN_HEADER, token)
.header(BOT_SCOPE_HEADER, BotScope::User.as_str())
}
fn user_api_key_request(path: &str, key: &str) -> ::axum::http::request::Builder {
request(path).header(USER_API_KEY_HEADER, key)
}
fn empty_body(request: ::axum::http::request::Builder) -> Request<Body> {
request.body(Body::empty()).unwrap()
}
fn assert_clone_without_service_clone<T: Clone>() {}
fn assert_display_and_error<T: std::fmt::Display + std::error::Error>() {}
#[test]
fn rejection_is_displayable_error_with_client_safe_message() {
assert_display_and_error::<MacroAuthorizationRejection>();
let rejection = MacroAuthorizationRejection {
status: StatusCode::INTERNAL_SERVER_ERROR,
message: Cow::Borrowed("client-safe message"),
};
assert_eq!(rejection.to_string(), "client-safe message");
}
#[tokio::test]
async fn rejection_response_preserves_status_and_cow_message() {
let cases = [
MacroAuthorizationRejection {
status: StatusCode::IM_A_TEAPOT,
message: Cow::Borrowed("borrowed message"),
},
MacroAuthorizationRejection {
status: StatusCode::FORBIDDEN,
message: Cow::Owned("owned message".to_string()),
},
];
for rejection in cases {
let expected_status = rejection.status;
let expected_body = format!(r#"{{"message":"{}"}}"#, rejection.message);
let response = rejection.into_response();
let status = response.status();
let body = response
.into_body()
.collect()
.await
.expect("rejection response body should be readable")
.to_bytes();
assert_eq!(status, expected_status);
assert_eq!(body.as_ref(), expected_body.as_bytes());
}
}
#[test]
fn state_and_extractors_are_clone_without_requiring_service_clone() {
struct NotClone;
assert_clone_without_service_clone::<MacroAuthorizationState<NotClone>>();
assert_clone_without_service_clone::<MacroAuthorizationExtractor<NotClone, AnyPrincipal>>();
assert_clone_without_service_clone::<OptionalMacroAuthorizationExtractor<NotClone, AnyPrincipal>>(
);
}
#[tokio::test]
async fn extractors_report_the_authenticating_entity() {
let (router, _service) = test_router();
let requests = [
(
empty_body(request("/required").header("authorization", "Bearer valid")),
Some(VALID_USER_ID.to_string()),
),
(
empty_body(bot_request("/required/acting-user", "bot-acting")),
Some(BOT_ID.to_string()),
),
(
empty_body(
request("/required")
.header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
.header(INTERNAL_MACRO_USER_ID_HEADER, STANDARD_INTERNAL_USER_ID),
),
Some("internal".to_string()),
),
(
empty_body(request("/optional").header("authorization", "Bearer optional")),
Some(OPTIONAL_USER_ID.to_string()),
),
(
empty_body(bot_request("/optional/any-principal", "bot-bare")),
Some(BOT_ID.to_string()),
),
(
empty_body(request("/optional").header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)),
Some("internal".to_string()),
),
(empty_body(request("/optional")), None),
(
empty_body(request("/user").header("authorization", "Bearer valid")),
Some(VALID_USER_ID.to_string()),
),
(
empty_body(bot_request("/bot", "bot-bare")),
Some(BOT_ID.to_string()),
),
(
empty_body(request("/internal").header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)),
Some("internal".to_string()),
),
];
for (request, expected) in requests {
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(
body["acting_entity"],
expected.map(Value::String).unwrap_or(Value::Null)
);
}
}
#[allow(deprecated)]
#[tokio::test]
async fn internal_accepts_standard_and_legacy_api_keys_without_identity_headers() {
let (router, service) = test_router();
for header in [INTERNAL_API_KEY_HEADER, LEGACY_DSS_INTERNAL_API_KEY_HEADER] {
let request = empty_body(request("/internal").header(header, VALID_INTERNAL_KEY));
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(
body,
json!({ "acting_entity": "internal", "authorized": true })
);
}
assert_eq!(
service.calls(),
[
AuthorizationCall::Internal {
provided_key: VALID_INTERNAL_KEY.to_string(),
claims: InternalIdentityClaims::default(),
},
AuthorizationCall::Internal {
provided_key: VALID_INTERNAL_KEY.to_string(),
claims: InternalIdentityClaims::default(),
},
]
);
}
#[tokio::test]
async fn internal_forwards_identity_headers_to_create_user_context() {
let (router, service) = test_router();
let request = empty_body(
request("/internal")
.header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
.header(INTERNAL_MACRO_USER_ID_HEADER, STANDARD_INTERNAL_USER_ID)
.header(INTERNAL_MACRO_ORGANIZATION_ID_HEADER, "42")
.header(INTERNAL_FUSIONAUTH_USER_ID_HEADER, "fusion-user"),
);
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(
body,
json!({ "acting_entity": "internal", "authorized": true })
);
assert_eq!(
service.calls(),
[AuthorizationCall::Internal {
provided_key: VALID_INTERNAL_KEY.to_string(),
claims: InternalIdentityClaims {
user_id: Some(STANDARD_INTERNAL_USER_ID.to_string()),
fusion_user_id: Some("fusion-user".to_string()),
organization_id: Some(42),
},
}]
);
}
#[tokio::test]
async fn internal_only_requires_credentials_and_forbids_valid_user_credentials() {
let (router, service) = test_router();
let (status, body) = send(&router, empty_body(request("/internal"))).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
let user_request = empty_body(request("/internal").header("authorization", "Bearer valid"));
let (status, body) = send(&router, user_request).await;
assert_eq!(status, StatusCode::FORBIDDEN);
assert_eq!(body, json!({ "message": "forbidden" }));
assert_eq!(
service.calls(),
[AuthorizationCall::Jwt("valid".to_string())]
);
}
#[tokio::test]
async fn internal_rejects_invalid_api_key() {
let (router, service) = test_router();
let request = empty_body(request("/internal").header(INTERNAL_API_KEY_HEADER, "invalid"));
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
assert_eq!(
service.calls(),
[AuthorizationCall::Internal {
provided_key: "invalid".to_string(),
claims: InternalIdentityClaims::default(),
}]
);
}
#[allow(deprecated)]
#[tokio::test]
async fn internal_standard_key_takes_precedence_over_legacy_key() {
let (router, service) = test_router();
let request = empty_body(
request("/internal")
.header(INTERNAL_API_KEY_HEADER, "invalid-standard-key")
.header(LEGACY_DSS_INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY),
);
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
assert_eq!(
service.calls(),
[AuthorizationCall::Internal {
provided_key: "invalid-standard-key".to_string(),
claims: InternalIdentityClaims::default(),
}]
);
}
#[tokio::test]
async fn user_accepts_query_bearer_and_cookie_credentials() {
let (router, service) = test_router();
let requests = [
(
empty_body(request("/user?macro-api-token=query")),
QUERY_USER_ID,
),
(
empty_body(request("/user").header("authorization", "Bearer bearer")),
BEARER_USER_ID,
),
(
empty_body(request("/user").header("cookie", format!("{ACCESS_TOKEN_COOKIE}=cookie"))),
COOKIE_USER_ID,
),
];
for (request, expected_user_id) in requests {
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["macro_user_id"], expected_user_id);
assert_eq!(body["user_context"]["user_id"], expected_user_id);
}
assert_eq!(
service.calls(),
[
AuthorizationCall::Jwt("query".to_string()),
AuthorizationCall::Jwt("bearer".to_string()),
AuthorizationCall::Jwt("cookie".to_string()),
]
);
}
#[tokio::test]
async fn user_rejects_missing_and_invalid_user_credentials() {
let (router, service) = test_router();
let (status, body) = send(&router, empty_body(request("/user"))).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
let (status, body) = send(
&router,
empty_body(request("/user").header("authorization", "Bearer expired")),
)
.await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "jwt expired" }));
assert_eq!(
service.calls(),
[AuthorizationCall::Jwt("expired".to_string())]
);
}
/// Records the level of every event emitted while installed.
#[derive(Clone, Default)]
struct EventLevels(Arc<Mutex<Vec<tracing::Level>>>);
impl<S: tracing::Subscriber> tracing_subscriber::Layer<S> for EventLevels {
fn on_event(
&self,
event: &tracing::Event<'_>,
_context: tracing_subscriber::layer::Context<'_, S>,
) {
self.0
.lock()
.expect("levels lock poisoned")
.push(*event.metadata().level());
}
}
#[tokio::test]
async fn authorization_failures_log_at_the_level_of_their_cause() {
use tracing::Level;
use tracing_subscriber::layer::SubscriberExt;
async fn check(request: Request<Body>, expected: Level) {
let (router, _service) = test_router();
let levels = EventLevels::default();
let _guard =
tracing::subscriber::set_default(tracing_subscriber::registry().with(levels.clone()));
send(&router, request).await;
assert_eq!(*levels.0.lock().expect("levels lock poisoned"), [expected]);
}
check(
empty_body(request("/user").header("authorization", "Bearer expired")),
Level::INFO,
)
.await;
check(
empty_body(request("/user").header("authorization", "Bearer invalid")),
Level::WARN,
)
.await;
check(
empty_body(request("/internal").header(INTERNAL_API_KEY_HEADER, "invalid")),
Level::WARN,
)
.await;
check(
empty_body(bot_request("/bot", "bot-forbidden")),
Level::WARN,
)
.await;
check(
empty_body(bot_request("/bot", "bot-unavailable")),
Level::ERROR,
)
.await;
check(
empty_body(user_api_key_request("/required", "mak_unavailable")),
Level::ERROR,
)
.await;
}
#[tokio::test]
async fn required_extracts_valid_bearer_and_preserves_organization() {
let (router, service) = test_router();
let request = empty_body(request("/required").header("authorization", "Bearer organization"));
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["authorization"]["variant"], "user");
assert_eq!(
body["authorization"]["macro_user_id"],
body["macro_user_id"]
);
assert_eq!(body["authorization"]["user_context"], body["user_context"]);
assert_eq!(body["macro_user_id"], VALID_USER_ID);
assert_eq!(body["user_context"]["organization_id"], 42);
assert_eq!(body["is_internal_access"], false);
assert_eq!(
service.calls(),
[AuthorizationCall::Jwt("organization".to_string())]
);
}
#[tokio::test]
async fn required_extracts_valid_cookie() {
let (router, service) = test_router();
let request =
empty_body(request("/required").header("cookie", format!("{ACCESS_TOKEN_COOKIE}=cookie")));
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["macro_user_id"], COOKIE_USER_ID);
assert_eq!(body["is_internal_access"], false);
assert_eq!(
service.calls(),
[AuthorizationCall::Jwt("cookie".to_string())]
);
}
#[tokio::test]
async fn query_token_takes_precedence_over_bearer_and_cookie() {
let (router, service) = test_router();
let request = empty_body(
request("/required?macro-api-token=query")
.header("authorization", "Bearer invalid")
.header("cookie", format!("{ACCESS_TOKEN_COOKIE}=invalid")),
);
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["macro_user_id"], QUERY_USER_ID);
assert_eq!(
service.calls(),
[AuthorizationCall::Jwt("query".to_string())]
);
}
#[tokio::test]
async fn bearer_token_takes_precedence_over_cookie() {
let (router, service) = test_router();
let request = empty_body(
request("/required")
.header("authorization", "Bearer bearer")
.header("cookie", format!("{ACCESS_TOKEN_COOKIE}=invalid")),
);
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["macro_user_id"], BEARER_USER_ID);
assert_eq!(
service.calls(),
[AuthorizationCall::Jwt("bearer".to_string())]
);
}
#[tokio::test]
async fn malformed_query_remains_an_explicit_user_credential() {
let (router, service) = test_router();
let malformed_query = "macro-api-token=query¯o-api-token=invalid";
let bearer_request = empty_body(
request(&format!("/required?{malformed_query}")).header("authorization", "Bearer bearer"),
);
let (status, body) = send(&router, bearer_request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["macro_user_id"], BEARER_USER_ID);
let cookie_request = empty_body(
request(&format!("/required?{malformed_query}"))
.header("cookie", format!("{ACCESS_TOKEN_COOKIE}=cookie")),
);
let (status, body) = send(&router, cookie_request).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
let (status, body) = send(
&router,
empty_body(request(&format!("/optional?{malformed_query}"))),
)
.await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
assert_eq!(
service.calls(),
[AuthorizationCall::Jwt("bearer".to_string())]
);
}
#[tokio::test]
async fn required_rejects_missing_credentials() {
let (router, service) = test_router();
let (status, body) = send(&router, empty_body(request("/required"))).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
assert!(service.calls().is_empty());
}
#[tokio::test]
async fn optional_returns_default_context_for_missing_credentials() {
let (router, service) = test_router();
let (status, body) = send(&router, empty_body(request("/optional"))).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["authorization"], Value::Null);
assert_eq!(body["macro_user_id"], Value::Null);
assert_eq!(body["user_context"]["user_id"], "");
assert_eq!(body["user_context"]["fusion_user_id"], "");
assert_eq!(body["user_context"]["organization_id"], Value::Null);
assert_eq!(body["user_context"]["permissions"], Value::Null);
assert_eq!(body["is_internal_access"], false);
assert!(service.calls().is_empty());
}
#[tokio::test]
async fn required_rejects_invalid_credentials() {
let (router, service) = test_router();
let request = empty_body(request("/required").header("authorization", "Bearer invalid"));
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
assert_eq!(
service.calls(),
[AuthorizationCall::Jwt("invalid".to_string())]
);
}
#[tokio::test]
async fn optional_rejects_supplied_invalid_credentials() {
let (router, service) = test_router();
let request = empty_body(request("/optional").header("authorization", "Bearer invalid"));
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
assert_eq!(
service.calls(),
[AuthorizationCall::Jwt("invalid".to_string())]
);
}
#[tokio::test]
async fn required_and_optional_reject_expired_credentials() {
let (router, service) = test_router();
for path in ["/required", "/optional"] {
let request = empty_body(request(path).header("authorization", "Bearer expired"));
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "jwt expired" }));
}
assert_eq!(
service.calls(),
[
AuthorizationCall::Jwt("expired".to_string()),
AuthorizationCall::Jwt("expired".to_string()),
]
);
}
#[tokio::test]
async fn required_rejects_malformed_user_id() {
let (router, service) = test_router();
let request = empty_body(request("/required").header("authorization", "Bearer malformed-user"));
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "invalid user id" }));
assert_eq!(
service.calls(),
[AuthorizationCall::Jwt("malformed-user".to_string())]
);
}
#[tokio::test]
async fn optional_rejects_empty_user_id_from_authorized_context() {
let (router, service) = test_router();
let request = empty_body(request("/optional").header("authorization", "Bearer empty-user"));
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "invalid user id" }));
assert_eq!(
service.calls(),
[AuthorizationCall::Jwt("empty-user".to_string())]
);
}
#[tokio::test]
async fn optional_returns_authenticated_output() {
let (router, service) = test_router();
let request = empty_body(request("/optional").header("authorization", "Bearer optional"));
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["authorization"]["variant"], "user");
assert_eq!(
body["authorization"]["macro_user_id"],
body["macro_user_id"]
);
assert_eq!(body["authorization"]["user_context"], body["user_context"]);
assert_eq!(body["macro_user_id"], OPTIONAL_USER_ID);
assert_eq!(body["user_context"]["user_id"], OPTIONAL_USER_ID);
assert_eq!(body["user_context"]["fusion_user_id"], "fusion-user-id");
assert_eq!(body["is_internal_access"], false);
assert_eq!(
service.calls(),
[AuthorizationCall::Jwt("optional".to_string())]
);
}
#[tokio::test]
async fn standard_internal_headers_authorize_matching_claims() {
let (router, service) = test_router();
let request = empty_body(
request("/required")
.header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
.header(INTERNAL_MACRO_USER_ID_HEADER, STANDARD_INTERNAL_USER_ID)
.header(INTERNAL_MACRO_ORGANIZATION_ID_HEADER, "42")
.header(INTERNAL_FUSIONAUTH_USER_ID_HEADER, "standard-fusion-id"),
);
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["authorization"]["variant"], "internal");
assert_eq!(
body["authorization"]["macro_user_id"],
body["macro_user_id"]
);
assert_eq!(body["authorization"]["user_context"], body["user_context"]);
assert_eq!(body["macro_user_id"], STANDARD_INTERNAL_USER_ID);
assert_eq!(body["user_context"]["fusion_user_id"], "standard-fusion-id");
assert_eq!(body["user_context"]["organization_id"], 42);
assert_eq!(body["is_internal_access"], true);
assert_eq!(
service.calls(),
[AuthorizationCall::Internal {
provided_key: VALID_INTERNAL_KEY.to_string(),
claims: InternalIdentityClaims {
user_id: Some(STANDARD_INTERNAL_USER_ID.to_string()),
fusion_user_id: Some("standard-fusion-id".to_string()),
organization_id: Some(42),
},
}]
);
}
#[allow(deprecated)]
#[tokio::test]
async fn legacy_dss_headers_authorize_matching_claims() {
let (router, service) = test_router();
let request = empty_body(
request("/required")
.header(LEGACY_DSS_INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
.header(
LEGACY_DSS_INTERNAL_MACRO_USER_ID_HEADER,
LEGACY_INTERNAL_USER_ID,
),
);
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["macro_user_id"], LEGACY_INTERNAL_USER_ID);
assert_eq!(body["user_context"]["fusion_user_id"], "");
assert_eq!(body["user_context"]["organization_id"], Value::Null);
assert_eq!(body["is_internal_access"], true);
assert_eq!(
service.calls(),
[AuthorizationCall::Internal {
provided_key: VALID_INTERNAL_KEY.to_string(),
claims: InternalIdentityClaims {
user_id: Some(LEGACY_INTERNAL_USER_ID.to_string()),
..InternalIdentityClaims::default()
},
}]
);
}
#[allow(deprecated)]
#[tokio::test]
async fn internal_identity_headers_are_not_mixed_between_conventions() {
let (router, service) = test_router();
let standard_request = empty_body(
request("/optional")
.header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
.header(
LEGACY_DSS_INTERNAL_MACRO_USER_ID_HEADER,
LEGACY_INTERNAL_USER_ID,
),
);
let (status, body) = send(&router, standard_request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["macro_user_id"], Value::Null);
assert_eq!(body["is_internal_access"], true);
let legacy_request = empty_body(
request("/optional")
.header(LEGACY_DSS_INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
.header(INTERNAL_MACRO_USER_ID_HEADER, STANDARD_INTERNAL_USER_ID)
.header(INTERNAL_MACRO_ORGANIZATION_ID_HEADER, "42")
.header(INTERNAL_FUSIONAUTH_USER_ID_HEADER, "standard-fusion-id"),
);
let (status, body) = send(&router, legacy_request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["macro_user_id"], Value::Null);
assert_eq!(body["is_internal_access"], true);
assert_eq!(
service.calls(),
[
AuthorizationCall::Internal {
provided_key: VALID_INTERNAL_KEY.to_string(),
claims: InternalIdentityClaims::default(),
},
AuthorizationCall::Internal {
provided_key: VALID_INTERNAL_KEY.to_string(),
claims: InternalIdentityClaims::default(),
},
]
);
}
#[allow(deprecated)]
#[tokio::test]
async fn standard_convention_takes_precedence_when_both_keys_are_present() {
let (router, service) = test_router();
let request = empty_body(
request("/required")
.header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
.header(LEGACY_DSS_INTERNAL_API_KEY_HEADER, "invalid-legacy-key")
.header(INTERNAL_MACRO_USER_ID_HEADER, STANDARD_INTERNAL_USER_ID)
.header(
LEGACY_DSS_INTERNAL_MACRO_USER_ID_HEADER,
LEGACY_INTERNAL_USER_ID,
),
);
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["macro_user_id"], STANDARD_INTERNAL_USER_ID);
assert_eq!(
service.calls(),
[AuthorizationCall::Internal {
provided_key: VALID_INTERNAL_KEY.to_string(),
claims: InternalIdentityClaims {
user_id: Some(STANDARD_INTERNAL_USER_ID.to_string()),
..InternalIdentityClaims::default()
},
}]
);
}
#[tokio::test]
async fn invalid_internal_key_rejects_without_cookie_fallback() {
let (router, service) = test_router();
let request = empty_body(
request("/required")
.header(INTERNAL_API_KEY_HEADER, "invalid-internal-key")
.header("cookie", format!("{ACCESS_TOKEN_COOKIE}=cookie")),
);
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
assert_eq!(
service.calls(),
[AuthorizationCall::Internal {
provided_key: "invalid-internal-key".to_string(),
claims: InternalIdentityClaims::default(),
}]
);
}
#[tokio::test]
async fn malformed_internal_key_rejects_without_cookie_fallback() {
let (router, service) = test_router();
let malformed_key = HeaderValue::from_bytes(b"\xff").unwrap();
let request = empty_body(
request("/required")
.header(INTERNAL_API_KEY_HEADER, malformed_key)
.header("cookie", format!("{ACCESS_TOKEN_COOKIE}=cookie")),
);
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
assert!(service.calls().is_empty());
}
#[tokio::test]
async fn identityless_internal_request_is_rejected_by_required_extractor() {
let (router, service) = test_router();
let request =
empty_body(request("/required").header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY));
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
assert_eq!(
service.calls(),
[AuthorizationCall::Internal {
provided_key: VALID_INTERNAL_KEY.to_string(),
claims: InternalIdentityClaims::default(),
}]
);
}
#[tokio::test]
async fn identityless_internal_request_is_preserved_by_optional_extractor() {
let (router, service) = test_router();
let request =
empty_body(request("/optional").header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY));
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["authorization"]["variant"], "internal");
assert_eq!(body["authorization"]["macro_user_id"], Value::Null);
assert_eq!(body["authorization"]["user_context"], Value::Null);
assert_eq!(body["macro_user_id"], Value::Null);
assert_eq!(body["user_context"]["user_id"], "");
assert_eq!(body["user_context"]["fusion_user_id"], "");
assert_eq!(body["user_context"]["organization_id"], Value::Null);
assert_eq!(body["user_context"]["permissions"], Value::Null);
assert_eq!(body["is_internal_access"], true);
assert_eq!(
service.calls(),
[AuthorizationCall::Internal {
provided_key: VALID_INTERNAL_KEY.to_string(),
claims: InternalIdentityClaims::default(),
}]
);
}
#[tokio::test]
async fn malformed_internal_organization_is_ignored() {
let (router, service) = test_router();
let request = empty_body(
request("/required")
.header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
.header(INTERNAL_MACRO_USER_ID_HEADER, STANDARD_INTERNAL_USER_ID)
.header(INTERNAL_MACRO_ORGANIZATION_ID_HEADER, "not-an-integer"),
);
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["macro_user_id"], STANDARD_INTERNAL_USER_ID);
assert_eq!(body["user_context"]["organization_id"], Value::Null);
assert_eq!(body["is_internal_access"], true);
assert_eq!(
service.calls(),
[AuthorizationCall::Internal {
provided_key: VALID_INTERNAL_KEY.to_string(),
claims: InternalIdentityClaims {
user_id: Some(STANDARD_INTERNAL_USER_ID.to_string()),
..InternalIdentityClaims::default()
},
}]
);
}
#[test]
fn bot_header_constants_use_the_resolved_names() {
assert_eq!(BOT_TOKEN_HEADER, "x-macro-bot-token");
assert_eq!(BOT_SCOPE_HEADER, "x-macro-bot-scope");
assert_eq!(
BOT_FOR_MACRO_USER_ID_HEADER,
"x-macro-bot-for-macro-user-id"
);
assert_eq!(
BOT_FOR_FUSIONAUTH_USER_ID_HEADER,
"x-macro-bot-for-fusionauth-user-id"
);
assert_eq!(
BOT_FOR_ORGANIZATION_ID_HEADER,
"x-macro-bot-for-organization-id"
);
}
#[test]
fn user_api_key_header_constant_uses_the_resolved_name() {
assert_eq!(USER_API_KEY_HEADER, "x-macro-user-api-key");
}
#[tokio::test]
async fn user_api_key_authenticates_as_the_user() {
let (router, service) = test_router();
for path in ["/user", "/required", "/required/user-only"] {
let (status, body) = send(
&router,
empty_body(user_api_key_request(path, VALID_USER_API_KEY)),
)
.await;
assert_eq!(status, StatusCode::OK, "path {path}");
assert_eq!(body["acting_entity"], API_KEY_USER_ID);
if path == "/user" {
assert_eq!(body["origin"], "UserApiKey");
}
if path != "/required/user-only" {
assert_eq!(body["macro_user_id"], API_KEY_USER_ID);
}
}
assert_eq!(
service.calls(),
[
AuthorizationCall::UserApiKey(VALID_USER_API_KEY.to_string()),
AuthorizationCall::UserApiKey(VALID_USER_API_KEY.to_string()),
AuthorizationCall::UserApiKey(VALID_USER_API_KEY.to_string()),
]
);
}
#[tokio::test]
async fn a_manager_credential_is_refused_only_where_the_account_holder_is_required() {
let (router, _) = test_router();
let (status, body) = send(
&router,
empty_body(user_api_key_request(
"/required/account-holder",
MANAGER_API_KEY,
)),
)
.await;
assert_eq!(status, StatusCode::FORBIDDEN);
assert_eq!(body, json!({ "message": "forbidden" }));
let (status, body) = send(
&router,
empty_body(user_api_key_request(
"/required/user-or-internal",
MANAGER_API_KEY,
)),
)
.await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["acting_entity"], API_KEY_USER_ID);
let (status, _) = send(
&router,
empty_body(user_api_key_request(
"/required/account-holder",
VALID_USER_API_KEY,
)),
)
.await;
assert_eq!(status, StatusCode::OK);
}
#[tokio::test]
async fn user_api_key_is_forbidden_for_bot_and_internal_only_policies() {
let (router, service) = test_router();
for path in ["/required/bot-only", "/required/internal-only"] {
let (status, body) = send(
&router,
empty_body(user_api_key_request(path, VALID_USER_API_KEY)),
)
.await;
assert_eq!(status, StatusCode::FORBIDDEN, "path {path}");
assert_eq!(body, json!({ "message": "forbidden" }));
}
assert_eq!(
service.calls(),
[
AuthorizationCall::UserApiKey(VALID_USER_API_KEY.to_string()),
AuthorizationCall::UserApiKey(VALID_USER_API_KEY.to_string()),
]
);
}
#[tokio::test]
async fn invalid_user_api_key_is_unauthorized() {
let (router, service) = test_router();
let (status, body) = send(
&router,
empty_body(user_api_key_request("/required", "mak_invalid")),
)
.await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
assert_eq!(
service.calls(),
[AuthorizationCall::UserApiKey("mak_invalid".to_string())]
);
}
#[tokio::test]
async fn unavailable_user_api_key_lookup_is_internal_server_error() {
let (router, service) = test_router();
let (status, body) = send(
&router,
empty_body(user_api_key_request("/required", "mak_unavailable")),
)
.await;
assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
assert_eq!(body, json!({ "message": "internal server error" }));
assert_eq!(
service.calls(),
[AuthorizationCall::UserApiKey("mak_unavailable".to_string())]
);
}
#[tokio::test]
async fn empty_user_api_key_header_is_unauthorized_without_a_service_call() {
let (router, service) = test_router();
let (status, body) = send(
&router,
empty_body(user_api_key_request("/required", " ")),
)
.await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
assert!(service.calls().is_empty());
}
#[tokio::test]
async fn user_api_key_combined_with_other_explicit_credentials_is_ambiguous() {
let (router, service) = test_router();
let requests = [
empty_body(
user_api_key_request("/required", VALID_USER_API_KEY)
.header("authorization", "Bearer valid"),
),
empty_body(
bot_request("/required", "bot-acting").header(USER_API_KEY_HEADER, VALID_USER_API_KEY),
),
empty_body(
request("/required")
.header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
.header(USER_API_KEY_HEADER, VALID_USER_API_KEY),
),
empty_body(
request("/required?macro-api-token=query")
.header(USER_API_KEY_HEADER, VALID_USER_API_KEY),
),
];
for request in requests {
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::BAD_REQUEST);
assert_eq!(body, json!({ "message": "ambiguous credentials" }));
}
assert!(service.calls().is_empty());
}
#[tokio::test]
async fn user_api_key_wins_over_ambient_cookies() {
let (router, service) = test_router();
let (status, body) = send(
&router,
empty_body(
user_api_key_request("/user", VALID_USER_API_KEY)
.header("cookie", format!("{ACCESS_TOKEN_COOKIE}=cookie")),
),
)
.await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["macro_user_id"], API_KEY_USER_ID);
assert_eq!(
service.calls(),
[AuthorizationCall::UserApiKey(
VALID_USER_API_KEY.to_string()
)]
);
}
#[tokio::test]
async fn optional_extractor_rejects_an_invalid_user_api_key() {
let (router, service) = test_router();
let (status, body) = send(
&router,
empty_body(user_api_key_request("/optional", "mak_invalid")),
)
.await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
assert_eq!(
service.calls(),
[AuthorizationCall::UserApiKey("mak_invalid".to_string())]
);
}
#[tokio::test]
async fn optional_extractor_accepts_a_valid_user_api_key() {
let (router, service) = test_router();
let (status, body) = send(
&router,
empty_body(user_api_key_request("/optional", VALID_USER_API_KEY)),
)
.await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["macro_user_id"], API_KEY_USER_ID);
assert_eq!(
service.calls(),
[AuthorizationCall::UserApiKey(
VALID_USER_API_KEY.to_string()
)]
);
}
#[tokio::test]
async fn acting_user_and_any_principal_accept_bot_with_verified_acting_user() {
let (router, service) = test_router();
for path in ["/required/acting-user", "/optional/any-principal"] {
let request = empty_body(
bot_request(path, "bot-acting")
.header(BOT_FOR_MACRO_USER_ID_HEADER, BOT_ACTING_USER_ID)
.header(BOT_FOR_FUSIONAUTH_USER_ID_HEADER, "fusion-claimed")
.header(BOT_FOR_ORGANIZATION_ID_HEADER, "42"),
);
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["acting_entity"], BOT_ID.to_string());
}
let claims = Some(BotActingUserClaims {
user_id: Some(BOT_ACTING_USER_ID.to_owned()),
fusion_user_id: Some("fusion-claimed".to_owned()),
organization_id: Some(42),
});
assert_eq!(
service.calls(),
[
AuthorizationCall::Bot {
token: "bot-acting".to_owned(),
bot_scope: BotScope::User,
claims: claims.clone(),
},
AuthorizationCall::Bot {
token: "bot-acting".to_owned(),
bot_scope: BotScope::User,
claims,
},
]
);
}
#[tokio::test]
async fn bare_bot_is_forbidden_by_no_bot_policies_and_accepted_by_bot_only() {
let (router, service) = test_router();
let (status, body) = send(&router, empty_body(bot_request("/required", "bot-bare"))).await;
assert_eq!(status, StatusCode::FORBIDDEN);
assert_eq!(body, json!({ "message": "forbidden" }));
let (status, body) = send(&router, empty_body(bot_request("/optional", "bot-bare"))).await;
assert_eq!(status, StatusCode::FORBIDDEN);
assert_eq!(body, json!({ "message": "forbidden" }));
for path in ["/bot", "/optional-bot"] {
let (status, body) = send(&router, empty_body(bot_request(path, "bot-bare"))).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["bot_id"], BOT_ID.to_string());
assert_eq!(body["token_id"], BOT_TOKEN_ID.to_string());
assert_eq!(body["bot_scope"], BotScope::User.as_str());
assert_eq!(body["team_id"], Value::Null);
assert_eq!(body["acting_user_id"], Value::Null);
}
assert_eq!(
service.calls(),
vec![
AuthorizationCall::Bot {
token: "bot-bare".to_owned(),
bot_scope: BotScope::User,
claims: None,
};
4
]
);
}
#[tokio::test]
async fn bot_scope_is_required_and_must_be_user_or_team() {
let (router, service) = test_router();
for request in [
request("/bot").header(BOT_TOKEN_HEADER, "bot-bare"),
request("/bot")
.header(BOT_TOKEN_HEADER, "bot-bare")
.header(BOT_SCOPE_HEADER, ""),
request("/bot")
.header(BOT_TOKEN_HEADER, "bot-bare")
.header(BOT_SCOPE_HEADER, "organization"),
] {
let (status, body) = send(&router, empty_body(request)).await;
assert_eq!(status, StatusCode::BAD_REQUEST);
assert_eq!(body, json!({ "message": "invalid bot scope" }));
}
let malformed_scope = HeaderValue::from_bytes(b"\xff").unwrap();
let request = empty_body(
request("/bot")
.header(BOT_TOKEN_HEADER, "bot-bare")
.header(BOT_SCOPE_HEADER, malformed_scope),
);
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::BAD_REQUEST);
assert_eq!(body, json!({ "message": "invalid bot scope" }));
assert!(service.calls().is_empty());
}
#[tokio::test]
async fn team_bot_scope_is_forwarded_and_returned() {
let (router, service) = test_router();
let request = empty_body(
request("/bot")
.header(BOT_TOKEN_HEADER, "bot-bare")
.header(BOT_SCOPE_HEADER, BotScope::Team.as_str()),
);
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body["bot_scope"], BotScope::Team.as_str());
assert_eq!(body["team_id"], BOT_TEAM_ID.to_string());
assert_eq!(
service.calls(),
[AuthorizationCall::Bot {
token: "bot-bare".to_owned(),
bot_scope: BotScope::Team,
claims: None,
}]
);
}
#[tokio::test]
async fn missing_malformed_and_blank_bot_tokens_follow_required_and_optional_contracts() {
let (router, service) = test_router();
let (status, body) = send(&router, empty_body(request("/bot"))).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
let (status, body) = send(&router, empty_body(request("/optional-bot"))).await;
assert_eq!(status, StatusCode::OK);
assert_eq!(body, Value::Null);
for path in ["/required", "/optional", "/bot", "/optional-bot"] {
let malformed_token = HeaderValue::from_bytes(b"\xff").unwrap();
let (status, body) = send(
&router,
empty_body(
request(path)
.header(BOT_TOKEN_HEADER, malformed_token)
.header(BOT_SCOPE_HEADER, BotScope::User.as_str()),
),
)
.await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
for blank_token in ["", " "] {
let (status, body) = send(&router, empty_body(bot_request(path, blank_token))).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
}
}
assert!(service.calls().is_empty());
}
#[tokio::test]
async fn bot_authorization_errors_have_generic_status_specific_responses() {
let (router, service) = test_router();
for token in ["bot-invalid", "bot-expired", "bot-revoked"] {
for path in ["/required", "/optional", "/bot", "/optional-bot"] {
let (status, body) = send(&router, empty_body(bot_request(path, token))).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
}
}
for path in ["/required", "/optional", "/bot", "/optional-bot"] {
for token in ["bot-forbidden", "bot-scope-forbidden"] {
let (status, body) = send(&router, empty_body(bot_request(path, token))).await;
assert_eq!(status, StatusCode::FORBIDDEN);
assert_eq!(body, json!({ "message": "forbidden" }));
}
let (status, body) = send(&router, empty_body(bot_request(path, "bot-unavailable"))).await;
assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
assert_eq!(body, json!({ "message": "internal server error" }));
}
assert_eq!(service.calls().len(), 24);
assert!(
service
.calls()
.iter()
.all(|call| matches!(call, AuthorizationCall::Bot { .. }))
);
}
#[tokio::test]
async fn bot_claim_headers_are_strictly_parsed_before_authorization() {
let (router, service) = test_router();
let malformed_header = HeaderValue::from_bytes(b"\xff").unwrap();
for header in [
BOT_FOR_MACRO_USER_ID_HEADER,
BOT_FOR_FUSIONAUTH_USER_ID_HEADER,
BOT_FOR_ORGANIZATION_ID_HEADER,
] {
let (status, body) = send(
&router,
empty_body(bot_request("/bot", "bot-acting").header(header, malformed_header.clone())),
)
.await;
assert_eq!(status, StatusCode::BAD_REQUEST);
assert_eq!(body, json!({ "message": "invalid bot claims" }));
}
for organization_id in ["not-an-integer", "", "2147483648"] {
let (status, body) = send(
&router,
empty_body(
bot_request("/bot", "bot-acting")
.header(BOT_FOR_ORGANIZATION_ID_HEADER, organization_id),
),
)
.await;
assert_eq!(status, StatusCode::BAD_REQUEST);
assert_eq!(body, json!({ "message": "invalid bot claims" }));
}
assert!(service.calls().is_empty());
}
#[tokio::test]
async fn bot_claims_without_a_user_identifier_reach_the_authorizer() {
let (router, service) = test_router();
let request = empty_body(
bot_request("/bot", "bot-forbidden").header(BOT_FOR_ORGANIZATION_ID_HEADER, "42"),
);
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::FORBIDDEN);
assert_eq!(body, json!({ "message": "forbidden" }));
assert_eq!(
service.calls(),
[AuthorizationCall::Bot {
token: "bot-forbidden".to_owned(),
bot_scope: BotScope::User,
claims: Some(BotActingUserClaims {
user_id: None,
fusion_user_id: None,
organization_id: Some(42),
}),
}]
);
}
#[tokio::test]
async fn every_combination_of_multiple_explicit_credential_types_is_ambiguous() {
for path in [
"/required/user-or-internal",
"/required/user-or-internal-service",
"/required/acting-user",
"/required/user-only",
"/required/user-or-bot",
"/required/bot-only",
"/required/internal-only",
"/required/any-principal",
"/optional/user-or-internal",
"/optional/user-or-internal-service",
"/optional/acting-user",
"/optional/user-only",
"/optional/user-or-bot",
"/optional/bot-only",
"/optional/internal-only",
"/optional/any-principal",
] {
let (router, service) = test_router();
let path_with_query = format!("{path}?macro-api-token=query");
let requests = [
empty_body(
request(path)
.header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
.header("authorization", "Bearer valid"),
),
empty_body(bot_request(path, "bot-acting").header("authorization", "Bearer valid")),
empty_body(
request(path)
.header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
.header(BOT_TOKEN_HEADER, "bot-acting")
.header(BOT_SCOPE_HEADER, BotScope::User.as_str()),
),
empty_body(
request(path)
.header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
.header(BOT_TOKEN_HEADER, "bot-acting")
.header(BOT_SCOPE_HEADER, BotScope::User.as_str())
.header("authorization", "Bearer valid"),
),
empty_body(
request(&path_with_query).header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY),
),
empty_body(bot_request(&path_with_query, "bot-acting")),
];
for request in requests {
let (status, body) = send(&router, request).await;
assert_eq!(status, StatusCode::BAD_REQUEST);
assert_eq!(body, json!({ "message": "ambiguous credentials" }));
}
assert!(service.calls().is_empty());
}
}
#[tokio::test]
async fn explicit_credentials_win_over_ambient_cookies_without_fallback() {
let (router, service) = test_router();
let valid_bot_request = empty_body(
bot_request("/required", "bot-acting")
.header("cookie", format!("{ACCESS_TOKEN_COOKIE}=cookie")),
);
let (status, body) = send(&router, valid_bot_request).await;
assert_eq!(status, StatusCode::FORBIDDEN);
assert_eq!(body, json!({ "message": "forbidden" }));
let invalid_bot_request = empty_body(
bot_request("/required", "bot-invalid")
.header("cookie", format!("{ACCESS_TOKEN_COOKIE}=cookie")),
);
let (status, body) = send(&router, invalid_bot_request).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
let malformed_user_request = empty_body(
request("/required")
.header("authorization", "Basic deliberate-but-malformed")
.header("cookie", format!("{ACCESS_TOKEN_COOKIE}=cookie")),
);
let (status, body) = send(&router, malformed_user_request).await;
assert_eq!(status, StatusCode::UNAUTHORIZED);
assert_eq!(body, json!({ "message": "unauthorized" }));
assert_eq!(
service.calls(),
[
AuthorizationCall::Bot {
token: "bot-acting".to_owned(),
bot_scope: BotScope::User,
claims: None,
},
AuthorizationCall::Bot {
token: "bot-invalid".to_owned(),
bot_scope: BotScope::User,
claims: None,
},
]
);
}
#[derive(Clone, Copy, Debug)]
enum PrincipalCredentials {
User,
BotWithActingUser,
BotWithoutActingUser,
InternalWithActingUser,
InternalWithoutActingUser,
Anonymous,
}
const PRINCIPAL_CREDENTIALS: [PrincipalCredentials; 6] = [
PrincipalCredentials::User,
PrincipalCredentials::BotWithActingUser,
PrincipalCredentials::BotWithoutActingUser,
PrincipalCredentials::InternalWithActingUser,
PrincipalCredentials::InternalWithoutActingUser,
PrincipalCredentials::Anonymous,
];
fn principal_request(path: &str, credentials: PrincipalCredentials) -> Request<Body> {
let request = match credentials {
PrincipalCredentials::User => request(path).header("authorization", "Bearer valid"),
PrincipalCredentials::BotWithActingUser => bot_request(path, "bot-acting"),
PrincipalCredentials::BotWithoutActingUser => bot_request(path, "bot-bare"),
PrincipalCredentials::InternalWithActingUser => request(path)
.header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
.header(INTERNAL_MACRO_USER_ID_HEADER, STANDARD_INTERNAL_USER_ID),
PrincipalCredentials::InternalWithoutActingUser => {
request(path).header(INTERNAL_API_KEY_HEADER, VALID_INTERNAL_KEY)
}
PrincipalCredentials::Anonymous => request(path),
};
empty_body(request)
}
#[tokio::test]
async fn required_policy_matrix_enforces_principal_and_acting_user_contracts() {
let policies = [
(
"/required/user-or-internal",
[
StatusCode::OK,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::OK,
StatusCode::UNAUTHORIZED,
StatusCode::UNAUTHORIZED,
],
),
(
"/required/user-or-internal-service",
[
StatusCode::OK,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::OK,
StatusCode::OK,
StatusCode::UNAUTHORIZED,
],
),
(
"/required/acting-user",
[
StatusCode::OK,
StatusCode::OK,
StatusCode::UNAUTHORIZED,
StatusCode::OK,
StatusCode::UNAUTHORIZED,
StatusCode::UNAUTHORIZED,
],
),
(
"/required/user-only",
[
StatusCode::OK,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::UNAUTHORIZED,
],
),
(
"/required/user-or-bot",
[
StatusCode::OK,
StatusCode::OK,
StatusCode::OK,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::UNAUTHORIZED,
],
),
(
"/required/bot-only",
[
StatusCode::FORBIDDEN,
StatusCode::OK,
StatusCode::OK,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::UNAUTHORIZED,
],
),
(
"/required/internal-only",
[
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::OK,
StatusCode::OK,
StatusCode::UNAUTHORIZED,
],
),
(
"/required/any-principal",
[
StatusCode::OK,
StatusCode::OK,
StatusCode::OK,
StatusCode::OK,
StatusCode::OK,
StatusCode::UNAUTHORIZED,
],
),
];
assert_policy_matrix(policies).await;
}
#[tokio::test]
async fn optional_policy_matrix_enforces_credentials_but_allows_anonymous_requests() {
let policies = [
(
"/optional/user-or-internal",
[
StatusCode::OK,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::OK,
StatusCode::UNAUTHORIZED,
StatusCode::OK,
],
),
(
"/optional/user-or-internal-service",
[
StatusCode::OK,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::OK,
StatusCode::OK,
StatusCode::OK,
],
),
(
"/optional/acting-user",
[
StatusCode::OK,
StatusCode::OK,
StatusCode::UNAUTHORIZED,
StatusCode::OK,
StatusCode::UNAUTHORIZED,
StatusCode::OK,
],
),
(
"/optional/user-only",
[
StatusCode::OK,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::OK,
],
),
(
"/optional/user-or-bot",
[
StatusCode::OK,
StatusCode::OK,
StatusCode::OK,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::OK,
],
),
(
"/optional/bot-only",
[
StatusCode::FORBIDDEN,
StatusCode::OK,
StatusCode::OK,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::OK,
],
),
(
"/optional/internal-only",
[
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::FORBIDDEN,
StatusCode::OK,
StatusCode::OK,
StatusCode::OK,
],
),
(
"/optional/any-principal",
[
StatusCode::OK,
StatusCode::OK,
StatusCode::OK,
StatusCode::OK,
StatusCode::OK,
StatusCode::OK,
],
),
];
assert_policy_matrix(policies).await;
}
async fn assert_policy_matrix<const N: usize>(policies: [(&str, [StatusCode; 6]); N]) {
let (router, _service) = test_router();
for (path, expected_statuses) in policies {
for (credentials, expected_status) in
PRINCIPAL_CREDENTIALS.into_iter().zip(expected_statuses)
{
let (status, body) = send(&router, principal_request(path, credentials)).await;
assert_eq!(
status, expected_status,
"unexpected status for {path} with {credentials:?}: {body}"
);
match expected_status {
StatusCode::UNAUTHORIZED => {
assert_eq!(body, json!({ "message": "unauthorized" }));
}
StatusCode::FORBIDDEN => {
assert_eq!(body, json!({ "message": "forbidden" }));
}
StatusCode::OK => {}
status => panic!("unexpected matrix status {status}"),
}
}
}
}
#[test]
fn policies_report_typed_acting_entity_variants_with_display_parity() {
let user = macro_user_authentication(VALID_USER_ID);
let internal_user = macro_user_authentication(STANDARD_INTERNAL_USER_ID);
let bot = bot_authentication(BotScope::User, Some(BOT_ACTING_USER_ID));
let direct_user = MacroAuthorization::User(user.clone());
let user_or_internal = UserOrInternal::narrow(direct_user.clone()).unwrap();
assert_eq!(
UserOrInternal::acting_entity(&user_or_internal),
UserOrInternalEntity::User(VALID_USER_ID)
);
assert_display_parity::<UserOrInternal>(direct_user);
let internal = MacroAuthorization::Internal(Some(internal_user.clone()));
let user_or_internal = UserOrInternal::narrow(internal.clone()).unwrap();
assert_eq!(
UserOrInternal::acting_entity(&user_or_internal),
UserOrInternalEntity::Internal
);
assert_display_parity::<UserOrInternal>(internal.clone());
let internal_service = UserOrInternalService::narrow(internal.clone()).unwrap();
assert!(internal_service.is_internal());
assert_eq!(
internal_service
.acting_user()
.map(|user| user.macro_user_id.as_ref()),
Some(STANDARD_INTERNAL_USER_ID)
);
assert_eq!(
UserOrInternalService::acting_entity(&internal_service),
UserOrInternalEntity::Internal
);
assert_display_parity::<UserOrInternalService>(internal.clone());
let bot_principal = MacroAuthorization::Bot(bot.clone());
let acting_user = ActingUser::narrow(bot_principal.clone()).unwrap();
assert!(matches!(acting_user.principal, MacroAuthorization::Bot(_)));
assert_eq!(acting_user.user.macro_user_id.as_ref(), BOT_ACTING_USER_ID);
assert_eq!(
ActingUser::acting_entity(&acting_user),
ActingEntity::Bot(BOT_ID)
);
assert_display_parity::<ActingUser>(bot_principal.clone());
let user_only = UserOnly::narrow(MacroAuthorization::User(user.clone())).unwrap();
assert_eq!(UserOnly::acting_entity(&user_only), VALID_USER_ID);
assert_display_parity::<UserOnly>(MacroAuthorization::User(user));
let bot_only = BotOnly::narrow(bot_principal.clone()).unwrap();
assert_eq!(BotOnly::acting_entity(&bot_only), BOT_ID);
assert_display_parity::<BotOnly>(bot_principal.clone());
let internal_only = InternalOnly::narrow(internal.clone()).unwrap();
assert_eq!(
internal_only
.acting_user
.as_ref()
.map(|user| user.macro_user_id.as_ref()),
Some(STANDARD_INTERNAL_USER_ID)
);
assert_eq!(InternalOnly::acting_entity(&internal_only), InternalEntity);
assert_display_parity::<InternalOnly>(internal.clone());
let any_principal = AnyPrincipal::narrow(bot_principal.clone()).unwrap();
assert_eq!(
AnyPrincipal::acting_entity(&any_principal),
ActingEntity::Bot(BOT_ID)
);
assert_display_parity::<AnyPrincipal>(bot_principal);
}
fn macro_user_authentication(user_id: &str) -> MacroUserAuthentication {
MacroUserAuthentication {
origin: crate::CredentialOrigin::Session,
agent_id: None,
agent_via: None,
macro_user_id: MacroUserIdStr::try_from(user_id.to_owned()).expect("valid Macro user ID"),
user_context: user_context(user_id, None),
}
}
fn assert_display_parity<Policy: AuthorizationPolicy>(authorization: MacroAuthorization) {
let expected = ActingEntity::from(&authorization).to_string();
let output = Policy::narrow(authorization).expect("principal should satisfy policy");
assert_eq!(Policy::acting_entity(&output).to_string(), expected);
}