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
#[cfg(test)]
mod agent_test;
#[cfg(test)]
mod fusionauth_access_token_test;
use std::{
sync::OnceLock,
time::{Duration, SystemTime, UNIX_EPOCH},
};
use anyhow::Context;
use jsonwebtoken::{Algorithm, DecodingKey, Validation, decode};
use macro_env::Environment;
use macro_env_var::{VarNameErr, env_var};
use macro_user_id::{cowlike::CowLike, lowercased::Lowercase, user_id::MacroUserId};
use remote_env_var::{LocalOrRemoteSecret, SecretManager};
use thiserror::Error;
use crate::{error::MacroAuthError, macro_api_token::MacroApiToken};
#[derive(Clone)]
pub struct JwtValidationArgs {
audience: Audience,
issuer: Issuer,
jwt_secret: LocalOrRemoteSecret<JwtSecretKey>,
macro_api_token_issuer: MacroApiTokenIssuer,
macro_api_token_public_key: LocalOrRemoteSecret<MacroApiTokenPublicKey>,
}
#[derive(Debug, Error)]
pub enum JwtValidationErr<T> {
#[error("Var error: {0}")]
VarErr(#[from] VarNameErr),
#[error("Remote Err: {0}")]
RemoteErr(T),
}
impl JwtValidationArgs {
/// create a new instance of self by reading the required data from the environment
pub async fn new_with_secret_manager<T: SecretManager>(
env: Environment,
secret_manager: &T,
) -> Result<Self, JwtValidationErr<T::Err>> {
let Env {
audience,
issuer,
macro_api_token_issuer,
} = Env::new()?;
let (jwt_secret, macro_api_token_public_key) = tokio::try_join!(
secret_manager.get_maybe_secret_value(env, JwtSecretKey::new()?),
secret_manager.get_maybe_secret_value(env, MacroApiTokenPublicKey::new()?)
)
.map_err(JwtValidationErr::RemoteErr)?;
Ok(Self {
audience,
issuer,
jwt_secret,
macro_api_token_issuer,
macro_api_token_public_key,
})
}
/// Build an isolated Macro JWT verifier with fixture keys.
#[cfg(feature = "testing")]
pub fn testing_macro_token(issuer: &'static str, public_key: &'static str) -> Self {
Self {
macro_api_token_issuer: MacroApiTokenIssuer::Comptime(issuer),
macro_api_token_public_key: LocalOrRemoteSecret::Local(
MacroApiTokenPublicKey::Comptime(public_key),
),
..Self::new_testing()
}
}
#[cfg(feature = "testing")]
#[allow(dead_code)]
/// create a new instance of Self with all empty values
pub fn new_testing() -> Self {
Self {
audience: Audience::Comptime(""),
issuer: Issuer::Comptime(""),
jwt_secret: LocalOrRemoteSecret::Local(JwtSecretKey::Comptime("")),
macro_api_token_issuer: MacroApiTokenIssuer::Comptime(""),
macro_api_token_public_key: LocalOrRemoteSecret::Local(
MacroApiTokenPublicKey::Comptime(""),
),
}
}
}
env_var! {
#[derive(Clone)]
struct JwtSecretKey;
}
env_var! {
#[derive(Clone)]
struct MacroApiTokenPublicKey;
}
env_var! {
#[derive(Debug, Clone)]
pub struct Env {
#[derive(Debug, Clone)]
Audience,
#[derive(Debug, Clone)]
Issuer,
#[derive(Debug, Clone)]
MacroApiTokenIssuer
}
}
#[derive(serde::Serialize, serde::Deserialize, Eq, PartialEq, Debug, Clone)]
pub struct MacroAccessToken {
/// The audience of the token
/// This is the fuisionauth application id
pub aud: String,
/// The expiration time of the token
pub exp: usize,
/// The tenant id of the token
pub tid: String,
/// The issuer of the token
/// This is the fuisionauth domain
pub iss: String,
/// The email of the user
pub email: String,
/// The fusionauth id of the user
pub fusion_user_id: String,
/// The macro user id of the user
pub macro_user_id: String,
/// The organization id for the user if they belong to one
pub macro_organization_id: Option<i32>,
/// The root macro id. If provided, if None, use fusion_user_id
pub root_macro_id: Option<String>,
}
#[derive(serde::Serialize, serde::Deserialize, Eq, PartialEq, Debug, Clone)]
pub enum JwtToken {
MacroAccessToken(MacroAccessToken),
MacroApiToken(MacroApiToken),
}
pub fn validate_macro_access_token(
macro_access_token: &str,
args: &JwtValidationArgs,
) -> Result<MacroAccessToken, MacroAuthError> {
validate_macro_access_token_inner(
macro_access_token,
&args.jwt_secret,
&args.audience,
&args.issuer,
)
}
/// Decodes a macro access token without validating expiry and the macro user id.
/// This is useful for extracting the user ID from an expired token
/// (e.g., for advisory lock acquisition during token refresh).
/// The signature is still validated.
pub fn decode_macro_access_token_allow_expired(
macro_access_token: &str,
args: &JwtValidationArgs,
) -> Result<MacroUserId<Lowercase<'static>>, MacroAuthError> {
let mut validation = Validation::new(Algorithm::HS256);
validation.set_audience(&[args.audience.as_ref()]);
validation.set_issuer(&[args.issuer.as_ref()]);
validation.validate_exp = false;
let decoded_jwt: MacroAccessToken = decode::<MacroAccessToken>(
macro_access_token,
&DecodingKey::from_secret(args.jwt_secret.as_ref().as_bytes()),
&validation,
)
.map_err(|e| MacroAuthError::JwtValidationFailed {
details: e.to_string(),
})?
.claims;
let macro_user_id = MacroUserId::parse_from_str(&decoded_jwt.macro_user_id)
.map_err(|_| MacroAuthError::from(anyhow::anyhow!("invalid macro user id in token")))?
.lowercase()
.into_owned();
Ok(macro_user_id)
}
#[derive(serde::Deserialize)]
struct FusionAuthAccessToken {
iat: u64,
}
/// Checks that a token was issued by FusionAuth for this application (signature, audience and
/// issuer) without checking expiry or the Macro claims, and returns when it was issued.
/// FusionAuth still issues an access token when the JWT populate lambda fails, just without
/// those claims.
pub fn validate_fusionauth_access_token_allow_expired(
access_token: &str,
args: &JwtValidationArgs,
) -> Result<SystemTime, MacroAuthError> {
let mut validation = Validation::new(Algorithm::HS256);
validation.set_audience(&[args.audience.as_ref()]);
validation.set_issuer(&[args.issuer.as_ref()]);
validation.set_required_spec_claims(&["exp", "aud", "iss"]);
validation.validate_exp = false;
let token = decode::<FusionAuthAccessToken>(
access_token,
&DecodingKey::from_secret(args.jwt_secret.as_ref().as_bytes()),
&validation,
)
.map_err(|e| MacroAuthError::JwtValidationFailed {
details: e.to_string(),
})?
.claims;
UNIX_EPOCH
.checked_add(Duration::from_secs(token.iat))
.ok_or_else(|| MacroAuthError::JwtValidationFailed {
details: "iat is out of range".to_string(),
})
}
fn validate_macro_access_token_inner(
macro_access_token: &str,
jwt_secret: &LocalOrRemoteSecret<JwtSecretKey>,
audience: &Audience,
issuer: &Issuer,
) -> Result<MacroAccessToken, MacroAuthError> {
// Verify and decode the JWT
let mut validation = Validation::new(Algorithm::HS256);
validation.set_audience(&[audience.as_ref()]);
validation.set_issuer(&[issuer.as_ref()]);
// Attempt to decode the token.
let decoded_jwt: MacroAccessToken = match decode::<MacroAccessToken>(
macro_access_token,
&DecodingKey::from_secret(jwt_secret.as_ref().as_bytes()),
&validation,
) {
Ok(decoded) => decoded.claims,
Err(e) => match e.kind() {
jsonwebtoken::errors::ErrorKind::ExpiredSignature => {
return Err(MacroAuthError::JwtExpired);
}
_ => {
return Err(MacroAuthError::JwtValidationFailed {
details: e.to_string(),
});
}
},
};
Ok(decoded_jwt)
}
static DECODING_KEY: OnceLock<Result<DecodingKey, MacroAuthError>> = OnceLock::new();
#[tracing::instrument(skip_all)]
fn validate_macro_api_token(
macro_api_token: &str,
public_key: &LocalOrRemoteSecret<MacroApiTokenPublicKey>,
issuer: &MacroApiTokenIssuer,
) -> Result<MacroApiToken, MacroAuthError> {
// Verify and decode the JWT
let mut validation = Validation::new(Algorithm::RS256);
validation.set_issuer(&[issuer.as_ref()]);
let init = move || {
Ok(DecodingKey::from_rsa_pem(public_key.as_ref().as_bytes())
.context("unable to decode key")?)
};
let decoding_key = DECODING_KEY
.get_or_init(init)
.as_ref()
.context("cached key failed to decode")?;
// Attempt to decode the token.
let decoded_jwt: MacroApiToken =
match decode::<MacroApiToken>(macro_api_token, decoding_key, &validation) {
Ok(decoded) => decoded.claims,
Err(e) => match e.kind() {
jsonwebtoken::errors::ErrorKind::ExpiredSignature => {
return Err(MacroAuthError::JwtExpired);
}
_ => {
return Err(MacroAuthError::JwtValidationFailed {
details: e.to_string(),
});
}
},
};
Ok(decoded_jwt)
}
/// Takes in a token (either a macro-access-token or a macro-api-token) and returns the decoded JWT token.
pub fn handler(
jwt_validation_args: &JwtValidationArgs,
access_token: &str,
) -> Result<JwtToken, MacroAuthError> {
let token = jsonwebtoken::decode_header(access_token).context("unable to decode token")?;
let kid = token.kid.context("expected kid")?;
if kid == "macro" {
let decoded_jwt = match validate_macro_api_token(
access_token,
&jwt_validation_args.macro_api_token_public_key,
&jwt_validation_args.macro_api_token_issuer,
) {
Ok(decoded_jwt) => decoded_jwt,
Err(e) => {
match e {
MacroAuthError::JwtExpired => {}
_ => {
tracing::error!(error=?e, "unable to decode jwt");
}
}
return Err(e);
}
};
Ok(JwtToken::MacroApiToken(decoded_jwt))
} else {
let decoded_jwt = match validate_macro_access_token_inner(
access_token,
&jwt_validation_args.jwt_secret,
&jwt_validation_args.audience,
&jwt_validation_args.issuer,
) {
Ok(decoded_jwt) => decoded_jwt,
Err(e) => {
match e {
MacroAuthError::JwtExpired => {}
_ => {
tracing::error!(error=?e, "unable to decode jwt");
}
}
return Err(e);
}
};
Ok(JwtToken::MacroAccessToken(decoded_jwt))
}
}
#[cfg(test)]
mod tests {
use std::time::{SystemTime, UNIX_EPOCH};
use anyhow::Context;
use super::*;
fn create_test_jwt(
audience: &str,
issuer: &str,
email: &str,
jwt_secret: &str,
time: Option<usize>,
) -> String {
// Get current timestamp
let now = time.unwrap_or_else(|| {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs() as usize
});
let claims = MacroAccessToken {
aud: audience.to_string(),
exp: now + 3600, // Token expires in 1 hour
iss: issuer.to_string(),
tid: "tenant_id".to_string(),
email: email.to_string(),
fusion_user_id: "fusion_testing".to_string(),
macro_user_id: "macro|testing".to_string(),
macro_organization_id: None,
root_macro_id: None,
};
let mut header = jsonwebtoken::Header::new(jsonwebtoken::Algorithm::HS256);
header.kid = Some("fromFusionauth".to_string());
jsonwebtoken::encode(
&header,
&claims,
&jsonwebtoken::EncodingKey::from_secret(jwt_secret.as_ref()),
)
.expect("Failed to create test JWT")
}
pub const PRIVATE_KEY: &str = r#"-----BEGIN RSA PRIVATE KEY-----
MIIEogIBAAKCAQEAlR0tDzyTkQuUyGg1zHKyvR5O2h2oQQV61MbaqojLL9G1VNQL
flHcqLI0XBglzRR0el21pRaNZYgguf78DpOF08KvWmKSpcqLM4P/F0GG5T4fT08a
kkXJH0+nejy4oa8CvnbDT/1C0H6gONQHzLFlzydtAlk2bjeXWaWrro0X9YTILRZS
QmPkN/4A/9xDdI2LTHP8VdcopYh1Uj+VFtFF9x7qpjXRkRlOHzD2Lj0qtmFY68v7
8aFtMbrCp8OmE5sg/6vOFTjz/dcjpdHPa++ab4zZbyQjbfy7RQdG/2zki8N3znMP
aa5JO4R5/Ot48vLAOowM9GR0FVYMBPqT0voECwIDAQABAoIBADX//mDtsY0N8iAP
aSg0g1ksoCaqJdQCPYTPzMGET3zuR2pEbjMdRzlKa97MGehmV3Y2+ICkJamWvi9N
UY+fyg+xidpEJ1JmAroxu4/6+XSMZj9M6NT+88JkkMSaN8zJuccq8DlIAMnLiY96
7aYpujJmVzpJ/4WzmRpsfjt0ui/9i9fefnZBFPFnNK16jrJ2RQBokglMKmpUg+yL
lVdPp57RS38LcBKEbMb6C20iMtZ+ZNxPF4rgzXEJyNRjl0Gh9ukjbnxm8aDkj/Xy
MHizGM0SnZ7VIkclu5CgtOM59V3HSG6ilifj9JkfkEe1pHHp71hVSHz8RF2NjfXa
rLRnuCkCgYEAzu97s4VMKXG5IvX2/m64sUJL/rB4WmtCl4x6Ru+gM+vUEmpmE1VF
FimOF0U10CsSKkJ51ZVVcdldQCO8uZD52N0iBJSVkzXcMUQUQs25NrAkmhqdqwQk
qm7KXXDBO1to3cMKeVUkrb5/uJpzsxOtctqYdqRkGsEGrGJJ+w8ByvkCgYEAuHgO
tgH5dI9wnyV1MlRlFT/60rvJq4GRD6zkR59/kGx6pvUfjl0s3+OoOi2Fco7girt2
1gznpfYgFRzE8Q9LKZCl3kdquNEEadoyRpERhYYKWW20FyYqFAPVrjdnjebrD/D1
wYzBsQyylzpwsgOCUX9raQczb2Ua+9L8EwCCZCMCgYAjyzjSbJQn9wvXCESY7f30
a0tJ2qx2t2blX98mtfw3/urH5K+TWISCuN1jGQ2d3FVgCe+ZCiOldbuzhHr4fiM5
Z8ailDDrLb3Qp735cCxBUWaDYWc0VZsh/9fxIbfK1Jzm/v2ozxlxFCpzfAPXTegK
ndURcI4AMrM8ziON0aK1wQKBgEj8Z4Wn3lU586tkHKyfK6duuwTp++75wrVbCK81
8jjoUtcAIU4om3qyDnuGS0h6M2lwpqImVPkbGrJ/wYRHMsvtSVNbGmSpfn+LL10w
RKh50lpzx09pcDifE8psbXJ9rP+PrQy5bmFozrh7DN/B96vbKFpT2Qv4CuccIVQ7
XVvVAoGAahMpYHYDr+BsB2On8xd5rzkDpUeDwiWCyCaZTb7BjrpWhv5K35GOWkYh
rS9MdSsDAdjiHGRRkX9C6oTx4w4pfxKSN65wAO6gI22oVrcWAMIR7CACmJHnIMxV
wuFWLzXAeE7o05XSvntpugiYm2fkekCTRoJM9OdIfrxLC4fTIeA=
-----END RSA PRIVATE KEY-----"#;
pub const PUBLIC_KEY: &str = r#"-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAlR0tDzyTkQuUyGg1zHKy
vR5O2h2oQQV61MbaqojLL9G1VNQLflHcqLI0XBglzRR0el21pRaNZYgguf78DpOF
08KvWmKSpcqLM4P/F0GG5T4fT08akkXJH0+nejy4oa8CvnbDT/1C0H6gONQHzLFl
zydtAlk2bjeXWaWrro0X9YTILRZSQmPkN/4A/9xDdI2LTHP8VdcopYh1Uj+VFtFF
9x7qpjXRkRlOHzD2Lj0qtmFY68v78aFtMbrCp8OmE5sg/6vOFTjz/dcjpdHPa++a
b4zZbyQjbfy7RQdG/2zki8N3znMPaa5JO4R5/Ot48vLAOowM9GR0FVYMBPqT0voE
CwIDAQAB
-----END PUBLIC KEY-----"#;
fn create_test_macro_api_token_jwt(
issuer: &str,
macro_user_id: &str,
fusionauth_id: &str,
organization_id: Option<i32>,
private_key: &str,
time: Option<usize>,
) -> String {
// Get current timestamp
let now = time.unwrap_or_else(|| {
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs() as usize
});
let claims = MacroApiToken {
agent_correlation_id: None,
agent_session_id: None,
agent_id: None,
agent_via: None,
exp: now + 3600, // Token expires in 1 hour
iss: issuer.to_string(),
fusion_user_id: fusionauth_id.to_string(),
macro_user_id: macro_user_id.to_string(),
macro_organization_id: organization_id,
};
let mut header = jsonwebtoken::Header::new(jsonwebtoken::Algorithm::RS256);
header.kid = Some("macro".to_string());
jsonwebtoken::encode(
&header,
&claims,
&jsonwebtoken::EncodingKey::from_rsa_pem(private_key.as_ref()).unwrap(),
)
.expect("Failed to create test JWT")
}
#[test]
fn test_handler_macro_access_token() -> anyhow::Result<()> {
let jwt_validation_args = JwtValidationArgs {
audience: Audience::new_testing("test_audience"),
issuer: Issuer::new_testing("test.macro.com"),
jwt_secret: LocalOrRemoteSecret::Local(JwtSecretKey::new_testing("super_secret_key")),
macro_api_token_public_key: LocalOrRemoteSecret::Local(
MacroApiTokenPublicKey::new_testing(PUBLIC_KEY),
),
macro_api_token_issuer: MacroApiTokenIssuer::new_testing("test.macro.com"),
};
let token = create_test_jwt(
"test_audience",
"test.macro.com",
"[email protected]",
"super_secret_key",
None,
);
let result = handler(&jwt_validation_args, &token)?;
let result = match result {
JwtToken::MacroAccessToken(token) => token,
_ => panic!("expected macro-access-token"),
};
assert_eq!(result.aud, "test_audience");
Ok(())
}
#[test]
fn test_handler_macro_api_token() -> anyhow::Result<()> {
let jwt_validation_args = JwtValidationArgs {
audience: Audience::new_testing("test_audience"),
issuer: Issuer::new_testing("test.macro.com"),
jwt_secret: LocalOrRemoteSecret::Local(JwtSecretKey::new_testing("super_secret_key")),
macro_api_token_public_key: LocalOrRemoteSecret::Local(
MacroApiTokenPublicKey::new_testing(PUBLIC_KEY),
),
macro_api_token_issuer: MacroApiTokenIssuer::new_testing("test.macro.com"),
};
let token = create_test_macro_api_token_jwt(
"test.macro.com",
"macro|[email protected]",
"fusionauth_user_id",
None,
PRIVATE_KEY,
None,
);
let result = handler(&jwt_validation_args, &token)?;
let result = match result {
JwtToken::MacroApiToken(token) => token,
_ => panic!("expected macro-api-token"),
};
assert!(!result.fusion_user_id.is_empty());
Ok(())
}
#[test]
fn test_validate_macro_access_token_jwt_token() -> anyhow::Result<()> {
let jwt_validation_args = JwtValidationArgs {
audience: Audience::new_testing("test_audience"),
issuer: Issuer::new_testing("test.macro.com"),
jwt_secret: LocalOrRemoteSecret::Local(JwtSecretKey::new_testing("super_secret_key")),
macro_api_token_public_key: LocalOrRemoteSecret::Local(
MacroApiTokenPublicKey::new_testing(""),
),
macro_api_token_issuer: MacroApiTokenIssuer::new_testing(""),
};
let token = create_test_jwt(
"test_audience",
"test.macro.com",
"[email protected]",
"super_secret_key",
None,
);
// Make jwt here using jsonwebtoken crate
let result = validate_macro_access_token_inner(
&token,
&jwt_validation_args.jwt_secret,
&jwt_validation_args.audience,
&jwt_validation_args.issuer,
)?;
assert_eq!(result.email, "[email protected]");
Ok(())
}
#[test]
fn test_validate_macro_access_token_jwt_token_invalid_audience() -> anyhow::Result<()> {
let jwt_validation_args = JwtValidationArgs {
audience: Audience::new_testing("test_audience"),
issuer: Issuer::new_testing("test.macro.com"),
jwt_secret: LocalOrRemoteSecret::Local(JwtSecretKey::new_testing("super_secret_key")),
macro_api_token_public_key: LocalOrRemoteSecret::Local(
MacroApiTokenPublicKey::new_testing(""),
),
macro_api_token_issuer: MacroApiTokenIssuer::new_testing(""),
};
let token = create_test_jwt(
"bad",
"test.macro.com",
"[email protected]",
"super_secret_key",
None,
);
// Make jwt here using jsonwebtoken crate
let result = validate_macro_access_token_inner(
&token,
&jwt_validation_args.jwt_secret,
&jwt_validation_args.audience,
&jwt_validation_args.issuer,
)
.err()
.context("expected error")?;
assert_eq!(result.to_string(), "jwt validation failed: InvalidAudience");
Ok(())
}
#[test]
fn test_validate_macro_access_token_jwt_token_invalid_issuer() -> anyhow::Result<()> {
let jwt_validation_args = JwtValidationArgs {
audience: Audience::new_testing("test_audience"),
issuer: Issuer::new_testing("test.macro.com"),
jwt_secret: LocalOrRemoteSecret::Local(JwtSecretKey::new_testing("super_secret_key")),
macro_api_token_public_key: LocalOrRemoteSecret::Local(
MacroApiTokenPublicKey::new_testing(""),
),
macro_api_token_issuer: MacroApiTokenIssuer::new_testing(""),
};
let token = create_test_jwt(
"test_audience",
"bad.macro.com",
"[email protected]",
"super_secret_key",
None,
);
// Make jwt here using jsonwebtoken crate
let result = validate_macro_access_token_inner(
&token,
&jwt_validation_args.jwt_secret,
&jwt_validation_args.audience,
&jwt_validation_args.issuer,
)
.err()
.context("expected error")?;
assert_eq!(result.to_string(), "jwt validation failed: InvalidIssuer");
Ok(())
}
#[test]
fn test_validate_macro_access_token_jwt_token_expired() -> anyhow::Result<()> {
let jwt_validation_args = JwtValidationArgs {
audience: Audience::new_testing("test_audience"),
issuer: Issuer::new_testing("test.macro.com"),
jwt_secret: LocalOrRemoteSecret::Local(JwtSecretKey::new_testing("super_secret_key")),
macro_api_token_public_key: LocalOrRemoteSecret::Local(
MacroApiTokenPublicKey::new_testing(""),
),
macro_api_token_issuer: MacroApiTokenIssuer::new_testing(""),
};
let token = create_test_jwt(
"test_audience",
"bad.macro.com",
"[email protected]",
"super_secret_key",
Some(
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs() as usize
- 10000,
),
);
// Make jwt here using jsonwebtoken crate
let result = validate_macro_access_token_inner(
&token,
&jwt_validation_args.jwt_secret,
&jwt_validation_args.audience,
&jwt_validation_args.issuer,
)
.err()
.context("expected error")?;
assert_eq!(result.to_string(), "jwt is expired");
Ok(())
}
#[test]
fn test_validate_macro_api_token_jwt_token() -> anyhow::Result<()> {
let jwt_validation_args = JwtValidationArgs {
audience: Audience::new_testing(""),
issuer: Issuer::new_testing(""),
jwt_secret: LocalOrRemoteSecret::Local(JwtSecretKey::new_testing("")),
macro_api_token_public_key: LocalOrRemoteSecret::Local(
MacroApiTokenPublicKey::new_testing(PUBLIC_KEY),
),
macro_api_token_issuer: MacroApiTokenIssuer::new_testing("test.macro.com"),
};
let token = create_test_macro_api_token_jwt(
"test.macro.com",
"macro|[email protected]",
"fusionauth_user_id",
None,
PRIVATE_KEY,
None,
);
// Make jwt here using jsonwebtoken crate
let result = validate_macro_api_token(
&token,
&jwt_validation_args.macro_api_token_public_key,
&jwt_validation_args.macro_api_token_issuer,
)?;
assert_eq!(result.macro_user_id, "macro|[email protected]");
Ok(())
}
#[test]
fn test_validate_macro_api_token_jwt_token_invalid_issuer() -> anyhow::Result<()> {
let jwt_validation_args = JwtValidationArgs {
audience: Audience::new_testing(""),
issuer: Issuer::new_testing(""),
jwt_secret: LocalOrRemoteSecret::Local(JwtSecretKey::new_testing("")),
macro_api_token_public_key: LocalOrRemoteSecret::Local(
MacroApiTokenPublicKey::new_testing(PUBLIC_KEY),
),
macro_api_token_issuer: MacroApiTokenIssuer::new_testing("test.macro.com"),
};
let token = create_test_macro_api_token_jwt(
"bad.macro.com",
"macro|[email protected]",
"fusionauth_user_id",
None,
PRIVATE_KEY,
None,
);
// Make jwt here using jsonwebtoken crate
let result = validate_macro_api_token(
&token,
&jwt_validation_args.macro_api_token_public_key,
&jwt_validation_args.macro_api_token_issuer,
)
.err()
.context("expected error")?;
assert_eq!(result.to_string(), "jwt validation failed: InvalidIssuer");
Ok(())
}
#[test]
fn test_validate_macro_api_token_jwt_token_expired() -> anyhow::Result<()> {
let jwt_validation_args = JwtValidationArgs {
audience: Audience::new_testing(""),
issuer: Issuer::new_testing(""),
jwt_secret: LocalOrRemoteSecret::Local(JwtSecretKey::new_testing("")),
macro_api_token_public_key: LocalOrRemoteSecret::Local(
MacroApiTokenPublicKey::new_testing(PUBLIC_KEY),
),
macro_api_token_issuer: MacroApiTokenIssuer::new_testing("test.macro.com"),
};
let token = create_test_macro_api_token_jwt(
"test.macro.com",
"macro|[email protected]",
"fusionauth_user_id",
None,
PRIVATE_KEY,
Some(
SystemTime::now()
.duration_since(UNIX_EPOCH)
.unwrap()
.as_secs() as usize
- 10000,
),
);
// Make jwt here using jsonwebtoken crate
let result = validate_macro_api_token(
&token,
&jwt_validation_args.macro_api_token_public_key,
&jwt_validation_args.macro_api_token_issuer,
)
.err()
.context("expected error")?;
assert_eq!(result.to_string(), "jwt is expired");
Ok(())
}
}