#[test]
fn test_ip_address_expected_type_mismatch() {
parse_err(r#"{"IpAddress": {"aws:SourceIp": 123}}"#);
}
#[test]
fn test_ip_address_ipv6_fallback_exact_match() {
parse_err(r#"{"IpAddress": {"aws:SourceIp": "2001:db8::/255"}}"#);
}
#[test]
fn test_string_like_missing_key_returns_false() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"StringLike": {"aws:username": "a*"}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result);
}
#[test]
fn test_date_equals_missing_key_returns_false() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_string(format!(
r#"{{
"DateEquals": {{"aws:TokenIssueTime": "{}"}}
}}"#,
chrono::Utc::now().to_rfc3339()
));
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result);
}
#[test]
fn test_forallvalues_string_like_empty_actual_true() {
let context = ConditionContext::builder()
.custom_value("str:vals", crate::ConditionValue::Array(vec![]))
.build();
let condition = parse_condition_block_from_json(
r#"{
"ForAllValues:StringLike": {"str:vals": ["a*"]}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_foranyvalue_string_equals_empty_actual_false() {
let context = ConditionContext::builder()
.custom_value("str:vals", crate::ConditionValue::Array(vec![]))
.build();
let condition = parse_condition_block_from_json(
r#"{
"ForAnyValue:StringEquals": {"str:vals": ["x"]}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result);
}
#[test]
fn test_foranyvalue_string_like_missing_key_false() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"ForAnyValue:StringLike": {"aws:username": ["a*"]}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result);
}
use crate::ConditionError;
use crate::{
evaluate_condition_block, evaluator::parse_condition_block, get_context_value, ConditionBlock,
ConditionContext, ConditionValue,
};
use serde_json::Value;
fn create_test_context() -> ConditionContext {
ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.username("alice")
.source_ip("203.0.113.42")
.current_time(chrono::Utc::now())
.mfa_present(true)
.mfa_age(300) .build()
}
fn parse_condition_block_from_json(json: &str) -> ConditionBlock {
let value: Value = serde_json::from_str(json).unwrap();
parse_condition_block(&value).unwrap()
}
fn unchecked_string(json: String) -> ConditionBlock {
unchecked(&json)
}
fn parse_condition_block_from_string(json_str: String) -> ConditionBlock {
let value: Value = serde_json::from_str(&json_str).unwrap();
parse_condition_block(&value).unwrap()
}
#[test]
fn test_string_equals_exact_match() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "alice"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_string_equals_no_match() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "bob"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result);
}
#[test]
fn test_string_equals_case_sensitive() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "Alice"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_string_equals_empty_string() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": ""
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_string_equals_missing_key() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:NonexistentKey": "value"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_string_equals_if_exists_missing_key() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringEqualsIfExists": {
"aws:NonexistentKey": "value"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_string_equals_if_exists_present_key() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringEqualsIfExists": {
"aws:username": "alice"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_string_equals_if_exists_present_key_no_match() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringEqualsIfExists": {
"aws:username": "bob"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_string_like_wildcard_prefix() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringLike": {
"aws:PrincipalArn": "arn:aws:iam::*:user/*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_string_like_wildcard_suffix() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringLike": {
"aws:username": "ali*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_string_like_wildcard_middle() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringLike": {
"aws:username": "al*ce"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_string_like_multiple_wildcards() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringLike": {
"aws:PrincipalArn": "arn:aws:iam::*:user/al*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_string_like_no_match() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringLike": {
"aws:username": "bob*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result);
}
#[test]
fn test_string_like_question_mark() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringLike": {
"aws:username": "ali?e"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_string_like_escape_wildcards() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringLike": {
"aws:username": "alice*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_string_not_equals() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringNotEquals": {
"aws:username": "bob"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_string_not_equals_match() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringNotEquals": {
"aws:username": "alice"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_string_equals_ignore_case() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringEqualsIgnoreCase": {
"aws:username": "Alice"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_numeric_equals() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"NumericEquals": {
"aws:MultiFactorAuthAge": "300"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_numeric_equals_float() {
let context = create_test_context();
let condition = unchecked(
r#"{
"NumericEquals": {
"aws:SomeNumericKey": "123.45"
}
}"#,
);
let _ = evaluate_condition_block(&condition, &context).unwrap();
}
#[test]
fn test_numeric_less_than() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"NumericLessThan": {
"aws:MultiFactorAuthAge": "3600"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_numeric_less_than_equals() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"NumericLessThanEquals": {
"aws:MultiFactorAuthAge": "300"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_numeric_greater_than() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"NumericGreaterThan": {
"aws:MultiFactorAuthAge": "60"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_numeric_greater_than_equals() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"NumericGreaterThanEquals": {
"aws:MultiFactorAuthAge": "300"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_numeric_negative_values() {
let _context = create_test_context();
let _condition = unchecked(
r#"{
"NumericLessThan": {
"aws:SomeKey": "-100"
}
}"#,
);
}
#[test]
fn test_numeric_zero() {
let _context = create_test_context();
let _condition = unchecked(
r#"{
"NumericEquals": {
"aws:SomeKey": "0"
}
}"#,
);
}
#[test]
fn test_numeric_very_large() {
let _context = create_test_context();
let _condition = unchecked(
r#"{
"NumericLessThan": {
"aws:SomeKey": "999999999999"
}
}"#,
);
}
#[test]
fn test_numeric_invalid_string() {
let message = parse_err(r#"{"NumericEquals": {"wami:SessionAge": "alice"}}"#);
assert!(message.contains("finite number"), "{message}");
}
#[test]
fn test_date_equals() {
let now = chrono::Utc::now();
let context = ConditionContext::builder().current_time(now).build();
let time_str = now.to_rfc3339();
let condition = parse_condition_block_from_string(format!(
r#"{{
"DateEquals": {{
"aws:CurrentTime": "{}"
}}
}}"#,
time_str
));
let _ = evaluate_condition_block(&condition, &context).unwrap();
}
#[test]
fn test_date_less_than() {
let now = chrono::Utc::now();
let future = now + chrono::Duration::hours(1);
let context = ConditionContext::builder().current_time(now).build();
let future_str = future.to_rfc3339();
let condition = parse_condition_block_from_string(format!(
r#"{{
"DateLessThan": {{
"aws:CurrentTime": "{}"
}}
}}"#,
future_str
));
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_date_greater_than() {
let now = chrono::Utc::now();
let past = now - chrono::Duration::hours(1);
let context = ConditionContext::builder().current_time(now).build();
let past_str = past.to_rfc3339();
let condition = parse_condition_block_from_string(format!(
r#"{{
"DateGreaterThan": {{
"aws:CurrentTime": "{}"
}}
}}"#,
past_str
));
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_date_invalid_format() {
let message = parse_err(r#"{"DateEquals": {"aws:CurrentTime": "invalid-date"}}"#);
assert!(message.contains("RFC 3339"), "{message}");
}
#[test]
fn test_ip_address_exact_match() {
let context = ConditionContext::builder()
.source_ip("203.0.113.42")
.build();
let condition = parse_condition_block_from_json(
r#"{
"IpAddress": {
"aws:SourceIp": "203.0.113.42"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_ip_address_cidr_match() {
let context = ConditionContext::builder()
.source_ip("203.0.113.42")
.build();
let condition = parse_condition_block_from_json(
r#"{
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_ip_address_cidr_no_match() {
let context = ConditionContext::builder()
.source_ip("198.51.100.42")
.build();
let condition = parse_condition_block_from_json(
r#"{
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_ip_address_multiple_cidrs() {
let context = ConditionContext::builder()
.source_ip("203.0.113.42")
.build();
let condition = parse_condition_block_from_json(
r#"{
"IpAddress": {
"aws:SourceIp": ["203.0.113.0/24", "198.51.100.0/24"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_ip_address_ipv6() {
let context = ConditionContext::builder().source_ip("2001:db8::1").build();
let condition = parse_condition_block_from_json(
r#"{
"IpAddress": {
"aws:SourceIp": "2001:db8::/32"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_ip_address_invalid_ip() {
let context = ConditionContext::builder().source_ip("not-an-ip").build();
let condition = parse_condition_block_from_json(
r#"{
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context);
assert_eq!(
result,
Err(ConditionError::TypeMismatch {
expected: "an IP address".to_string(),
actual: "String".to_string()
})
);
}
#[test]
fn test_not_ip_address() {
let context = ConditionContext::builder()
.source_ip("198.51.100.42")
.build();
let condition = parse_condition_block_from_json(
r#"{
"NotIpAddress": {
"aws:SourceIp": "203.0.113.0/24"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_arn_equals() {
let context = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.build();
let condition = parse_condition_block_from_json(
r#"{
"ArnEquals": {
"aws:PrincipalArn": "arn:aws:iam::123456789012:user/alice"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_arn_like_wildcard() {
let context = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.build();
let condition = parse_condition_block_from_json(
r#"{
"ArnLike": {
"aws:PrincipalArn": "arn:aws:iam::*:user/*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_arn_like_no_match() {
let context = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.build();
let condition = parse_condition_block_from_json(
r#"{
"ArnLike": {
"aws:PrincipalArn": "arn:aws:iam::*:role/*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_bool_true() {
let context = ConditionContext::builder().mfa_present(true).build();
let condition = parse_condition_block_from_json(
r#"{
"Bool": {
"aws:MultiFactorAuthPresent": "true"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_bool_false() {
let context = ConditionContext::builder().mfa_present(false).build();
let condition = parse_condition_block_from_json(
r#"{
"Bool": {
"aws:MultiFactorAuthPresent": "false"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_bool_mismatch() {
let context = ConditionContext::builder().mfa_present(true).build();
let condition = parse_condition_block_from_json(
r#"{
"Bool": {
"aws:MultiFactorAuthPresent": "false"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_bool_invalid_value() {
let message = parse_err(r#"{"Bool": {"aws:MultiFactorAuthPresent": "yes"}}"#);
assert!(message.contains("true or false"), "{message}");
}
#[test]
fn test_for_all_values_string_equals_all_match() {
let context = ConditionContext::builder()
.tag_keys(vec!["Env".to_string(), "Owner".to_string()])
.build();
let condition = parse_condition_block_from_json(
r#"{
"ForAllValues:StringEquals": {
"aws:TagKeys": ["Env", "Owner"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_for_all_values_string_equals_one_missing() {
let context = ConditionContext::builder()
.tag_keys(vec![
"Env".to_string(),
"Owner".to_string(),
"Cost".to_string(),
])
.build();
let condition = parse_condition_block_from_json(
r#"{
"ForAllValues:StringEquals": {
"aws:TagKeys": ["Env", "Owner"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_for_all_values_string_equals_empty_request() {
let context = ConditionContext::builder().tag_keys(vec![]).build();
let condition = parse_condition_block_from_json(
r#"{
"ForAllValues:StringEquals": {
"aws:TagKeys": ["Env", "Owner"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_for_any_value_string_equals_one_matches() {
let context = ConditionContext::builder()
.principal_tag_role(vec!["Admin".to_string()])
.build();
let condition = parse_condition_block_from_json(
r#"{
"ForAnyValue:StringEquals": {
"aws:PrincipalTag/Role": ["Admin", "DevOps"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_for_any_value_string_equals_none_match() {
let context = ConditionContext::builder()
.principal_tag_role(vec!["User".to_string()])
.build();
let condition = parse_condition_block_from_json(
r#"{
"ForAnyValue:StringEquals": {
"aws:PrincipalTag/Role": ["Admin", "DevOps"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_for_any_value_string_equals_empty_request() {
let context = ConditionContext::builder()
.principal_tag_role(vec![])
.build();
let condition = parse_condition_block_from_json(
r#"{
"ForAnyValue:StringEquals": {
"aws:PrincipalTag/Role": ["Admin", "DevOps"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_multiple_conditions_all_pass() {
let context = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.username("alice")
.source_ip("203.0.113.42")
.mfa_present(true)
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "alice"
},
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
},
"Bool": {
"aws:MultiFactorAuthPresent": "true"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_multiple_conditions_one_fails() {
let context = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.source_ip("198.51.100.42") .mfa_present(true)
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "alice"
},
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
},
"Bool": {
"aws:MultiFactorAuthPresent": "true"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_multiple_keys_same_operator() {
let context = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.source_ip("203.0.113.42")
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "alice",
"aws:PrincipalType": "User"
}
}"#,
);
let _ = evaluate_condition_block(&condition, &context).unwrap();
}
#[test]
fn test_empty_condition_block() {
let context = create_test_context();
let condition = parse_condition_block_from_json(r#"{}"#);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_with_null_value() {
let _context = create_test_context();
let _condition = parse_condition_block_from_json(
r#"{
"Null": {
"aws:TokenIssueTime": "true"
}
}"#,
);
}
#[test]
fn test_condition_with_unicode() {
let context = ConditionContext::builder()
.username("用户".to_string())
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "用户"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_with_very_long_string() {
let long_string = "a".repeat(10000);
let context = ConditionContext::builder()
.username(long_string.clone())
.build();
let condition = parse_condition_block_from_string(format!(
r#"{{
"StringEquals": {{
"aws:username": "{}"
}}
}}"#,
long_string
));
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_condition_with_special_characters() {
let context = ConditionContext::builder()
.username("user@example.com".to_string())
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "user@example.com"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_condition_type_mismatch() {
let context = ConditionContext::builder()
.username("alice".to_string())
.build();
let condition = unchecked(
r#"{
"NumericEquals": {
"aws:username": "123"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context);
assert_eq!(
result,
Err(ConditionError::TypeMismatch {
expected: "a finite Number".to_string(),
actual: "String".to_string()
})
);
}
#[test]
fn test_condition_invalid_operator() {
let message = parse_err(r#"{"InvalidOperator": {"aws:username": "alice"}}"#);
assert!(message.contains("InvalidOperator"), "{message}");
let mut condition = ConditionBlock::new();
condition.insert(
"InvalidOperator".to_string(),
std::collections::HashMap::from([(
"aws:username".to_string(),
ConditionValue::String("alice".to_string()),
)]),
);
let result = evaluate_condition_block(&condition, &create_test_context());
assert_eq!(
result,
Err(ConditionError::UnknownOperator(
"InvalidOperator".to_string()
))
);
}
#[test]
fn test_condition_array_value() {
let context = ConditionContext::builder()
.tag_keys(vec!["Env".to_string(), "Owner".to_string()])
.build();
let condition = parse_condition_block_from_json(
r#"{
"ForAllValues:StringEquals": {
"aws:TagKeys": ["Env", "Owner"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_condition_nested_structure() {
}
#[test]
fn test_policy_with_condition_allows() {
}
#[test]
fn test_policy_with_condition_denies() {
}
#[test]
fn test_policy_without_condition() {
}
#[test]
fn test_multiple_statements_with_conditions() {
}
#[test]
fn test_deny_statement_with_condition() {
}
#[test]
fn test_deny_statement_with_condition_fails() {
}
#[test]
fn test_aws_condition_key_principal_arn() {
}
#[test]
fn test_aws_condition_key_source_ip() {
}
#[test]
fn test_aws_condition_key_current_time() {
}
#[test]
fn test_wami_condition_key_tenant_id() {
let _context = ConditionContext::builder()
.tenant_id(12345678)
.principal_tenant_id(12345678)
.build();
let _condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"wami:TenantId": "${wami:PrincipalTenantId}"
}
}"#,
);
}
#[test]
fn test_wami_condition_key_provider() {
let context = ConditionContext::builder()
.provider("AWS".to_string())
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"wami:Provider": "AWS"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_condition_evaluation_performance() {
}
#[test]
fn test_large_condition_block() {
}
#[test]
fn test_condition_injection_prevention() {
let context = ConditionContext::builder()
.username("alice'; DROP TABLE users; --")
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "alice'; DROP TABLE users; --"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_sql_injection_in_pattern() {
let context = ConditionContext::builder().username("alice").build();
let condition = parse_condition_block_from_json(
r#"{
"StringLike": {
"aws:username": "*'; DROP TABLE users; --*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_condition_path_traversal_prevention() {
let context = ConditionContext::builder()
.username("../../../etc/passwd")
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "../../../etc/passwd"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_xss_prevention() {
let context = ConditionContext::builder()
.username("<script>alert('xss')</script>")
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "<script>alert('xss')</script>"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_command_injection_prevention() {
let context = ConditionContext::builder()
.username("alice; rm -rf /")
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "alice; rm -rf /"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_resource_limits() {
let mut large_condition = String::from(r#"{"StringEquals": {"#);
for i in 0..1000 {
if i > 0 {
large_condition.push(',');
}
large_condition.push_str(&format!(r#""aws:username{}": "value{}""#, i, i));
}
large_condition.push_str(r#"}}"#);
let value: Value = serde_json::from_str(&large_condition).unwrap();
let result = parse_condition_block(&value);
assert!(result.is_ok()); }
#[test]
fn test_condition_deeply_nested_structure() {
let nested = r#"{"StringEquals": {"aws:username": "alice"}}"#;
let value: Value = serde_json::from_str(nested).unwrap();
let result = parse_condition_block(&value);
assert!(result.is_ok());
}
#[test]
fn test_condition_very_long_strings() {
let long_string = "a".repeat(1_000_000);
let context = ConditionContext::builder()
.username(long_string.clone())
.build();
let condition_json = format!(
r#"{{
"StringEquals": {{
"aws:username": "{}"
}}
}}"#,
long_string
);
let condition = parse_condition_block_from_string(condition_json);
let result = evaluate_condition_block(&condition, &context);
assert!(result.is_ok());
}
#[test]
fn test_condition_malformed_json_handling() {
let malformed = r#"{"StringEquals": {"aws:username": "alice""#; let value_result: Result<Value, _> = serde_json::from_str(malformed);
assert!(value_result.is_err()); }
#[test]
fn test_condition_null_bytes_in_strings() {
let username_with_null = format!("alice{}injected", '\0');
let context = ConditionContext::builder()
.username(username_with_null.clone())
.build();
let condition_json = serde_json::json!({
"StringEquals": {
"aws:username": username_with_null
}
});
let condition = parse_condition_block(&condition_json).unwrap();
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_unicode_normalization_attacks() {
let context = ConditionContext::builder()
.username("alice") .build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "аlice"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_condition_regex_injection_prevention() {
let context = ConditionContext::builder().username("alice").build();
let condition = parse_condition_block_from_json(
r#"{
"StringLike": {
"aws:username": ".*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_condition_arithmetic_overflow_prevention() {
let context = ConditionContext::builder().mfa_age(u64::MAX).build();
let condition = parse_condition_block_from_json(
r#"{
"NumericLessThan": {
"aws:MultiFactorAuthAge": "18446744073709551615"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context);
assert_eq!(result, Ok(false));
}
#[test]
fn test_condition_denial_of_service_wildcard() {
let context = ConditionContext::builder()
.username("a".repeat(1000))
.build();
let pattern = format!("*{}*", "a".repeat(100));
let condition_json = format!(
r#"{{
"StringLike": {{
"aws:username": "{}"
}}
}}"#,
pattern
);
let condition = parse_condition_block_from_string(condition_json);
let start = std::time::Instant::now();
let result = evaluate_condition_block(&condition, &context);
let duration = start.elapsed();
assert!(result.is_ok());
assert!(duration.as_secs() < 1);
}
#[test]
fn test_condition_empty_context_handling() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "alice"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_condition_missing_key_handling() {
let context = ConditionContext::builder().username("alice").build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "alice",
"aws:PrincipalType": "User"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result);
}
#[test]
fn test_condition_if_exists_with_missing_key() {
let context = ConditionContext::builder().username("alice").build();
let condition = parse_condition_block_from_json(
r#"{
"StringEqualsIfExists": {
"aws:PrincipalType": "User"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_type_coercion_security() {
let context = ConditionContext::builder().username("0").build();
let condition = unchecked(
r#"{
"NumericEquals": {
"aws:username": "0"
}
}"#,
);
let _result1 = evaluate_condition_block(&condition, &context);
let context2 = ConditionContext::builder().username("alice").build();
let result2 = evaluate_condition_block(&condition, &context2);
assert_eq!(
result2,
Err(ConditionError::TypeMismatch {
expected: "a finite Number".to_string(),
actual: "String".to_string()
})
);
let context3 = ConditionContext::builder().username("not-a-number").build();
let result3 = evaluate_condition_block(&condition, &context3);
assert_eq!(
result3,
Err(ConditionError::TypeMismatch {
expected: "a finite Number".to_string(),
actual: "String".to_string()
})
);
}
#[test]
fn test_condition_array_injection() {
let message = parse_err(r#"{"StringEquals": {"aws:username": ["Env", "Owner"]}}"#);
assert!(message.contains("wami 002"), "{message}");
}
#[test]
fn test_condition_boolean_coercion_security() {
let context = ConditionContext::builder().mfa_present(true).build();
let condition = parse_condition_block_from_json(
r#"{
"Bool": {
"aws:MultiFactorAuthPresent": "true"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_date_manipulation_attempts() {
let now = chrono::Utc::now();
let future = now + chrono::Duration::days(365 * 100); let context = ConditionContext::builder().current_time(now).build();
let future_str = future.to_rfc3339();
let condition = parse_condition_block_from_string(format!(
r#"{{
"DateLessThan": {{
"aws:CurrentTime": "{}"
}}
}}"#,
future_str
));
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_ip_address_spoofing_prevention() {
let context = ConditionContext::builder()
.source_ip("203.0.113.42")
.build();
let condition = parse_condition_block_from_json(
r#"{
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_arn_injection_prevention() {
let context = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.build();
let condition = parse_condition_block_from_json(
r#"{
"ArnLike": {
"aws:PrincipalArn": "arn:aws:iam::*:user/*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_forallvalues_empty_actual() {
let context = ConditionContext::builder().tag_keys(vec![]).build();
let condition = parse_condition_block_from_json(
r#"{
"ForAllValues:StringEquals": {
"aws:TagKeys": ["Env", "Owner"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_foranyvalue_empty_actual() {
let context = ConditionContext::builder().tag_keys(vec![]).build();
let condition = parse_condition_block_from_json(
r#"{
"ForAnyValue:StringEquals": {
"aws:TagKeys": ["Env", "Owner"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_condition_multiple_operators_security() {
let context = ConditionContext::builder()
.username("alice")
.source_ip("203.0.113.42")
.mfa_present(true)
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "alice"
},
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
},
"Bool": {
"aws:MultiFactorAuthPresent": "true"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_operator_short_circuit_security() {
let context = ConditionContext::builder()
.username("alice")
.source_ip("198.51.100.42") .build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "alice"
},
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_condition_very_large_numbers() {
let context = ConditionContext::builder()
.mfa_age(1_000_000_000_000)
.build();
let condition = parse_condition_block_from_json(
r#"{
"NumericLessThan": {
"aws:MultiFactorAuthAge": "2000000000000"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_condition_negative_numbers() {
let context = ConditionContext::builder().mfa_age(300).build();
let condition = parse_condition_block_from_json(
r#"{
"NumericGreaterThan": {
"aws:MultiFactorAuthAge": "-100"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_floating_point_precision() {
let context = ConditionContext::builder().mfa_age(300).build();
let condition = parse_condition_block_from_json(
r#"{
"NumericEquals": {
"aws:MultiFactorAuthAge": "300.0"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_special_characters_in_keys() {
let mut tags = std::collections::HashMap::new();
tags.insert("Key-With-Special/Chars".to_string(), "value".to_string());
let context = ConditionContext::builder()
.principal_tag("Key-With-Special/Chars", "value")
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:PrincipalTag/Key-With-Special/Chars": "value"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_condition_unicode_in_keys() {
let context = ConditionContext::builder()
.principal_tag("键", "值")
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:PrincipalTag/键": "值"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_condition_control_characters() {
let context = ConditionContext::builder().username("alice\tbob").build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "alice\tbob"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_condition_empty_strings() {
let context = ConditionContext::builder().username("").build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": ""
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_whitespace_handling() {
let context = ConditionContext::builder().username(" alice ").build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": " alice "
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_case_sensitivity() {
let context = ConditionContext::builder().username("Alice").build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "alice"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_condition_case_insensitive() {
let context = ConditionContext::builder().username("Alice").build();
let condition = parse_condition_block_from_json(
r#"{
"StringEqualsIgnoreCase": {
"aws:username": "alice"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_wildcard_edge_cases() {
let test_cases = vec![
("alice", "*", true),
("alice", "alice*", true),
("alice", "*alice", true), ("alice", "*alice*", true),
("alice", "alice", true),
("alice", "bob", false),
("alice", "a*e", true),
("alice", "a?ice", true),
("alice", "a??ce", true),
("alice", "a???ce", false),
("testalice", "*alice", true), ("", "*", true), ("", "*alice", false), ("alice", "a*", true), ("alice", "*c*", true), ];
for (value, pattern, expected) in test_cases {
let context = ConditionContext::builder().username(value).build();
let condition_json = format!(
r#"{{
"StringLike": {{
"aws:username": "{}"
}}
}}"#,
pattern
);
let condition = parse_condition_block_from_string(condition_json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(
result, expected,
"Pattern '{}' should match '{}' = {}",
pattern, value, expected
);
}
}
#[test]
fn test_condition_parse_invalid_structure() {
let invalid_cases = vec![
r#"null"#,
r#""string""#,
r#"123"#,
r#"[]"#,
r#"{"StringEquals": "not an object"}"#,
r#"{"StringEquals": {"key": null}}"#,
];
for invalid_json in invalid_cases {
let value_result: Result<Value, _> = serde_json::from_str(invalid_json);
if let Ok(value) = value_result {
let result = parse_condition_block(&value);
assert!(
matches!(
result,
Err(ConditionError::InvalidConditionStructure(_)
| ConditionError::InvalidConditionValue { .. })
),
"{invalid_json}: {result:?}"
);
}
}
}
#[test]
fn test_condition_context_key_resolution_edge_cases() {
let context = ConditionContext::builder()
.principal_arn("")
.username("")
.mfa_present(false)
.mfa_age(0)
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:PrincipalArn": "",
"aws:username": ""
},
"Bool": {
"aws:MultiFactorAuthPresent": "false"
},
"NumericEquals": {
"aws:MultiFactorAuthAge": "0"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_custom_value_fallback() {
let context = ConditionContext::builder()
.custom_value(
"custom:key",
crate::ConditionValue::String("value".to_string()),
)
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"custom:key": "value"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_condition_unknown_key_handling() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"unknown:key": "value"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result);
}
#[test]
fn test_condition_empty_block() {
let context = create_test_context();
let condition = ConditionBlock::new();
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_condition_empty_operator_block() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_condition_multiple_empty_operators() {
let context = create_test_context();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {},
"NumericEquals": {},
"Bool": {}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_condition_all_ifexists_operators() {
let context = ConditionContext::builder()
.username("alice")
.mfa_present(true)
.build();
let test_cases = vec![
(
r#"{"StringEqualsIfExists": {"aws:username": "alice"}}"#,
true,
),
(
r#"{"StringEqualsIfExists": {"aws:PrincipalType": "User"}}"#,
true,
), (
r#"{"NumericEqualsIfExists": {"aws:MultiFactorAuthAge": "300"}}"#,
true,
),
(
r#"{"NumericEqualsIfExists": {"aws:MultiFactorAuthAge": "600"}}"#,
true, ),
(
r#"{"DateEqualsIfExists": {"aws:TokenIssueTime": "2024-01-01T00:00:00Z"}}"#,
true,
), (
r#"{"IpAddressIfExists": {"aws:SourceIp": "203.0.113.0/24"}}"#,
true,
), (
r#"{"ArnEqualsIfExists": {"aws:PrincipalArn": "arn:aws:iam::123456789012:user/alice"}}"#,
true,
), (
r#"{"BoolIfExists": {"aws:MultiFactorAuthPresent": "true"}}"#,
true,
),
(
r#"{"BoolIfExists": {"aws:MultiFactorAuthPresent": "false"}}"#,
false,
),
];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_condition_numeric_edge_cases() {
let max_str = u64::MAX.to_string();
let test_cases = vec![
(0u64, "0", true),
(0u64, "0.0", true),
(300u64, "300", true),
(300u64, "300.0", true),
(300u64, "299", false),
(300u64, "301", false),
(u64::MAX, &max_str, true),
];
for (age, expected_str, should_match) in test_cases {
let context = ConditionContext::builder().mfa_age(age).build();
let condition_json = format!(
r#"{{
"NumericEquals": {{
"aws:MultiFactorAuthAge": "{}"
}}
}}"#,
expected_str
);
let condition = parse_condition_block_from_string(condition_json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(
result,
should_match,
"Age {} should {} match {}",
age,
if should_match { "" } else { "not" },
expected_str
);
}
}
#[test]
fn test_condition_numeric_comparison_operators() {
let context = ConditionContext::builder().mfa_age(300).build();
let test_cases = vec![
(
r#"{"NumericLessThan": {"aws:MultiFactorAuthAge": "400"}}"#,
true,
),
(
r#"{"NumericLessThan": {"aws:MultiFactorAuthAge": "300"}}"#,
false,
),
(
r#"{"NumericLessThan": {"aws:MultiFactorAuthAge": "200"}}"#,
false,
),
(
r#"{"NumericLessThanEquals": {"aws:MultiFactorAuthAge": "300"}}"#,
true,
),
(
r#"{"NumericLessThanEquals": {"aws:MultiFactorAuthAge": "400"}}"#,
true,
),
(
r#"{"NumericLessThanEquals": {"aws:MultiFactorAuthAge": "200"}}"#,
false,
),
(
r#"{"NumericGreaterThan": {"aws:MultiFactorAuthAge": "200"}}"#,
true,
),
(
r#"{"NumericGreaterThan": {"aws:MultiFactorAuthAge": "300"}}"#,
false,
),
(
r#"{"NumericGreaterThan": {"aws:MultiFactorAuthAge": "400"}}"#,
false,
),
(
r#"{"NumericGreaterThanEquals": {"aws:MultiFactorAuthAge": "300"}}"#,
true,
),
(
r#"{"NumericGreaterThanEquals": {"aws:MultiFactorAuthAge": "200"}}"#,
true,
),
(
r#"{"NumericGreaterThanEquals": {"aws:MultiFactorAuthAge": "400"}}"#,
false,
),
];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_condition_date_comparison_operators() {
let now = chrono::Utc::now();
let past = now - chrono::Duration::hours(1);
let future = now + chrono::Duration::hours(1);
let context = ConditionContext::builder().current_time(now).build();
let test_cases = vec![
(
format!(
r#"{{"DateLessThan": {{"aws:CurrentTime": "{}"}}}}"#,
future.to_rfc3339()
),
true,
),
(
format!(
r#"{{"DateLessThan": {{"aws:CurrentTime": "{}"}}}}"#,
now.to_rfc3339()
),
false,
),
(
format!(
r#"{{"DateLessThan": {{"aws:CurrentTime": "{}"}}}}"#,
past.to_rfc3339()
),
false,
),
(
format!(
r#"{{"DateLessThanEquals": {{"aws:CurrentTime": "{}"}}}}"#,
now.to_rfc3339()
),
true,
),
(
format!(
r#"{{"DateLessThanEquals": {{"aws:CurrentTime": "{}"}}}}"#,
future.to_rfc3339()
),
true,
),
(
format!(
r#"{{"DateLessThanEquals": {{"aws:CurrentTime": "{}"}}}}"#,
past.to_rfc3339()
),
false,
),
(
format!(
r#"{{"DateGreaterThan": {{"aws:CurrentTime": "{}"}}}}"#,
past.to_rfc3339()
),
true,
),
(
format!(
r#"{{"DateGreaterThan": {{"aws:CurrentTime": "{}"}}}}"#,
now.to_rfc3339()
),
false,
),
(
format!(
r#"{{"DateGreaterThan": {{"aws:CurrentTime": "{}"}}}}"#,
future.to_rfc3339()
),
false,
),
(
format!(
r#"{{"DateGreaterThanEquals": {{"aws:CurrentTime": "{}"}}}}"#,
now.to_rfc3339()
),
true,
),
(
format!(
r#"{{"DateGreaterThanEquals": {{"aws:CurrentTime": "{}"}}}}"#,
past.to_rfc3339()
),
true,
),
(
format!(
r#"{{"DateGreaterThanEquals": {{"aws:CurrentTime": "{}"}}}}"#,
future.to_rfc3339()
),
false,
),
];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_string(json.clone());
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_condition_binary_operators() {
let context = ConditionContext::builder()
.custom_value(
"binary:key",
crate::ConditionValue::String("dGVzdA==".to_string()),
)
.build();
let condition = parse_condition_block_from_json(
r#"{
"BinaryEquals": {
"binary:key": "dGVzdA=="
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_condition_null_operators() {
let context1 = ConditionContext::builder().username("alice").build();
let context2 = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"Null": {
"aws:username": "true"
}
}"#,
);
let result1 = evaluate_condition_block(&condition, &context1).unwrap();
assert!(!result1);
let result2 = evaluate_condition_block(&condition, &context2).unwrap();
assert!(result2); }
#[test]
fn test_condition_forallvalues_comprehensive() {
let context = ConditionContext::builder()
.tag_keys(vec!["Env".to_string(), "Owner".to_string()])
.build();
let test_cases = vec![
(
r#"{"ForAllValues:StringEquals": {"aws:TagKeys": ["Env", "Owner"]}}"#,
true,
),
(
r#"{"ForAllValues:StringEquals": {"aws:TagKeys": ["Env", "Owner", "Project"]}}"#,
true, ),
(
r#"{"ForAllValues:StringEquals": {"aws:TagKeys": ["Env", "Owner"]}}"#,
true,
),
(
r#"{"ForAllValues:StringEquals": {"aws:TagKeys": ["Env"]}}"#,
false,
), ];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_condition_foranyvalue_comprehensive() {
let context = ConditionContext::builder()
.tag_keys(vec!["Env".to_string(), "Owner".to_string()])
.build();
let test_cases = vec![
(
r#"{"ForAnyValue:StringEquals": {"aws:TagKeys": ["Env", "Project"]}}"#,
true,
),
(
r#"{"ForAnyValue:StringEquals": {"aws:TagKeys": ["Project", "Team"]}}"#,
false,
),
(
r#"{"ForAnyValue:StringEquals": {"aws:TagKeys": ["Env"]}}"#,
true,
), ];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_condition_tag_keys_dynamic() {
let context = ConditionContext::builder()
.principal_tag("Environment", "production")
.principal_tag("Role", "admin")
.resource_tag("Project", "wami")
.request_tag("RequestId", "12345")
.build();
let test_cases = vec![
(
r#"{"StringEquals": {"aws:PrincipalTag/Environment": "production"}}"#,
true,
),
(
r#"{"StringEquals": {"aws:PrincipalTag/Role": "admin"}}"#,
true,
),
(
r#"{"StringEquals": {"aws:PrincipalTag/Environment": "staging"}}"#,
false,
),
(
r#"{"StringEquals": {"aws:ResourceTag/Project": "wami"}}"#,
true,
),
(
r#"{"StringEquals": {"aws:RequestTag/RequestId": "12345"}}"#,
true,
),
(
r#"{"StringEquals": {"aws:PrincipalTag/Nonexistent": "value"}}"#,
false,
),
];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_condition_wami_specific_keys() {
let context = ConditionContext::builder()
.tenant_id(12345)
.principal_tenant_id(12345)
.resource_tenant_id(67890)
.provider("AWS")
.source_provider("AWS")
.target_provider("GCP")
.build();
let test_cases = vec![
(r#"{"StringEquals": {"wami:TenantId": "12345"}}"#, true),
(
r#"{"StringEquals": {"wami:PrincipalTenantId": "12345"}}"#,
true,
),
(
r#"{"StringEquals": {"wami:ResourceTenantId": "67890"}}"#,
true,
),
(r#"{"StringEquals": {"wami:Provider": "AWS"}}"#, true),
(r#"{"StringEquals": {"wami:SourceProvider": "AWS"}}"#, true),
(r#"{"StringEquals": {"wami:TargetProvider": "GCP"}}"#, true),
(r#"{"StringEquals": {"wami:TenantId": "99999"}}"#, false),
];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_condition_epoch_time() {
let now = chrono::Utc::now();
let context = ConditionContext::builder().current_time(now).build();
let epoch = now.timestamp();
let condition_json = format!(
r#"{{
"NumericEquals": {{
"aws:EpochTime": "{}"
}}
}}"#,
epoch
);
let condition = parse_condition_block_from_string(condition_json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_condition_boolean_edge_cases() {
let context_true = ConditionContext::builder().mfa_present(true).build();
let context_false = ConditionContext::builder().mfa_present(false).build();
let test_cases = vec![
(
r#"{"Bool": {"aws:MultiFactorAuthPresent": "true"}}"#,
true,
true,
),
(
r#"{"Bool": {"aws:MultiFactorAuthPresent": "false"}}"#,
false,
true,
),
(
r#"{"Bool": {"aws:MultiFactorAuthPresent": "true"}}"#,
false,
false,
),
(
r#"{"Bool": {"aws:MultiFactorAuthPresent": "false"}}"#,
true,
false,
),
];
for (json, expected, use_true_context) in test_cases {
let context = if use_true_context {
&context_true
} else {
&context_false
};
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_condition_arn_wildcard_patterns() {
let context = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.build();
let test_cases = vec![
(
r#"{"ArnLike": {"aws:PrincipalArn": "arn:aws:iam::*:user/*"}}"#,
true,
),
(
r#"{"ArnLike": {"aws:PrincipalArn": "arn:aws:iam::123456789012:user/alice"}}"#,
true,
),
(
r#"{"ArnLike": {"aws:PrincipalArn": "arn:aws:iam::*:role/*"}}"#,
false,
),
(
r#"{"ArnLike": {"aws:PrincipalArn": "arn:aws:s3:::*"}}"#,
false,
),
];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_condition_complex_multi_operator() {
let context = ConditionContext::builder()
.username("alice")
.source_ip("203.0.113.42")
.mfa_present(true)
.mfa_age(300)
.principal_tag("Environment", "production")
.current_time(chrono::Utc::now())
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:username": "alice"
},
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
},
"Bool": {
"aws:MultiFactorAuthPresent": "true"
},
"NumericLessThan": {
"aws:MultiFactorAuthAge": "600"
},
"StringEquals": {
"aws:PrincipalTag/Environment": "production"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_condition_parse_error_handling() {
let invalid_cases = vec![
serde_json::json!(null),
serde_json::json!("string"),
serde_json::json!(123),
serde_json::json!([]),
serde_json::json!({"StringEquals": "not an object"}),
];
for invalid_value in invalid_cases {
let result = parse_condition_block(&invalid_value);
assert!(
matches!(result, Err(ConditionError::InvalidConditionStructure(_))),
"{invalid_value}: {result:?}"
);
}
}
#[test]
fn test_condition_value_as_string() {
use crate::ConditionValue;
let val = ConditionValue::String("test".to_string());
assert_eq!(val.as_string().unwrap(), "test");
let val = ConditionValue::Number(123.45);
assert_eq!(val.as_string().unwrap(), "123.45");
let val = ConditionValue::Boolean(true);
assert_eq!(val.as_string().unwrap(), "true");
let val = ConditionValue::Boolean(false);
assert_eq!(val.as_string().unwrap(), "false");
let val = ConditionValue::Array(vec!["a".to_string(), "b".to_string()]);
assert!(val.as_string().is_err());
}
#[test]
fn test_condition_value_as_number() {
use crate::ConditionValue;
let val = ConditionValue::Number(123.45);
assert_eq!(val.as_number().unwrap(), 123.45);
let val = ConditionValue::String("123.45".to_string());
assert_eq!(val.as_number().unwrap(), 123.45);
let val = ConditionValue::String("not-a-number".to_string());
assert!(val.as_number().is_err());
let val = ConditionValue::Boolean(true);
assert!(val.as_number().is_err());
let val = ConditionValue::Array(vec!["a".to_string()]);
assert!(val.as_number().is_err());
}
#[test]
fn test_condition_value_as_boolean() {
use crate::ConditionValue;
let val = ConditionValue::Boolean(true);
assert!(val.as_boolean().unwrap());
let val = ConditionValue::Boolean(false);
assert!(!val.as_boolean().unwrap());
let val = ConditionValue::String("true".to_string());
assert!(val.as_boolean().unwrap());
let val = ConditionValue::String("false".to_string());
assert!(!val.as_boolean().unwrap());
let val = ConditionValue::String("maybe".to_string());
assert!(val.as_boolean().is_err());
let val = ConditionValue::Number(1.0);
assert!(val.as_boolean().is_err());
let val = ConditionValue::Array(vec!["a".to_string()]);
assert!(val.as_boolean().is_err());
}
#[test]
fn test_condition_value_as_array() {
use crate::ConditionValue;
let arr = vec!["a".to_string(), "b".to_string()];
let val = ConditionValue::Array(arr.clone());
assert_eq!(val.as_array().unwrap(), &arr);
let val = ConditionValue::String("test".to_string());
assert!(val.as_array().is_err());
let val = ConditionValue::Number(123.45);
assert!(val.as_array().is_err());
let val = ConditionValue::Boolean(true);
assert!(val.as_array().is_err());
}
#[test]
fn test_condition_value_from_json_value() {
use crate::ConditionValue;
use serde_json::Value;
let json = Value::String("test".to_string());
let val = ConditionValue::from(json);
assert!(matches!(val, ConditionValue::String(_)));
let json = Value::Number(serde_json::Number::from_f64(123.45).unwrap());
let val = ConditionValue::from(json);
assert!(matches!(val, ConditionValue::Number(_)));
let json = Value::Bool(true);
let val = ConditionValue::from(json);
assert!(matches!(val, ConditionValue::Boolean(_)));
let json = Value::Array(vec![
Value::String("a".to_string()),
Value::String("b".to_string()),
]);
let val = ConditionValue::from(json);
assert!(matches!(val, ConditionValue::Array(_)));
let json = Value::Null;
let val = ConditionValue::from(json);
assert!(matches!(val, ConditionValue::String(_)));
let json = Value::Object(serde_json::Map::new());
let val = ConditionValue::from(json);
assert!(matches!(val, ConditionValue::String(_)));
}
#[test]
fn test_condition_error_display() {
use crate::evaluator::ConditionError;
let err = ConditionError::UnknownOperator("BadOp".to_string());
assert!(err.to_string().contains("Unknown operator"));
assert!(err.to_string().contains("BadOp"));
let err = ConditionError::TypeMismatch {
expected: "String".to_string(),
actual: "Number".to_string(),
};
assert!(err.to_string().contains("Type mismatch"));
assert!(err.to_string().contains("String"));
assert!(err.to_string().contains("Number"));
let err = ConditionError::InvalidBooleanValue;
assert!(err.to_string().contains("Invalid boolean value"));
let err = ConditionError::InvalidDate {
error: "parse error".to_string(),
};
assert!(err.to_string().contains("Invalid date value"));
assert!(err.to_string().contains("parse error"));
let err = ConditionError::MissingContextKey("aws:username".to_string());
assert!(err.to_string().contains("Missing context key"));
assert!(err.to_string().contains("aws:username"));
let err = ConditionError::InvalidConditionStructure("bad structure".to_string());
assert!(err.to_string().contains("Invalid condition structure"));
assert!(err.to_string().contains("bad structure"));
}
#[test]
fn test_condition_error_to_ami_error() {
use crate::error::AmiError;
use crate::evaluator::ConditionError;
let err = ConditionError::UnknownOperator("BadOp".to_string());
let ami_err: AmiError = err.into();
assert!(matches!(ami_err, AmiError::InvalidParameter { .. }));
}
#[test]
fn test_context_builder_all_methods() {
use crate::ConditionContext;
use chrono::Utc;
let context = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.principal_account("123456789012")
.principal_type("User")
.username("alice")
.userid("AIDAIOSFODNN7EXAMPLE")
.mfa_present(true)
.mfa_age(300)
.token_issue_time(Utc::now())
.secure_transport(true)
.source_ip("203.0.113.42")
.source_vpc("vpc-12345678")
.source_vpce("vpce-12345678")
.current_time(Utc::now())
.requested_region("us-east-1")
.referer("https://example.com")
.user_agent("Mozilla/5.0")
.resource_arn("arn:aws:s3:::bucket/key")
.resource_account("123456789012")
.principal_tag("Environment", "production")
.resource_tag("Project", "wami")
.request_tag("RequestId", "12345")
.tag_keys(vec!["Env".to_string(), "Owner".to_string()])
.tenant_id(12345)
.principal_tenant_id(12345)
.resource_tenant_id(67890)
.provider("AWS")
.source_provider("AWS")
.target_provider("GCP")
.custom_value(
"custom:key",
crate::ConditionValue::String("value".to_string()),
)
.build();
assert_eq!(
context.principal_arn,
Some("arn:aws:iam::123456789012:user/alice".to_string())
);
assert_eq!(context.username, Some("alice".to_string()));
assert_eq!(context.mfa_present, Some(true));
assert_eq!(context.tenant_id.as_deref(), Some("12345"));
}
#[test]
fn test_context_builder_principal_tag_role() {
use crate::ConditionContext;
let context = ConditionContext::builder()
.principal_tag_role(vec!["admin".to_string(), "user".to_string()])
.build();
assert_eq!(
context.principal_tags.get("Role"),
Some(&"admin".to_string())
);
}
#[test]
fn test_all_numeric_ifexists_operators() {
let context = ConditionContext::builder().mfa_age(300).build();
let test_cases = vec![
(
r#"{"NumericEqualsIfExists": {"aws:MultiFactorAuthAge": "300"}}"#,
true,
),
(
r#"{"NumericEqualsIfExists": {"aws:MultiFactorAuthAge": "600"}}"#,
false,
),
(
r#"{"NumericNotEqualsIfExists": {"aws:MultiFactorAuthAge": "300"}}"#,
false,
),
(
r#"{"NumericNotEqualsIfExists": {"aws:MultiFactorAuthAge": "600"}}"#,
true,
),
(
r#"{"NumericLessThanIfExists": {"aws:MultiFactorAuthAge": "400"}}"#,
true,
),
(
r#"{"NumericLessThanIfExists": {"aws:MultiFactorAuthAge": "200"}}"#,
false,
),
(
r#"{"NumericLessThanEqualsIfExists": {"aws:MultiFactorAuthAge": "300"}}"#,
true,
),
(
r#"{"NumericLessThanEqualsIfExists": {"aws:MultiFactorAuthAge": "200"}}"#,
false,
),
(
r#"{"NumericGreaterThanIfExists": {"aws:MultiFactorAuthAge": "200"}}"#,
true,
),
(
r#"{"NumericGreaterThanIfExists": {"aws:MultiFactorAuthAge": "400"}}"#,
false,
),
(
r#"{"NumericGreaterThanEqualsIfExists": {"aws:MultiFactorAuthAge": "300"}}"#,
true,
),
(
r#"{"NumericGreaterThanEqualsIfExists": {"aws:MultiFactorAuthAge": "400"}}"#,
false,
),
];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_all_date_ifexists_operators() {
let now = chrono::Utc::now();
let past = now - chrono::Duration::hours(1);
let future = now + chrono::Duration::hours(1);
let context = ConditionContext::builder().current_time(now).build();
let test_cases = vec![
(
format!(
r#"{{"DateEqualsIfExists": {{"aws:CurrentTime": "{}"}}}}"#,
now.to_rfc3339()
),
true,
),
(
format!(
r#"{{"DateNotEqualsIfExists": {{"aws:CurrentTime": "{}"}}}}"#,
now.to_rfc3339()
),
false,
),
(
format!(
r#"{{"DateLessThanIfExists": {{"aws:CurrentTime": "{}"}}}}"#,
future.to_rfc3339()
),
true,
),
(
format!(
r#"{{"DateLessThanEqualsIfExists": {{"aws:CurrentTime": "{}"}}}}"#,
now.to_rfc3339()
),
true,
),
(
format!(
r#"{{"DateGreaterThanIfExists": {{"aws:CurrentTime": "{}"}}}}"#,
past.to_rfc3339()
),
true,
),
(
format!(
r#"{{"DateGreaterThanEqualsIfExists": {{"aws:CurrentTime": "{}"}}}}"#,
now.to_rfc3339()
),
true,
),
];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_string(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition");
}
}
#[test]
fn test_all_arn_ifexists_operators() {
let context = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.build();
let test_cases = vec![
(
r#"{"ArnEqualsIfExists": {"aws:PrincipalArn": "arn:aws:iam::123456789012:user/alice"}}"#,
true,
),
(
r#"{"ArnEqualsIfExists": {"aws:PrincipalArn": "arn:aws:iam::123456789012:user/bob"}}"#,
false,
),
(
r#"{"ArnNotEqualsIfExists": {"aws:PrincipalArn": "arn:aws:iam::123456789012:user/alice"}}"#,
false,
),
(
r#"{"ArnNotEqualsIfExists": {"aws:PrincipalArn": "arn:aws:iam::123456789012:user/bob"}}"#,
true,
),
(
r#"{"ArnLikeIfExists": {"aws:PrincipalArn": "arn:aws:iam::*:user/*"}}"#,
true,
),
(
r#"{"ArnLikeIfExists": {"aws:PrincipalArn": "arn:aws:s3:::*"}}"#,
false,
),
(
r#"{"ArnNotLikeIfExists": {"aws:PrincipalArn": "arn:aws:iam::*:user/*"}}"#,
false,
),
(
r#"{"ArnNotLikeIfExists": {"aws:PrincipalArn": "arn:aws:s3:::*"}}"#,
true,
),
];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_all_forallvalues_operators() {
let context = ConditionContext::builder()
.tag_keys(vec!["Env".to_string(), "Owner".to_string()])
.source_ip("203.0.113.42")
.mfa_age(300)
.current_time(chrono::Utc::now())
.build();
let test_cases = vec![
(
r#"{"ForAllValues:StringNotEquals": {"aws:TagKeys": ["Project", "Team"]}}"#,
true,
), (
r#"{"ForAllValues:StringLike": {"aws:TagKeys": ["Env*", "Own*"]}}"#,
true,
),
(
r#"{"ForAllValues:StringNotLike": {"aws:TagKeys": ["Pro*", "Tea*"]}}"#,
true,
),
(
r#"{"ForAllValues:ArnEquals": {"aws:TagKeys": ["arn:aws:iam::123456789012:user/alice"]}}"#,
false,
), (
r#"{"ForAllValues:ArnLike": {"aws:TagKeys": ["arn:aws:iam::*:user/*"]}}"#,
false,
),
];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context);
assert_eq!(result, Ok(expected), "{json}");
}
}
#[test]
fn test_all_foranyvalue_operators() {
let context = ConditionContext::builder()
.tag_keys(vec!["Env".to_string(), "Owner".to_string()])
.source_ip("203.0.113.42")
.mfa_age(300)
.current_time(chrono::Utc::now())
.build();
let test_cases = vec![
(
r#"{"ForAnyValue:StringNotEquals": {"aws:TagKeys": ["Project", "Team"]}}"#,
true,
), (
r#"{"ForAnyValue:StringLike": {"aws:TagKeys": ["Env*", "Pro*"]}}"#,
true,
), (
r#"{"ForAnyValue:StringNotLike": {"aws:TagKeys": ["Pro*", "Tea*"]}}"#,
true,
), (
r#"{"ForAnyValue:ArnEquals": {"aws:TagKeys": ["arn:aws:iam::123456789012:user/alice"]}}"#,
false,
),
(
r#"{"ForAnyValue:ArnLike": {"aws:TagKeys": ["arn:aws:iam::*:user/*"]}}"#,
false,
),
];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context);
assert_eq!(result, Ok(expected), "{json}");
}
}
#[test]
fn test_operator_from_str_all_variants() {
use crate::operators::ConditionOperator;
use std::str::FromStr;
let operators = vec![
"StringEquals",
"StringNotEquals",
"StringLike",
"StringNotLike",
"StringEqualsIgnoreCase",
"StringNotEqualsIgnoreCase",
"StringEqualsIfExists",
"StringNotEqualsIfExists",
"StringLikeIfExists",
"StringNotLikeIfExists",
"NumericEquals",
"NumericNotEquals",
"NumericLessThan",
"NumericLessThanEquals",
"NumericGreaterThan",
"NumericGreaterThanEquals",
"NumericEqualsIfExists",
"NumericNotEqualsIfExists",
"NumericLessThanIfExists",
"NumericLessThanEqualsIfExists",
"NumericGreaterThanIfExists",
"NumericGreaterThanEqualsIfExists",
"DateEquals",
"DateNotEquals",
"DateLessThan",
"DateLessThanEquals",
"DateGreaterThan",
"DateGreaterThanEquals",
"DateEqualsIfExists",
"DateNotEqualsIfExists",
"DateLessThanIfExists",
"DateLessThanEqualsIfExists",
"DateGreaterThanIfExists",
"DateGreaterThanEqualsIfExists",
"IpAddress",
"NotIpAddress",
"IpAddressIfExists",
"NotIpAddressIfExists",
"ArnEquals",
"ArnNotEquals",
"ArnLike",
"ArnNotLike",
"ArnEqualsIfExists",
"ArnNotEqualsIfExists",
"ArnLikeIfExists",
"ArnNotLikeIfExists",
"Bool",
"BoolIfExists",
"BinaryEquals",
"BinaryEqualsIfExists",
"Null",
"NullIfExists",
"ForAllValues:StringEquals",
"ForAllValues:StringNotEquals",
"ForAllValues:StringLike",
"ForAllValues:StringNotLike",
"ForAllValues:ArnEquals",
"ForAllValues:ArnLike",
"ForAllValues:NumericLessThan",
"ForAllValues:NumericGreaterThan",
"ForAllValues:IpAddress",
"ForAllValues:DateLessThan",
"ForAllValues:DateGreaterThan",
"ForAnyValue:StringEquals",
"ForAnyValue:StringNotEquals",
"ForAnyValue:StringLike",
"ForAnyValue:StringNotLike",
"ForAnyValue:ArnEquals",
"ForAnyValue:ArnLike",
"ForAnyValue:NumericLessThan",
"ForAnyValue:NumericGreaterThan",
"ForAnyValue:IpAddress",
"ForAnyValue:DateLessThan",
"ForAnyValue:DateGreaterThan",
];
for op_str in operators {
let result = ConditionOperator::from_str(op_str);
assert!(result.is_ok(), "Failed to parse operator: {}", op_str);
}
let result = ConditionOperator::from_str("InvalidOperator");
assert!(result.is_err());
}
#[test]
fn test_operator_evaluation_error_paths() {
use crate::operators::{evaluate_operator, ConditionOperator};
use crate::ConditionValue;
let test_cases = vec![
(
ConditionOperator::NumericEquals,
Some(ConditionValue::String("not-a-number".to_string())),
ConditionValue::Number(123.0),
),
(
ConditionOperator::DateEquals,
Some(ConditionValue::String("invalid-date".to_string())),
ConditionValue::String("2024-01-01T00:00:00Z".to_string()),
),
(
ConditionOperator::Bool,
Some(ConditionValue::String("maybe".to_string())),
ConditionValue::Boolean(true),
),
(
ConditionOperator::ForAllValuesStringEquals,
Some(ConditionValue::String("single".to_string())),
ConditionValue::Number(123.0),
), ];
let errors = [
ConditionError::TypeMismatch {
expected: "a finite Number".to_string(),
actual: "String".to_string(),
},
ConditionError::InvalidDate {
error: "input contains invalid characters".to_string(),
},
ConditionError::InvalidBooleanValue,
ConditionError::TypeMismatch {
expected: "Array".to_string(),
actual: "Number".to_string(),
},
];
for ((op, actual, expected), error) in test_cases.into_iter().zip(errors) {
assert_eq!(
evaluate_operator(op, actual, &expected),
Err(error),
"{op:?}"
);
}
}
#[test]
fn test_parse_condition_block_error_paths() {
use crate::evaluator::parse_condition_block;
use serde_json::Value;
let invalid_cases = vec![
Value::String("not an object".to_string()),
Value::Number(serde_json::Number::from(123)),
Value::Bool(true),
Value::Array(vec![]),
serde_json::json!({
"StringEquals": "not an object"
}),
serde_json::json!({
"StringEquals": null
}),
];
for invalid_value in invalid_cases {
let result = parse_condition_block(&invalid_value);
assert!(
result.is_err(),
"Should error on invalid structure: {:?}",
invalid_value
);
}
}
#[test]
fn test_evaluator_error_display_coverage() {
use crate::evaluator::ConditionError;
let errors = vec![
ConditionError::UnknownOperator("TestOp".to_string()),
ConditionError::TypeMismatch {
expected: "String".to_string(),
actual: "Number".to_string(),
},
ConditionError::InvalidBooleanValue,
ConditionError::InvalidDate {
error: "parse error".to_string(),
},
ConditionError::MissingContextKey("key".to_string()),
ConditionError::InvalidConditionStructure("bad".to_string()),
];
for err in errors {
let _display = format!("{}", err);
let _debug = format!("{:?}", err);
}
}
#[test]
fn test_condition_value_from_json_edge_cases() {
use crate::ConditionValue;
use serde_json::Value;
let json = Value::Number(serde_json::Number::from(0));
let val = ConditionValue::from(json);
assert!(matches!(val, ConditionValue::Number(_)));
let json = Value::Number(serde_json::Number::from(-123));
let val = ConditionValue::from(json);
assert!(matches!(val, ConditionValue::Number(_)));
let json = Value::Array(vec![
Value::String("a".to_string()),
Value::Number(serde_json::Number::from(123)),
Value::Bool(true),
Value::String("b".to_string()),
]);
let val = ConditionValue::from(json);
match val {
ConditionValue::Array(arr) => {
assert_eq!(arr.len(), 2); assert_eq!(arr, vec!["a".to_string(), "b".to_string()]);
}
_ => panic!("Expected Array"),
}
let json = Value::Array(vec![]);
let val = ConditionValue::from(json);
match val {
ConditionValue::Array(arr) => assert!(arr.is_empty()),
_ => panic!("Expected Array"),
}
}
#[test]
fn test_ip_address_actual_not_string() {
let context = ConditionContext::builder()
.custom_value("ip:key", crate::ConditionValue::Number(123.0))
.build();
let condition = unchecked(
r#"{
"IpAddress": {
"ip:key": "127.0.0.1"
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "an IP address".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_bool_operator_missing_key() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"Bool": {
"aws:MultiFactorAuthPresent": "true"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result);
}
#[test]
fn test_forallvalues_string_equals_missing_key() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"ForAllValues:StringEquals": {
"aws:TagKeys": ["Env", "Owner"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_ip_address_cidr_parse_failure() {
parse_err(r#"{"IpAddress": {"aws:SourceIp": "203.0.113.0/invalid"}}"#);
}
#[test]
fn test_ip_address_ipv4_parse_failure() {
let context = ConditionContext::builder().source_ip("203.0.113").build();
let condition = unchecked(
r#"{
"IpAddress": {
"aws:SourceIp": "203.0.113.0/24"
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "an IP address".to_string(),
actual: "String".to_string()
})
);
}
#[test]
fn test_ip_address_ipv6_no_colon() {
let context = ConditionContext::builder()
.source_ip("203.0.113.42")
.build();
let condition = parse_condition_block_from_json(
r#"{
"IpAddress": {
"aws:SourceIp": "2001:db8::/32"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result);
}
#[test]
fn test_ip_address_cidr_no_slash() {
let context = ConditionContext::builder()
.source_ip("203.0.113.42")
.build();
let condition = parse_condition_block_from_json(
r#"{
"IpAddress": {
"aws:SourceIp": "203.0.113.42"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_ip_address_cidr_prefix_len_too_large() {
parse_err(r#"{"IpAddress": {"aws:SourceIp": "203.0.113.0/33"}}"#);
}
#[test]
fn test_ip_address_ipv6_prefix_len_edge_case() {
let ip = "2001:db8::1";
let context = ConditionContext::builder().source_ip(ip).build();
let condition = parse_condition_block_from_json(&format!(
r#"{{
"IpAddress": {{
"aws:SourceIp": "{}/128"
}}
}}"#,
ip
));
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_string_not_operators() {
let context = ConditionContext::builder().username("alice").build();
let test_cases = vec![
(r#"{"StringNotEquals": {"aws:username": "bob"}}"#, true), (r#"{"StringNotEquals": {"aws:username": "alice"}}"#, false), (r#"{"StringNotLike": {"aws:username": "b*"}}"#, true), (r#"{"StringNotLike": {"aws:username": "a*"}}"#, false), (
r#"{"StringNotEqualsIgnoreCase": {"aws:username": "BOB"}}"#,
true,
), (
r#"{"StringNotEqualsIgnoreCase": {"aws:username": "ALICE"}}"#,
false,
), ];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_string_not_ifexists_operators() {
let context1 = ConditionContext::builder().username("alice").build();
let context2 = ConditionContext::builder().build();
let test_cases = vec![
(
r#"{"StringNotEqualsIfExists": {"aws:username": "bob"}}"#,
true,
true,
), (
r#"{"StringNotEqualsIfExists": {"aws:username": "alice"}}"#,
false,
true,
), (
r#"{"StringNotEqualsIfExists": {"aws:PrincipalType": "User"}}"#,
true,
false,
), (
r#"{"StringNotLikeIfExists": {"aws:username": "b*"}}"#,
true,
true,
), (
r#"{"StringNotLikeIfExists": {"aws:username": "a*"}}"#,
false,
true,
), (
r#"{"StringNotLikeIfExists": {"aws:PrincipalType": "User*"}}"#,
true,
false,
), ];
for (json, expected, use_context1) in test_cases {
let context = if use_context1 { &context1 } else { &context2 };
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_numeric_not_equals() {
let context = ConditionContext::builder().mfa_age(300).build();
let test_cases = vec![
(
r#"{"NumericNotEquals": {"aws:MultiFactorAuthAge": "300"}}"#,
false,
), (
r#"{"NumericNotEquals": {"aws:MultiFactorAuthAge": "600"}}"#,
true,
), (
r#"{"NumericNotEquals": {"aws:MultiFactorAuthAge": "299"}}"#,
true,
), ];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_date_not_equals() {
let now = chrono::Utc::now();
let past = now - chrono::Duration::hours(1);
let context = ConditionContext::builder().current_time(now).build();
let test_cases = vec![
(
format!(
r#"{{"DateNotEquals": {{"aws:CurrentTime": "{}"}}}}"#,
now.to_rfc3339()
),
false,
), (
format!(
r#"{{"DateNotEquals": {{"aws:CurrentTime": "{}"}}}}"#,
past.to_rfc3339()
),
true,
), ];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_string(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition");
}
}
#[test]
fn test_date_not_equals_ifexists() {
let now = chrono::Utc::now();
let past = now - chrono::Duration::hours(1);
let context1 = ConditionContext::builder().current_time(now).build();
let context2 = ConditionContext::builder().build();
let test_cases = vec![
(
format!(
r#"{{"DateNotEqualsIfExists": {{"aws:CurrentTime": "{}"}}}}"#,
now.to_rfc3339()
),
false,
true,
), (
format!(
r#"{{"DateNotEqualsIfExists": {{"aws:CurrentTime": "{}"}}}}"#,
past.to_rfc3339()
),
true,
true,
), (
format!(
r#"{{"DateNotEqualsIfExists": {{"aws:TokenIssueTime": "{}"}}}}"#,
now.to_rfc3339()
),
true,
false,
), ];
for (json, expected, use_context1) in test_cases {
let context = if use_context1 { &context1 } else { &context2 };
let condition = parse_condition_block_from_string(json);
let result = evaluate_condition_block(&condition, context).unwrap();
assert_eq!(result, expected, "Failed for condition");
}
}
#[test]
fn test_binary_equals_ifexists() {
let context1 = ConditionContext::builder()
.custom_value(
"binary:key",
crate::ConditionValue::String("dGVzdA==".to_string()),
)
.build();
let context2 = ConditionContext::builder().build();
let condition1 = parse_condition_block_from_json(
r#"{
"BinaryEqualsIfExists": {
"binary:key": "dGVzdA=="
}
}"#,
);
let result1 = evaluate_condition_block(&condition1, &context1).unwrap();
assert!(result1);
let condition2 = parse_condition_block_from_json(
r#"{
"BinaryEqualsIfExists": {
"binary:key": "dGVzdA=="
}
}"#,
);
let result2 = evaluate_condition_block(&condition2, &context2).unwrap();
assert!(result2); }
#[test]
fn test_null_ifexists() {
let context1 = ConditionContext::builder().username("alice").build();
let context2 = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"NullIfExists": {
"aws:username": "true"
}
}"#,
);
let result1 = evaluate_condition_block(&condition, &context1).unwrap();
assert!(!result1);
let result2 = evaluate_condition_block(&condition, &context2).unwrap();
assert!(result2); }
#[test]
fn test_arn_not_equals_ifexists() {
let context1 = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.build();
let context2 = ConditionContext::builder().build();
let test_cases = vec![
(
r#"{"ArnNotEqualsIfExists": {"aws:PrincipalArn": "arn:aws:iam::123456789012:user/alice"}}"#,
false,
true,
), (
r#"{"ArnNotEqualsIfExists": {"aws:PrincipalArn": "arn:aws:iam::123456789012:user/bob"}}"#,
true,
true,
), (
r#"{"ArnNotEqualsIfExists": {"aws:PrincipalArn": "arn:aws:iam::123456789012:user/alice"}}"#,
true,
false,
), ];
for (json, expected, use_context1) in test_cases {
let context = if use_context1 { &context1 } else { &context2 };
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_arn_not_like_ifexists() {
let context1 = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.build();
let context2 = ConditionContext::builder().build();
let test_cases = vec![
(
r#"{"ArnNotLikeIfExists": {"aws:PrincipalArn": "arn:aws:iam::*:user/*"}}"#,
false,
true,
), (
r#"{"ArnNotLikeIfExists": {"aws:PrincipalArn": "arn:aws:s3:::*"}}"#,
true,
true,
), (
r#"{"ArnNotLikeIfExists": {"aws:PrincipalArn": "arn:aws:iam::*:user/*"}}"#,
true,
false,
), ];
for (json, expected, use_context1) in test_cases {
let context = if use_context1 { &context1 } else { &context2 };
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_wildcard_pattern_edge_cases() {
let test_cases = vec![
("", "*", true), ("", "?", false), ("a", "?", true), ("ab", "??", true), ("abc", "a?c", true), ("abc", "a??c", false), ("", "a*", false), ("a", "a*", true), ("ab", "a*", true), ("ba", "*a", true), ("ba", "a*", false), ("abc", "*b*", true), ("abc", "a*c", true), ("abc", "a*e", false), ("abcde", "a*e", true), ("test", "t*st", true), ("test", "t?st", true), ("test", "t??st", false), ];
for (value, pattern, expected) in test_cases {
let context = ConditionContext::builder().username(value).build();
let condition_json = format!(
r#"{{
"StringLike": {{
"aws:username": "{}"
}}
}}"#,
pattern
);
let condition = parse_condition_block_from_string(condition_json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(
result, expected,
"Pattern '{}' should match '{}' = {}",
pattern, value, expected
);
}
}
#[test]
fn test_date_operator_error_paths() {
let context = ConditionContext::builder()
.current_time(chrono::Utc::now())
.build();
parse_err(r#"{"DateEquals": {"aws:CurrentTime": "not-a-date"}}"#);
parse_err(r#"{"DateEquals": {"aws:CurrentTime": "123"}}"#);
let test_cases = vec![
(
r#"{"DateEquals": {"aws:TokenIssueTime": "2024-01-01T00:00:00Z"}}"#,
false,
),
];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_forallvalues_string_single_value() {
let context = ConditionContext::builder().username("alice").build();
let condition = parse_condition_block_from_json(
r#"{
"ForAllValues:StringEquals": {
"aws:username": ["alice", "bob"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
let condition2 = parse_condition_block_from_json(
r#"{
"ForAllValues:StringEquals": {
"aws:username": ["bob", "charlie"]
}
}"#,
);
let result2 = evaluate_condition_block(&condition2, &context).unwrap();
assert!(!result2); }
#[test]
fn test_forallvalues_string_like_single_value() {
let context = ConditionContext::builder().username("alice").build();
let condition = parse_condition_block_from_json(
r#"{
"ForAllValues:StringLike": {
"aws:username": ["a*", "b*"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
let condition2 = parse_condition_block_from_json(
r#"{
"ForAllValues:StringLike": {
"aws:username": ["b*", "c*"]
}
}"#,
);
let result2 = evaluate_condition_block(&condition2, &context).unwrap();
assert!(!result2); }
#[test]
fn test_forallvalues_arn_single_value() {
let context = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.build();
let condition1 = parse_condition_block_from_json(
r#"{
"ForAllValues:ArnEquals": {
"aws:PrincipalArn": ["arn:aws:iam::123456789012:user/alice", "arn:aws:iam::123456789012:user/bob"]
}
}"#,
);
let result1 = evaluate_condition_block(&condition1, &context).unwrap();
assert!(result1);
let condition2 = parse_condition_block_from_json(
r#"{
"ForAllValues:ArnLike": {
"aws:PrincipalArn": ["arn:aws:iam::*:user/*", "arn:aws:s3:::*"]
}
}"#,
);
let result2 = evaluate_condition_block(&condition2, &context).unwrap();
assert!(result2); }
#[test]
fn test_foranyvalue_string_single_value() {
let context = ConditionContext::builder().username("alice").build();
let condition = parse_condition_block_from_json(
r#"{
"ForAnyValue:StringEquals": {
"aws:username": ["alice", "bob"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
let condition2 = parse_condition_block_from_json(
r#"{
"ForAnyValue:StringLike": {
"aws:username": ["a*", "b*"]
}
}"#,
);
let result2 = evaluate_condition_block(&condition2, &context).unwrap();
assert!(result2); }
#[test]
fn test_foranyvalue_arn_single_value() {
let context = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.build();
let condition1 = parse_condition_block_from_json(
r#"{
"ForAnyValue:ArnEquals": {
"aws:PrincipalArn": ["arn:aws:iam::123456789012:user/alice", "arn:aws:iam::123456789012:user/bob"]
}
}"#,
);
let result1 = evaluate_condition_block(&condition1, &context).unwrap();
assert!(result1);
let condition2 = parse_condition_block_from_json(
r#"{
"ForAnyValue:ArnLike": {
"aws:PrincipalArn": ["arn:aws:iam::*:user/*", "arn:aws:s3:::*"]
}
}"#,
);
let result2 = evaluate_condition_block(&condition2, &context).unwrap();
assert!(result2); }
#[test]
fn test_ip_address_array_handling() {
let context = ConditionContext::builder()
.source_ip("203.0.113.42")
.build();
let condition = parse_condition_block_from_json(
r#"{
"IpAddress": {
"aws:SourceIp": ["203.0.113.0/24", "198.51.100.0/24"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
let condition2 = parse_condition_block_from_json(
r#"{
"NotIpAddress": {
"aws:SourceIp": ["198.51.100.0/24", "192.0.2.0/24"]
}
}"#,
);
let result2 = evaluate_condition_block(&condition2, &context).unwrap();
assert!(result2); }
#[test]
fn test_ip_parsing_edge_cases() {
let test_cases = vec![
("2001:db8::1", "2001:db8::/32", true),
("2001:db8::1", "2001:db9::/32", false),
("not-an-ip", "203.0.113.0/24", false),
("203.0.113.42", "203.0.113.42", true), ];
parse_err(r#"{"IpAddress": {"aws:SourceIp": "203.0.113.0/"}}"#);
parse_err(r#"{"IpAddress": {"aws:SourceIp": "203.0.113.0/33"}}"#);
for (ip, cidr, expected) in test_cases {
let context = ConditionContext::builder().source_ip(ip).build();
let condition_json = format!(
r#"{{
"IpAddress": {{
"aws:SourceIp": "{}"
}}
}}"#,
cidr
);
let condition = parse_condition_block_from_string(condition_json);
let result = evaluate_condition_block(&condition, &context);
if let Ok(val) = result {
assert_eq!(
val, expected,
"IP {} in CIDR {} should be {}",
ip, cidr, expected
);
}
}
}
#[test]
fn test_forallvalues_empty_actual_edge_cases() {
let context = ConditionContext::builder()
.tag_keys(vec![]) .build();
let test_cases = vec![
(
r#"{"ForAllValues:StringEquals": {"aws:TagKeys": ["Env", "Owner"]}}"#,
true,
),
(
r#"{"ForAllValues:StringLike": {"aws:TagKeys": ["Env*", "Own*"]}}"#,
true,
),
(
r#"{"ForAllValues:ArnEquals": {"aws:TagKeys": ["arn:aws:iam::123456789012:user/alice"]}}"#,
true,
),
(
r#"{"ForAllValues:ArnLike": {"aws:TagKeys": ["arn:aws:iam::*:user/*"]}}"#,
true,
),
];
for (json, expected) in test_cases {
let condition = unchecked(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_foranyvalue_empty_actual_edge_cases() {
let context = ConditionContext::builder()
.tag_keys(vec![]) .build();
let test_cases = vec![
(
r#"{"ForAnyValue:StringEquals": {"aws:TagKeys": ["Env", "Owner"]}}"#,
false,
),
(
r#"{"ForAnyValue:StringLike": {"aws:TagKeys": ["Env*", "Own*"]}}"#,
false,
),
(
r#"{"ForAnyValue:ArnEquals": {"aws:TagKeys": ["arn:aws:iam::123456789012:user/alice"]}}"#,
false,
),
(
r#"{"ForAnyValue:ArnLike": {"aws:TagKeys": ["arn:aws:iam::*:user/*"]}}"#,
false,
),
];
for (json, expected) in test_cases {
let condition = unchecked(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_forallvalues_type_mismatch_paths() {
let message = parse_err(r#"{"ForAllValues:StringEquals": {"aws:TagKeys": "Env"}}"#);
assert!(message.contains("reads only a list"), "{message}");
let context2 = ConditionContext::builder().mfa_age(300).build();
let condition2 = unchecked(
r#"{
"ForAllValues:StringEquals": {
"aws:MultiFactorAuthAge": ["300"]
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition2, &context2),
Err(ConditionError::TypeMismatch {
expected: "a String or an Array of Strings".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_foranyvalue_type_mismatch_paths() {
let message = parse_err(r#"{"ForAnyValue:StringEquals": {"aws:TagKeys": "Env"}}"#);
assert!(message.contains("reads only a list"), "{message}");
let context2 = ConditionContext::builder().mfa_age(300).build();
let condition2 = unchecked(
r#"{
"ForAnyValue:StringEquals": {
"aws:MultiFactorAuthAge": ["300"]
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition2, &context2),
Err(ConditionError::TypeMismatch {
expected: "a String or an Array of Strings".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_string_operator_error_paths() {
let context1 = ConditionContext::builder()
.mfa_age(300) .build();
let condition1 = unchecked(
r#"{
"StringEquals": {
"aws:MultiFactorAuthAge": "300"
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition1, &context1),
Err(ConditionError::TypeMismatch {
expected: "String".to_string(),
actual: "Number".to_string()
})
);
let condition2 = unchecked(
r#"{
"StringLike": {
"aws:MultiFactorAuthAge": "3*"
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition2, &context1),
Err(ConditionError::TypeMismatch {
expected: "String".to_string(),
actual: "Number".to_string()
})
);
let condition3 = unchecked(
r#"{
"StringEqualsIgnoreCase": {
"aws:MultiFactorAuthAge": "300"
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition3, &context1),
Err(ConditionError::TypeMismatch {
expected: "String".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_keys_aws_userid_variant() {
let context = ConditionContext::builder()
.userid("AIDAIOSFODNN7EXAMPLE")
.build();
let condition1 = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:userid": "AIDAIOSFODNN7EXAMPLE"
}
}"#,
);
let result1 = evaluate_condition_block(&condition1, &context).unwrap();
assert!(result1);
let condition2 = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:userId": "AIDAIOSFODNN7EXAMPLE"
}
}"#,
);
let result2 = evaluate_condition_block(&condition2, &context).unwrap();
assert!(result2);
}
#[test]
fn test_keys_principal_account() {
let context = ConditionContext::builder()
.principal_account("123456789012")
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:PrincipalAccount": "123456789012"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_keys_principal_type() {
let context = ConditionContext::builder().principal_type("User").build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:PrincipalType": "User"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_keys_resource_account() {
let context = ConditionContext::builder()
.resource_account("123456789012")
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:ResourceAccount": "123456789012"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_keys_secure_transport() {
let context = ConditionContext::builder().secure_transport(true).build();
let condition = parse_condition_block_from_json(
r#"{
"Bool": {
"aws:SecureTransport": "true"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_keys_source_vpc_vpce() {
let context = ConditionContext::builder()
.source_vpc("vpc-12345678")
.source_vpce("vpce-12345678")
.build();
let condition1 = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:SourceVpc": "vpc-12345678"
}
}"#,
);
let result1 = evaluate_condition_block(&condition1, &context).unwrap();
assert!(result1);
let condition2 = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:SourceVpce": "vpce-12345678"
}
}"#,
);
let result2 = evaluate_condition_block(&condition2, &context).unwrap();
assert!(result2);
}
#[test]
fn test_keys_referer_user_agent() {
let context = ConditionContext::builder()
.referer("https://example.com")
.user_agent("Mozilla/5.0")
.build();
let condition1 = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:Referer": "https://example.com"
}
}"#,
);
let result1 = evaluate_condition_block(&condition1, &context).unwrap();
assert!(result1);
let condition2 = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:UserAgent": "Mozilla/5.0"
}
}"#,
);
let result2 = evaluate_condition_block(&condition2, &context).unwrap();
assert!(result2);
}
#[test]
fn test_keys_requested_region() {
let context = ConditionContext::builder()
.requested_region("us-east-1")
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"aws:RequestedRegion": "us-east-1"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_keys_token_issue_time() {
let now = chrono::Utc::now();
let context = ConditionContext::builder().token_issue_time(now).build();
let condition_json = format!(
r#"{{
"DateEquals": {{
"aws:TokenIssueTime": "{}"
}}
}}"#,
now.to_rfc3339()
);
let condition = parse_condition_block_from_string(condition_json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_keys_mfa_age() {
let context = ConditionContext::builder().mfa_age(300).build();
let condition = parse_condition_block_from_json(
r#"{
"NumericEquals": {
"aws:MultiFactorAuthAge": "300"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_keys_tag_keys_empty() {
let context = ConditionContext::builder()
.tag_keys(vec![]) .build();
let condition = parse_condition_block_from_json(
r#"{
"ForAllValues:StringEquals": {
"aws:TagKeys": ["Env"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_keys_tag_keys_non_empty() {
let context = ConditionContext::builder()
.tag_keys(vec!["Env".to_string(), "Owner".to_string()])
.build();
let condition = parse_condition_block_from_json(
r#"{
"ForAllValues:StringEquals": {
"aws:TagKeys": ["Env", "Owner"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_ipv4_parsing_edge_cases() {
let test_cases = vec![
("203.0.113.42", "203.0.113.0/24", true),
("203.0.113", "203.0.113.0/24", false),
("203.0.113.42.1", "203.0.113.0/24", false),
("203.0.113.abc", "203.0.113.0/24", false),
("203.0.113.42", "0.0.0.0/0", true), ("203.0.113.42", "203.0.113.42/32", true),
];
parse_err(r#"{"IpAddress": {"aws:SourceIp": "203.0.113.0/33"}}"#);
for (ip, cidr, expected) in test_cases {
let context = ConditionContext::builder().source_ip(ip).build();
let condition_json = format!(
r#"{{
"IpAddress": {{
"aws:SourceIp": "{}"
}}
}}"#,
cidr
);
let condition = parse_condition_block_from_string(condition_json);
let result = evaluate_condition_block(&condition, &context);
if let Ok(val) = result {
assert_eq!(
val, expected,
"IP {} in CIDR {} should be {}",
ip, cidr, expected
);
} else {
}
}
}
#[test]
fn test_ipv6_basic_matching() {
let test_cases = vec![
("2001:db8::1", "2001:db8::/32", true),
("2001:db8::1", "2001:db8::1", true), ("2001:db8::1", "2001:db9::/32", false),
];
parse_err(r#"{"IpAddress": {"aws:SourceIp": "2001:db8::1/129"}}"#);
for (ip, cidr, expected) in test_cases {
let context = ConditionContext::builder().source_ip(ip).build();
let condition_json = format!(
r#"{{
"IpAddress": {{
"aws:SourceIp": "{}"
}}
}}"#,
cidr
);
let condition = parse_condition_block_from_string(condition_json);
let result = evaluate_condition_block(&condition, &context);
if let Ok(val) = result {
assert_eq!(
val, expected,
"IP {} in CIDR {} should be {}",
ip, cidr, expected
);
}
}
}
#[test]
fn test_cidr_prefix_edge_cases() {
let test_cases = vec![
("203.0.113.42", "0.0.0.0/0", true),
("198.51.100.42", "0.0.0.0/0", true),
("203.0.113.42", "203.0.0.0/8", true),
("198.51.100.42", "203.0.0.0/8", false),
("203.0.113.42", "203.0.0.0/16", true),
("203.1.113.42", "203.0.0.0/16", false),
("203.0.113.42", "203.0.113.0/24", true),
("203.0.114.42", "203.0.113.0/24", false),
("203.0.113.42", "203.0.113.42/32", true),
("203.0.113.43", "203.0.113.42/32", false),
];
for (ip, cidr, expected) in test_cases {
let context = ConditionContext::builder().source_ip(ip).build();
let condition_json = format!(
r#"{{
"IpAddress": {{
"aws:SourceIp": "{}"
}}
}}"#,
cidr
);
let condition = parse_condition_block_from_string(condition_json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(
result, expected,
"IP {} in CIDR {} should be {}",
ip, cidr, expected
);
}
}
#[test]
fn test_cidr_partial_byte_matching() {
let test_cases = vec![
("203.0.113.0", "203.0.113.0/25", true),
("203.0.113.127", "203.0.113.0/25", true),
("203.0.113.128", "203.0.113.0/25", false), ("203.0.113.0", "203.0.113.0/26", true),
("203.0.113.63", "203.0.113.0/26", true),
("203.0.113.64", "203.0.113.0/26", false), ("203.0.113.0", "203.0.113.0/28", true),
("203.0.113.15", "203.0.113.0/28", true),
("203.0.113.16", "203.0.113.0/28", false), ];
for (ip, cidr, expected) in test_cases {
let context = ConditionContext::builder().source_ip(ip).build();
let condition_json = format!(
r#"{{
"IpAddress": {{
"aws:SourceIp": "{}"
}}
}}"#,
cidr
);
let condition = parse_condition_block_from_string(condition_json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(
result, expected,
"IP {} in CIDR {} should be {}",
ip, cidr, expected
);
}
}
#[test]
fn test_wildcard_pattern_complex_cases() {
let test_cases = vec![
("abc", "a*c", true),
("abc", "a*b*c", true), ("abcde", "a*e", true),
("abcde", "a*c*e", true),
("abc", "*b*", true),
("abc", "*d*", false),
("abc", "a?c", true),
("abc", "a??c", false), ("abcd", "a??d", true), ("abc", "a?*c", true),
("abc", "a*?c", true),
("abcd", "a?*d", true),
("ab", "abc", false),
("ab", "a?c", false),
("abc", "ab", false),
];
for (value, pattern, expected) in test_cases {
let context = ConditionContext::builder().username(value).build();
let condition_json = format!(
r#"{{
"StringLike": {{
"aws:username": "{}"
}}
}}"#,
pattern
);
let condition = parse_condition_block_from_string(condition_json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(
result, expected,
"Pattern '{}' should match '{}' = {}",
pattern, value, expected
);
}
}
#[test]
fn test_wildcard_pattern_star_at_end() {
let context = ConditionContext::builder().username("alice").build();
let condition = parse_condition_block_from_json(
r#"{
"StringLike": {
"aws:username": "a*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_wildcard_pattern_star_consumes_rest() {
let test_cases = vec![
("abc", "*bc", true),
("abc", "a*c", true),
("abc", "ab*", true),
("abc", "*abc", true),
("abc", "abc*", true),
("abc", "*abc*", true),
];
for (value, pattern, expected) in test_cases {
let context = ConditionContext::builder().username(value).build();
let condition_json = format!(
r#"{{
"StringLike": {{
"aws:username": "{}"
}}
}}"#,
pattern
);
let condition = parse_condition_block_from_string(condition_json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(
result, expected,
"Pattern '{}' should match '{}' = {}",
pattern, value, expected
);
}
}
#[test]
fn test_binary_equals_error_paths() {
let context1 = ConditionContext::builder()
.custom_value("binary:key", crate::ConditionValue::Number(123.0)) .build();
let condition = unchecked(
r#"{
"BinaryEquals": {
"binary:key": "dGVzdA=="
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context1),
Err(ConditionError::TypeMismatch {
expected: "String".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_null_operator_with_false() {
let context1 = ConditionContext::builder().username("alice").build();
let context2 = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"Null": {
"aws:username": "false"
}
}"#,
);
let result1 = evaluate_condition_block(&condition, &context1).unwrap();
assert!(result1);
let result2 = evaluate_condition_block(&condition, &context2).unwrap();
assert!(!result2); }
#[test]
fn test_forallvalues_with_none_actual() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"ForAllValues:StringEquals": {
"aws:TagKeys": ["Env", "Owner"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_foranyvalue_with_none_actual() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"ForAnyValue:StringEquals": {
"aws:TagKeys": ["Env", "Owner"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_string_like_ifexists_missing_key() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"StringLikeIfExists": {
"aws:username": "a*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_not_ip_address_ifexists_missing_key() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"NotIpAddressIfExists": {
"aws:SourceIp": ["203.0.113.0/24"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_arn_not_equals_missing_key() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"ArnNotEquals": {
"aws:PrincipalArn": "arn:aws:iam::123456789012:user/alice"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_arn_not_like_missing_key() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"ArnNotLike": {
"aws:PrincipalArn": "arn:aws:iam::*:user/*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_string_equals_ignore_case_missing_key() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"StringEqualsIgnoreCase": {
"aws:username": "ALICE"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_numeric_operators_missing_key() {
let context = ConditionContext::builder().build();
let test_cases = vec![
(
r#"{"NumericLessThan": {"aws:MultiFactorAuthAge": "400"}}"#,
false,
),
(
r#"{"NumericLessThanEquals": {"aws:MultiFactorAuthAge": "400"}}"#,
false,
),
(
r#"{"NumericGreaterThan": {"aws:MultiFactorAuthAge": "100"}}"#,
false,
),
(
r#"{"NumericGreaterThanEquals": {"aws:MultiFactorAuthAge": "100"}}"#,
false,
),
];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_json(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition: {}", json);
}
}
#[test]
fn test_date_operators_missing_key() {
let context = ConditionContext::builder().build();
let now = chrono::Utc::now();
let test_cases = vec![
(
format!(
r#"{{"DateLessThan": {{"aws:TokenIssueTime": "{}"}}}}"#,
now.to_rfc3339()
),
false,
),
(
format!(
r#"{{"DateLessThanEquals": {{"aws:TokenIssueTime": "{}"}}}}"#,
now.to_rfc3339()
),
false,
),
(
format!(
r#"{{"DateGreaterThan": {{"aws:TokenIssueTime": "{}"}}}}"#,
now.to_rfc3339()
),
false,
),
(
format!(
r#"{{"DateGreaterThanEquals": {{"aws:TokenIssueTime": "{}"}}}}"#,
now.to_rfc3339()
),
false,
),
];
for (json, expected) in test_cases {
let condition = parse_condition_block_from_string(json);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert_eq!(result, expected, "Failed for condition");
}
}
#[test]
fn test_ip_address_missing_key() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"IpAddress": {
"aws:SourceIp": ["203.0.113.0/24"]
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_ip_address_type_mismatch() {
let context = ConditionContext::builder()
.mfa_age(300) .build();
let condition = unchecked(
r#"{
"IpAddress": {
"aws:MultiFactorAuthAge": ["203.0.113.0/24"]
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "an IP address".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_forallvalues_type_mismatch_non_array_string() {
let context = ConditionContext::builder()
.mfa_age(300) .build();
let condition = unchecked(
r#"{
"ForAllValues:StringEquals": {
"aws:MultiFactorAuthAge": ["300"]
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "a String or an Array of Strings".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_foranyvalue_type_mismatch_non_array_string() {
let context = ConditionContext::builder()
.mfa_age(300) .build();
let condition = unchecked(
r#"{
"ForAnyValue:StringEquals": {
"aws:MultiFactorAuthAge": ["300"]
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "a String or an Array of Strings".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_arn_equals_missing_key() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"ArnEquals": {
"aws:PrincipalArn": "arn:aws:iam::123456789012:user/alice"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_arn_like_missing_key() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"ArnLike": {
"aws:PrincipalArn": "arn:aws:iam::*:user/*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_binary_equals_missing_key() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"BinaryEquals": {
"binary:key": "dGVzdA=="
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(!result); }
#[test]
fn test_null_missing_key() {
let context = ConditionContext::builder().build();
let condition = parse_condition_block_from_json(
r#"{
"Null": {
"aws:username": "true"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_string_like_type_mismatch_boolean() {
let context = ConditionContext::builder()
.mfa_present(true) .build();
let condition = unchecked(
r#"{
"StringLike": {
"aws:MultiFactorAuthPresent": "true*"
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "String".to_string(),
actual: "Boolean".to_string()
})
);
}
#[test]
fn test_date_operators_type_mismatch_number() {
let context = ConditionContext::builder()
.mfa_age(300) .build();
let now = chrono::Utc::now();
let test_cases = vec![
(
format!(
r#"{{"DateLessThan": {{"aws:MultiFactorAuthAge": "{}"}}}}"#,
now.to_rfc3339()
),
false,
),
(
format!(
r#"{{"DateLessThanEquals": {{"aws:MultiFactorAuthAge": "{}"}}}}"#,
now.to_rfc3339()
),
false,
),
(
format!(
r#"{{"DateGreaterThan": {{"aws:MultiFactorAuthAge": "{}"}}}}"#,
now.to_rfc3339()
),
false,
),
(
format!(
r#"{{"DateGreaterThanEquals": {{"aws:MultiFactorAuthAge": "{}"}}}}"#,
now.to_rfc3339()
),
false,
),
];
for (json, _answered_false) in test_cases {
let condition = unchecked_string(json);
let outcome = evaluate_condition_block(&condition, &context);
assert_eq!(
outcome,
Err(ConditionError::TypeMismatch {
expected: "String".to_string(),
actual: "Number".to_string()
})
);
}
}
#[test]
fn test_ip_address_type_mismatch_boolean() {
let context = ConditionContext::builder()
.secure_transport(true) .build();
let condition = unchecked(
r#"{
"IpAddress": {
"aws:SecureTransport": ["203.0.113.0/24"]
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "an IP address".to_string(),
actual: "Boolean".to_string()
})
);
}
#[test]
fn test_arn_equals_type_mismatch_number() {
let context = ConditionContext::builder()
.mfa_age(300) .build();
let condition = unchecked(
r#"{
"ArnEquals": {
"aws:MultiFactorAuthAge": "arn:aws:iam::123456789012:user/alice"
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "String".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_arn_like_type_mismatch_number() {
let context = ConditionContext::builder()
.mfa_age(300) .build();
let condition = unchecked(
r#"{
"ArnLike": {
"aws:MultiFactorAuthAge": "arn:aws:iam::*:user/*"
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "String".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_binary_equals_type_mismatch_boolean() {
let context = ConditionContext::builder()
.mfa_present(true) .build();
let condition = unchecked(
r#"{
"BinaryEquals": {
"aws:MultiFactorAuthPresent": "dGVzdA=="
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "String".to_string(),
actual: "Boolean".to_string()
})
);
}
#[test]
fn test_forallvalues_string_type_mismatch_number() {
let context = ConditionContext::builder()
.mfa_age(300) .build();
let condition = unchecked(
r#"{
"ForAllValues:StringEquals": {
"aws:MultiFactorAuthAge": ["300"]
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "a String or an Array of Strings".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_forallvalues_string_like_type_mismatch_number() {
let context = ConditionContext::builder()
.mfa_age(300) .build();
let condition = unchecked(
r#"{
"ForAllValues:StringLike": {
"aws:MultiFactorAuthAge": ["3*"]
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "a String or an Array of Strings".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_forallvalues_arn_type_mismatch_number() {
let context = ConditionContext::builder()
.mfa_age(300) .build();
let condition = unchecked(
r#"{
"ForAllValues:ArnEquals": {
"aws:MultiFactorAuthAge": ["arn:aws:iam::123456789012:user/alice"]
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "a String or an Array of Strings".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_foranyvalue_string_type_mismatch_number() {
let context = ConditionContext::builder()
.mfa_age(300) .build();
let condition = unchecked(
r#"{
"ForAnyValue:StringEquals": {
"aws:MultiFactorAuthAge": ["300"]
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "a String or an Array of Strings".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_foranyvalue_string_like_type_mismatch_number() {
let context = ConditionContext::builder()
.mfa_age(300) .build();
let condition = unchecked(
r#"{
"ForAnyValue:StringLike": {
"aws:MultiFactorAuthAge": ["3*"]
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "a String or an Array of Strings".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_foranyvalue_arn_type_mismatch_number() {
let context = ConditionContext::builder()
.mfa_age(300) .build();
let condition = unchecked(
r#"{
"ForAnyValue:ArnEquals": {
"aws:MultiFactorAuthAge": ["arn:aws:iam::123456789012:user/alice"]
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "a String or an Array of Strings".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_not_ip_address_ifexists_type_mismatch() {
let context = ConditionContext::builder()
.mfa_age(300) .build();
let condition = unchecked(
r#"{
"NotIpAddressIfExists": {
"aws:MultiFactorAuthAge": ["203.0.113.0/24"]
}
}"#,
);
assert_eq!(
evaluate_condition_block(&condition, &context),
Err(ConditionError::TypeMismatch {
expected: "an IP address".to_string(),
actual: "Number".to_string()
})
);
}
#[test]
fn test_wami_request_method_key() {
let context = ConditionContext::builder().request_method("POST").build();
let value = get_context_value("wami:RequestMethod", &context).unwrap();
assert_eq!(value, Some(ConditionValue::String("POST".to_string())));
}
#[test]
fn test_wami_request_path_key() {
let context = ConditionContext::builder()
.request_path("/api/v1/users")
.build();
let value = get_context_value("wami:RequestPath", &context).unwrap();
assert_eq!(
value,
Some(ConditionValue::String("/api/v1/users".to_string()))
);
}
#[test]
fn test_wami_api_version_key() {
let context = ConditionContext::builder().api_version("v2").build();
let value = get_context_value("wami:ApiVersion", &context).unwrap();
assert_eq!(value, Some(ConditionValue::String("v2".to_string())));
}
#[test]
fn test_wami_client_type_key() {
let context = ConditionContext::builder().client_type("web").build();
let value = get_context_value("wami:ClientType", &context).unwrap();
assert_eq!(value, Some(ConditionValue::String("web".to_string())));
}
#[test]
fn test_wami_platform_key() {
let context = ConditionContext::builder().platform("ios").build();
let value = get_context_value("wami:Platform", &context).unwrap();
assert_eq!(value, Some(ConditionValue::String("ios".to_string())));
}
#[test]
fn test_wami_device_type_key() {
let context = ConditionContext::builder().device_type("mobile").build();
let value = get_context_value("wami:DeviceType", &context).unwrap();
assert_eq!(value, Some(ConditionValue::String("mobile".to_string())));
}
#[test]
fn test_wami_session_age_key() {
let context = ConditionContext::builder().session_age(3600).build();
let value = get_context_value("wami:SessionAge", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Number(3600.0)));
}
#[test]
fn test_wami_authentication_method_key() {
let context = ConditionContext::builder()
.authentication_method("oauth")
.build();
let value = get_context_value("wami:AuthenticationMethod", &context).unwrap();
assert_eq!(value, Some(ConditionValue::String("oauth".to_string())));
}
#[test]
fn test_wami_authentication_strength_key() {
let context = ConditionContext::builder()
.authentication_strength("high")
.build();
let value = get_context_value("wami:AuthenticationStrength", &context).unwrap();
assert_eq!(value, Some(ConditionValue::String("high".to_string())));
}
#[test]
fn test_wami_session_risk_score_key() {
let context = ConditionContext::builder().session_risk_score(0.75).build();
let value = get_context_value("wami:SessionRiskScore", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Number(0.75)));
}
#[test]
fn test_wami_source_country_key() {
let context = ConditionContext::builder()
.geolocation_country("US")
.build();
let value = get_context_value("wami:SourceCountry", &context).unwrap();
assert_eq!(value, Some(ConditionValue::String("US".to_string())));
}
#[test]
fn test_wami_source_city_key() {
let context = ConditionContext::builder()
.geolocation_city("San Francisco")
.build();
let value = get_context_value("wami:SourceCity", &context).unwrap();
assert_eq!(
value,
Some(ConditionValue::String("San Francisco".to_string()))
);
}
#[test]
fn test_wami_vpn_detected_key() {
let context = ConditionContext::builder().vpn_detected(true).build();
let value = get_context_value("wami:VpnDetected", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Boolean(true)));
}
#[test]
fn test_wami_proxy_detected_key() {
let context = ConditionContext::builder().proxy_detected(false).build();
let value = get_context_value("wami:ProxyDetected", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Boolean(false)));
}
#[test]
fn test_wami_requests_per_minute_key() {
let context = ConditionContext::builder().requests_per_minute(100).build();
let value = get_context_value("wami:RequestsPerMinute", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Number(100.0)));
}
#[test]
fn test_wami_quota_remaining_key() {
let context = ConditionContext::builder().quota_remaining(5000).build();
let value = get_context_value("wami:QuotaRemaining", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Number(5000.0)));
}
#[test]
fn test_wami_burst_capacity_used_key() {
let context = ConditionContext::builder()
.burst_capacity_used(0.85)
.build();
let value = get_context_value("wami:BurstCapacityUsed", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Number(0.85)));
}
#[test]
fn test_wami_request_id_key() {
let context = ConditionContext::builder().request_id("req-12345").build();
let value = get_context_value("wami:RequestId", &context).unwrap();
assert_eq!(value, Some(ConditionValue::String("req-12345".to_string())));
}
#[test]
fn test_wami_trace_id_key() {
let context = ConditionContext::builder().trace_id("trace-abc123").build();
let value = get_context_value("wami:TraceId", &context).unwrap();
assert_eq!(
value,
Some(ConditionValue::String("trace-abc123".to_string()))
);
}
#[test]
fn test_wami_debug_mode_enabled_key() {
let context = ConditionContext::builder().debug_mode(true).build();
let value = get_context_value("wami:DebugModeEnabled", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Boolean(true)));
}
#[test]
fn test_wami_dry_run_mode_key() {
let context = ConditionContext::builder().dry_run_mode(false).build();
let value = get_context_value("wami:DryRunMode", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Boolean(false)));
}
#[test]
fn test_wami_data_classification_key() {
let context = ConditionContext::builder()
.data_classification("confidential")
.build();
let value = get_context_value("wami:ResourceDataClassification", &context).unwrap();
assert_eq!(
value,
Some(ConditionValue::String("confidential".to_string()))
);
}
#[test]
fn test_wami_encryption_required_key() {
let context = ConditionContext::builder()
.encryption_required(true)
.build();
let value = get_context_value("wami:EncryptionRequired", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Boolean(true)));
}
#[test]
fn test_wami_tenant_name_key() {
let context = ConditionContext::builder().tenant_name("acme-corp").build();
let value = get_context_value("wami:TenantName", &context).unwrap();
assert_eq!(value, Some(ConditionValue::String("acme-corp".to_string())));
}
#[test]
fn test_wami_cross_tenant_request_key() {
let context = ConditionContext::builder()
.cross_tenant_request(true)
.build();
let value = get_context_value("wami:CrossTenantRequest", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Boolean(true)));
}
#[test]
fn test_wami_provider_region_key() {
let context = ConditionContext::builder()
.provider_region("us-east-1")
.build();
let value = get_context_value("wami:ProviderRegion", &context).unwrap();
assert_eq!(value, Some(ConditionValue::String("us-east-1".to_string())));
}
#[test]
fn test_wami_cross_provider_request_key() {
let context = ConditionContext::builder()
.cross_provider_request(false)
.build();
let value = get_context_value("wami:CrossProviderRequest", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Boolean(false)));
}
#[test]
fn test_wami_condition_with_request_method() {
let context = ConditionContext::builder().request_method("POST").build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"wami:RequestMethod": "POST"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_wami_condition_with_client_type() {
let context = ConditionContext::builder().client_type("mobile").build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"wami:ClientType": "mobile"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_wami_condition_with_platform() {
let context = ConditionContext::builder().platform("ios").build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"wami:Platform": "ios"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_wami_condition_with_session_age() {
let context = ConditionContext::builder()
.session_age(1800) .build();
let condition = parse_condition_block_from_json(
r#"{
"NumericLessThan": {
"wami:SessionAge": "3600"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_wami_condition_with_rate_limiting() {
let context = ConditionContext::builder()
.requests_per_minute(50)
.quota_remaining(1000)
.build();
let condition = parse_condition_block_from_json(
r#"{
"NumericLessThan": {
"wami:RequestsPerMinute": "100"
},
"NumericGreaterThan": {
"wami:QuotaRemaining": "500"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result); }
#[test]
fn test_wami_condition_with_geolocation() {
let context = ConditionContext::builder()
.geolocation_country("US")
.geolocation_city("New York")
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"wami:SourceCountry": "US"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_wami_condition_with_security_flags() {
let context = ConditionContext::builder()
.vpn_detected(false)
.proxy_detected(false)
.session_risk_score(0.2)
.build();
let condition = parse_condition_block_from_json(
r#"{
"Bool": {
"wami:VpnDetected": "false"
},
"NumericLessThan": {
"wami:SessionRiskScore": "0.5"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_wami_condition_with_authentication() {
let context = ConditionContext::builder()
.authentication_method("oauth")
.authentication_strength("high")
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"wami:AuthenticationMethod": "oauth",
"wami:AuthenticationStrength": "high"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_wami_condition_with_data_classification() {
let context = ConditionContext::builder()
.data_classification("confidential")
.encryption_required(true)
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"wami:ResourceDataClassification": "confidential"
},
"Bool": {
"wami:EncryptionRequired": "true"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_wami_condition_web_app_example() {
let context = ConditionContext::builder()
.client_type("web")
.platform("web")
.request_method("POST")
.request_path("/api/admin/users")
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"wami:ClientType": "web",
"wami:Platform": "web"
},
"StringLike": {
"wami:RequestPath": "/api/admin/*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_wami_condition_mobile_app_example() {
let context = ConditionContext::builder()
.client_type("mobile")
.platform("ios")
.device_type("mobile")
.application_version("2.0.0")
.build();
let condition = parse_condition_block_from_json(
r#"{
"StringEquals": {
"wami:ClientType": "mobile",
"wami:Platform": "ios"
},
"StringLike": {
"wami:ApplicationVersion": "2.*"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_wami_condition_api_rate_limit_example() {
let context = ConditionContext::builder()
.requests_per_minute(45)
.quota_remaining(500)
.build();
let condition = parse_condition_block_from_json(
r#"{
"NumericLessThan": {
"wami:RequestsPerMinute": "60"
},
"NumericGreaterThan": {
"wami:QuotaRemaining": "0"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_wami_condition_security_example() {
let context = ConditionContext::builder()
.session_risk_score(0.15)
.vpn_detected(false)
.authentication_strength("high")
.build();
let condition = parse_condition_block_from_json(
r#"{
"NumericLessThan": {
"wami:SessionRiskScore": "0.3"
},
"Bool": {
"wami:VpnDetected": "false"
},
"StringEquals": {
"wami:AuthenticationStrength": "high"
}
}"#,
);
let result = evaluate_condition_block(&condition, &context).unwrap();
assert!(result);
}
#[test]
fn test_wami_requests_per_hour_key() {
let context = ConditionContext::builder().requests_per_hour(1000).build();
let value = get_context_value("wami:RequestsPerHour", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Number(1000.0)));
}
#[test]
fn test_wami_requests_per_day_key() {
let context = ConditionContext::builder().requests_per_day(10000).build();
let value = get_context_value("wami:RequestsPerDay", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Number(10000.0)));
}
#[test]
fn test_wami_quota_limit_key() {
let context = ConditionContext::builder().quota_limit(50000).build();
let value = get_context_value("wami:QuotaLimit", &context).unwrap();
assert_eq!(value, Some(ConditionValue::Number(50000.0)));
}
#[test]
fn test_wami_data_residency_region_key() {
let context = ConditionContext::builder()
.data_residency_region("eu-west-1")
.build();
let value = get_context_value("wami:DataResidencyRegion", &context).unwrap();
assert_eq!(value, Some(ConditionValue::String("eu-west-1".to_string())));
}
#[test]
fn test_wami_encryption_algorithm_key() {
let context = ConditionContext::builder()
.encryption_algorithm("AES-256")
.build();
let value = get_context_value("wami:EncryptionAlgorithm", &context).unwrap();
assert_eq!(value, Some(ConditionValue::String("AES-256".to_string())));
}
fn parse_err(json: &str) -> String {
let value: Value = serde_json::from_str(json).unwrap();
match parse_condition_block(&value) {
Ok(block) => panic!("{json} parsed, as {block:?}; it must be refused"),
Err(e) => e.to_string(),
}
}
fn parses(json: &str) {
let value: Value = serde_json::from_str(json).unwrap();
if let Err(e) = parse_condition_block(&value) {
panic!("{json} was refused ({e}); it is a readable condition");
}
}
#[test]
fn an_unknown_operator_is_refused_at_parse() {
let message = parse_err(r#"{"StringEqualz":{"aws:username":"alice"}}"#);
assert!(message.contains("StringEqualz"), "{message}");
}
#[test]
fn a_malformed_value_is_refused_at_parse_for_every_operator_family() {
let cases = [
(
r#"{"IpAddress":{"aws:SourceIp":"not-an-ip"}}"#,
"IpAddress",
"aws:SourceIp",
),
(
r#"{"NotIpAddressIfExists":{"aws:SourceIp":"10.0.0.0/33"}}"#,
"NotIpAddressIfExists",
"aws:SourceIp",
),
(
r#"{"IpAddress":{"aws:SourceIp":123}}"#,
"IpAddress",
"aws:SourceIp",
),
(
r#"{"Bool":{"aws:SecureTransport":"yes"}}"#,
"Bool",
"aws:SecureTransport",
),
(
r#"{"NumericEquals":{"aws:username":"abc"}}"#,
"NumericEquals",
"aws:username",
),
(
r#"{"NumericLessThanIfExists":{"wami:SessionAge":true}}"#,
"NumericLessThanIfExists",
"wami:SessionAge",
),
(
r#"{"DateLessThan":{"aws:CurrentTime":"yesterday"}}"#,
"DateLessThan",
"aws:CurrentTime",
),
(
r#"{"Null":{"aws:SourceIp":"maybe"}}"#,
"Null",
"aws:SourceIp",
),
(
r#"{"StringEquals":{"aws:username":{"a":1}}}"#,
"StringEquals",
"aws:username",
),
(
r#"{"ArnLike":{"aws:PrincipalArn":null}}"#,
"ArnLike",
"aws:PrincipalArn",
),
(
r#"{"BinaryEquals":{"wami:Custom":{}}}"#,
"BinaryEquals",
"wami:Custom",
),
(
r#"{"ForAnyValue:StringEquals":{"aws:TagKeys":"env"}}"#,
"ForAnyValue:StringEquals",
"aws:TagKeys",
),
];
for (json, operator, key) in cases {
let message = parse_err(json);
assert!(message.contains(operator), "{json}: {message}");
assert!(message.contains(key), "{json}: {message}");
}
}
#[test]
fn a_list_element_is_validated_and_named_by_its_position() {
let message = parse_err(r#"{"ForAnyValue:StringEquals":{"aws:TagKeys":["env", 5]}}"#);
assert!(message.contains("element 1"), "{message}");
let message = parse_err(r#"{"IpAddress":{"aws:SourceIp":["10.0.0.1","nope"]}}"#);
assert!(message.contains("element 1"), "{message}");
}
#[test]
fn a_list_is_refused_where_its_operator_cannot_read_one() {
for json in [
r#"{"StringEquals":{"aws:username":["alice","bob"]}}"#,
r#"{"ArnEquals":{"aws:PrincipalArn":["a","b"]}}"#,
r#"{"NumericEquals":{"wami:SessionAge":[1,2]}}"#,
r#"{"DateEquals":{"aws:CurrentTime":["2020-01-01T00:00:00Z"]}}"#,
r#"{"Bool":{"aws:SecureTransport":[true]}}"#,
] {
let message = parse_err(json);
assert!(message.contains("wami 002"), "{json}: {message}");
}
}
#[test]
fn every_readable_form_still_parses() {
for json in [
r#"{"StringEquals":{"aws:username":"alice"}}"#,
r#"{"StringLike":{"aws:username":5}}"#,
r#"{"StringEqualsIgnoreCase":{"aws:username":true}}"#,
r#"{"IpAddress":{"aws:SourceIp":"10.0.0.0/8"}}"#,
r#"{"IpAddress":{"aws:SourceIp":["10.0.0.1","2001:db8::/32","::1"]}}"#,
r#"{"Bool":{"aws:SecureTransport":true}}"#,
r#"{"BoolIfExists":{"aws:SecureTransport":"false"}}"#,
r#"{"NumericLessThan":{"wami:SessionAge":5}}"#,
r#"{"NumericGreaterThan":{"wami:SessionAge":"5.5"}}"#,
r#"{"DateGreaterThan":{"aws:CurrentTime":"2020-01-01T00:00:00Z"}}"#,
r#"{"Null":{"aws:SourceIp":"true"}}"#,
r#"{"ArnLike":{"aws:PrincipalArn":"arn:wami:iam:*"}}"#,
r#"{"ForAnyValue:StringEquals":{"aws:TagKeys":["env","team"]}}"#,
r#"{"StringEquals":{}}"#,
r#"{}"#,
] {
parses(json);
}
}
#[test]
fn a_missing_context_key_is_a_false_condition_not_an_error() {
let empty = ConditionContext::builder().build();
let block = parse_condition_block_from_json(r#"{"IpAddress":{"aws:SourceIp":"10.0.0.1"}}"#);
assert_eq!(evaluate_condition_block(&block, &empty), Ok(false));
let block = parse_condition_block_from_json(r#"{"StringEquals":{"wami:NoSuchKey":"x"}}"#);
assert_eq!(evaluate_condition_block(&block, &empty), Ok(false));
let block =
parse_condition_block_from_json(r#"{"IpAddressIfExists":{"aws:SourceIp":"10.0.0.1"}}"#);
assert_eq!(evaluate_condition_block(&block, &empty), Ok(true));
}
#[test]
fn a_context_value_its_operator_cannot_read_is_an_error_not_false() {
let json = r#"{"NumericLessThan":{"aws:username":"5"}}"#;
parse_err(json);
let context = ConditionContext::builder().username("alice").build();
assert_eq!(
evaluate_condition_block(&unchecked(json), &context),
Err(ConditionError::TypeMismatch {
expected: "a finite Number".to_string(),
actual: "String".to_string(),
}),
"an evaluation error must not be answered as false"
);
}
#[test]
fn an_unreadable_value_that_bypassed_parse_is_an_error_at_evaluation() {
let mut block = ConditionBlock::new();
block.insert(
"Bool".to_string(),
std::collections::HashMap::from([(
"aws:SecureTransport".to_string(),
ConditionValue::String("yes".to_string()),
)]),
);
let context = ConditionContext::builder().secure_transport(true).build();
assert_eq!(
evaluate_condition_block(&block, &context),
Err(ConditionError::InvalidBooleanValue)
);
}
fn unchecked(json: &str) -> ConditionBlock {
let value: Value = serde_json::from_str(json).unwrap();
value
.as_object()
.unwrap()
.iter()
.map(|(operator, pairs)| {
let pairs = pairs
.as_object()
.unwrap()
.iter()
.map(|(key, v)| (key.clone(), ConditionValue::from(v.clone())))
.collect();
(operator.clone(), pairs)
})
.collect()
}
#[test]
fn an_operator_of_another_type_than_its_key_is_refused_at_parse() {
let cases = [
(
r#"{"StringEquals":{"aws:SecureTransport":"false"}}"#,
"StringEquals",
"aws:SecureTransport",
),
(
r#"{"StringNotEqualsIfExists":{"aws:MultiFactorAuthAge":"300"}}"#,
"StringNotEqualsIfExists",
"aws:MultiFactorAuthAge",
),
(
r#"{"StringLike":{"aws:CurrentTime":"2020-*"}}"#,
"StringLike",
"aws:CurrentTime",
),
(
r#"{"StringEquals":{"aws:SourceIp":"10.0.0.1"}}"#,
"StringEquals",
"aws:SourceIp",
),
(
r#"{"StringEquals":{"aws:TagKeys":"env"}}"#,
"StringEquals",
"aws:TagKeys",
),
(
r#"{"ArnEquals":{"wami:VpnDetected":"x"}}"#,
"ArnEquals",
"wami:VpnDetected",
),
(
r#"{"BinaryEquals":{"wami:SessionAge":"QQ=="}}"#,
"BinaryEquals",
"wami:SessionAge",
),
(
r#"{"NumericLessThan":{"aws:username":"5"}}"#,
"NumericLessThan",
"aws:username",
),
(
r#"{"NumericEquals":{"wami:Team":"5"}}"#,
"NumericEquals",
"wami:Team",
),
(
r#"{"DateLessThan":{"aws:EpochTime":"2020-01-01T00:00:00Z"}}"#,
"DateLessThan",
"aws:EpochTime",
),
(
r#"{"Bool":{"aws:username":"true"}}"#,
"Bool",
"aws:username",
),
(
r#"{"IpAddress":{"aws:username":"10.0.0.1"}}"#,
"IpAddress",
"aws:username",
),
(
r#"{"IpAddress":{"wami:Team":"10.0.0.1"}}"#,
"IpAddress",
"wami:Team",
),
(
r#"{"ForAllValues:StringEquals":{"aws:SecureTransport":["true"]}}"#,
"ForAllValues:StringEquals",
"aws:SecureTransport",
),
];
for (json, operator, key) in cases {
let message = parse_err(json);
assert!(message.contains(operator), "{json}: {message}");
assert!(message.contains(key), "{json}: {message}");
}
}
#[test]
fn well_typed_operators_parse_on_every_kind_of_key() {
for json in [
r#"{"StringEquals":{"aws:username":"alice"}}"#,
r#"{"StringLike":{"aws:PrincipalArn":"arn:*"}}"#,
r#"{"ArnLike":{"aws:PrincipalArn":"arn:*"}}"#,
r#"{"ArnEquals":{"aws:username":"alice"}}"#,
r#"{"StringEquals":{"wami:Team":"core"}}"#,
r#"{"StringEquals":{"aws:PrincipalTag/team":"core"}}"#,
r#"{"BinaryEquals":{"wami:Blob":"QQ=="}}"#,
r#"{"Bool":{"aws:SecureTransport":true}}"#,
r#"{"BoolIfExists":{"wami:VpnDetected":"false"}}"#,
r#"{"NumericLessThan":{"aws:MultiFactorAuthAge":600}}"#,
r#"{"DateLessThan":{"aws:CurrentTime":"2020-01-01T00:00:00Z"}}"#,
r#"{"IpAddress":{"aws:SourceIp":"10.0.0.0/8"}}"#,
r#"{"ForAnyValue:StringEquals":{"aws:TagKeys":["env"]}}"#,
r#"{"ForAllValues:StringLike":{"aws:username":["a*"]}}"#,
r#"{"Null":{"aws:SecureTransport":"true"}}"#,
r#"{"Null":{"aws:TagKeys":"false"}}"#,
r#"{"NullIfExists":{"wami:Team":"true"}}"#,
] {
parses(json);
}
}
#[test]
fn a_context_value_of_another_type_is_an_error_for_every_string_operator() {
let context = ConditionContext::builder()
.custom_value("wami:Team", ConditionValue::Number(5.0))
.custom_value("wami:Flags", ConditionValue::Boolean(true))
.custom_value("wami:List", ConditionValue::Array(vec!["a".to_string()]))
.build();
for json in [
r#"{"StringEquals":{"wami:Team":"5"}}"#,
r#"{"StringNotEquals":{"wami:Team":"5"}}"#,
r#"{"StringLike":{"wami:Flags":"t*"}}"#,
r#"{"StringEqualsIgnoreCase":{"wami:List":"a"}}"#,
r#"{"StringEqualsIfExists":{"wami:Team":"5"}}"#,
r#"{"ArnEquals":{"wami:Team":"x"}}"#,
r#"{"ArnNotLike":{"wami:Flags":"x"}}"#,
r#"{"BinaryEquals":{"wami:Team":"QQ=="}}"#,
r#"{"ForAllValues:StringEquals":{"wami:Team":["5"]}}"#,
r#"{"ForAnyValue:StringLike":{"wami:Flags":["t*"]}}"#,
r#"{"ForAllValues:ArnLike":{"wami:Team":["x"]}}"#,
] {
let block = parse_condition_block_from_json(json);
let outcome = evaluate_condition_block(&block, &context);
assert!(
matches!(outcome, Err(ConditionError::TypeMismatch { .. })),
"{json}: {outcome:?}"
);
}
}
#[test]
fn a_context_value_of_another_type_is_an_error_for_every_other_operator() {
let context = ConditionContext::builder()
.custom_value("wami:When", ConditionValue::Number(5.0))
.custom_value("wami:Where", ConditionValue::Boolean(true))
.custom_value(
"wami:Numbers",
ConditionValue::Array(vec!["1".to_string(), "abc".to_string()]),
)
.custom_value(
"wami:Dates",
ConditionValue::Array(vec!["2020-01-01T00:00:00Z".to_string(), "soon".to_string()]),
)
.custom_value(
"wami:Ips",
ConditionValue::Array(vec!["10.0.0.1".to_string(), "nope".to_string()]),
)
.custom_value("wami:Flag", ConditionValue::Number(1.0))
.source_ip("not-an-ip")
.build();
for json in [
r#"{"DateLessThan":{"wami:When":"2020-01-01T00:00:00Z"}}"#,
r#"{"DateNotEquals":{"wami:When":"2020-01-01T00:00:00Z"}}"#,
r#"{"IpAddress":{"wami:Where":"10.0.0.0/8"}}"#,
r#"{"NotIpAddress":{"wami:Where":"10.0.0.0/8"}}"#,
r#"{"IpAddress":{"aws:SourceIp":"10.0.0.0/8"}}"#,
r#"{"NotIpAddress":{"aws:SourceIp":"10.0.0.0/8"}}"#,
r#"{"Bool":{"wami:Flag":"true"}}"#,
] {
let outcome = evaluate_condition_block(&unchecked(json), &context);
assert!(
matches!(outcome, Err(ConditionError::TypeMismatch { .. })),
"{json}: {outcome:?}"
);
}
}
#[test]
fn a_number_that_is_not_finite_is_refused() {
for value in ["NaN", "inf", "-inf", "infinity", "+Infinity"] {
let json = format!(r#"{{"NumericLessThan":{{"wami:SessionAge":"{value}"}}}}"#);
parse_err(&json);
}
assert!(ConditionValue::String("NaN".to_string())
.as_number()
.is_err());
}
#[test]
fn an_empty_list_is_refused_where_a_list_is_read() {
for json in [
r#"{"IpAddress":{"aws:SourceIp":[]}}"#,
r#"{"NotIpAddress":{"aws:SourceIp":[]}}"#,
r#"{"ForAllValues:StringEquals":{"aws:TagKeys":[]}}"#,
] {
parse_err(json);
}
}
#[test]
fn malformed_set_and_if_exists_forms_are_refused_at_parse() {
for json in [
r#"{"DateEqualsIfExists":{"aws:CurrentTime":"soon"}}"#,
r#"{"BoolIfExists":{"aws:SecureTransport":"yes"}}"#,
r#"{"NullIfExists":{"aws:SourceIp":"maybe"}}"#,
] {
parse_err(json);
}
}
#[test]
fn an_error_names_where_a_value_sits_never_the_value() {
use crate::operators::evaluate_operator;
use crate::ConditionOperator as O;
let canary = "canary-value";
for json in [
format!(r#"{{"Bool":{{"aws:SecureTransport":"{canary}"}}}}"#),
format!(r#"{{"DateLessThan":{{"aws:CurrentTime":"{canary}"}}}}"#),
format!(r#"{{"NumericEquals":{{"wami:SessionAge":"{canary}"}}}}"#),
format!(r#"{{"IpAddress":{{"aws:SourceIp":["10.0.0.1","{canary}"]}}}}"#),
] {
let message = parse_err(&json);
assert!(!message.contains(canary), "{json}: {message}");
}
let cases = [
(O::Bool, ConditionValue::Boolean(true)),
(
O::DateLessThan,
ConditionValue::String("2020-01-01T00:00:00Z".to_string()),
),
(O::NumericLessThan, ConditionValue::Number(5.0)),
(
O::IpAddress,
ConditionValue::String("10.0.0.0/8".to_string()),
),
];
for (operator, expected) in cases {
let err = evaluate_operator(
operator,
Some(ConditionValue::String(canary.to_string())),
&expected,
)
.unwrap_err();
assert!(!err.to_string().contains(canary), "{operator:?}: {err}");
assert!(
!format!("{err:?}").contains(canary),
"{operator:?}: {err:?}"
);
}
let err = evaluate_operator(
O::StringEquals,
Some(ConditionValue::Array(vec![canary.to_string()])),
&ConditionValue::String("x".to_string()),
)
.unwrap_err();
assert!(!format!("{err:?}").contains(canary), "{err:?}");
}
const EVERY_OPERATOR: [&str; 74] = [
"StringEquals",
"StringNotEquals",
"StringLike",
"StringNotLike",
"StringEqualsIgnoreCase",
"StringNotEqualsIgnoreCase",
"StringEqualsIfExists",
"StringNotEqualsIfExists",
"StringLikeIfExists",
"StringNotLikeIfExists",
"NumericEquals",
"NumericNotEquals",
"NumericLessThan",
"NumericLessThanEquals",
"NumericGreaterThan",
"NumericGreaterThanEquals",
"NumericEqualsIfExists",
"NumericNotEqualsIfExists",
"NumericLessThanIfExists",
"NumericLessThanEqualsIfExists",
"NumericGreaterThanIfExists",
"NumericGreaterThanEqualsIfExists",
"DateEquals",
"DateNotEquals",
"DateLessThan",
"DateLessThanEquals",
"DateGreaterThan",
"DateGreaterThanEquals",
"DateEqualsIfExists",
"DateNotEqualsIfExists",
"DateLessThanIfExists",
"DateLessThanEqualsIfExists",
"DateGreaterThanIfExists",
"DateGreaterThanEqualsIfExists",
"IpAddress",
"NotIpAddress",
"IpAddressIfExists",
"NotIpAddressIfExists",
"ArnEquals",
"ArnNotEquals",
"ArnLike",
"ArnNotLike",
"ArnEqualsIfExists",
"ArnNotEqualsIfExists",
"ArnLikeIfExists",
"ArnNotLikeIfExists",
"Bool",
"BoolIfExists",
"BinaryEquals",
"BinaryEqualsIfExists",
"Null",
"NullIfExists",
"ForAllValues:StringEquals",
"ForAllValues:StringNotEquals",
"ForAllValues:StringLike",
"ForAllValues:StringNotLike",
"ForAllValues:ArnEquals",
"ForAllValues:ArnLike",
"ForAllValues:NumericLessThan",
"ForAllValues:NumericGreaterThan",
"ForAllValues:IpAddress",
"ForAllValues:DateLessThan",
"ForAllValues:DateGreaterThan",
"ForAnyValue:StringEquals",
"ForAnyValue:StringNotEquals",
"ForAnyValue:StringLike",
"ForAnyValue:StringNotLike",
"ForAnyValue:ArnEquals",
"ForAnyValue:ArnLike",
"ForAnyValue:NumericLessThan",
"ForAnyValue:NumericGreaterThan",
"ForAnyValue:IpAddress",
"ForAnyValue:DateLessThan",
"ForAnyValue:DateGreaterThan",
];
fn a_key_for(operator: &str) -> &'static str {
let base = operator
.trim_start_matches("ForAllValues:")
.trim_start_matches("ForAnyValue:");
if base.contains("IpAddress") {
"aws:SourceIp"
} else if base.starts_with("Numeric") {
"aws:MultiFactorAuthAge"
} else if base.starts_with("Date") {
"aws:CurrentTime"
} else if base.starts_with("Bool") {
"aws:SecureTransport"
} else if base.starts_with("Null") {
"aws:SourceIp"
} else if base.starts_with("Arn") {
"aws:PrincipalArn"
} else if operator.starts_with("For") {
"aws:TagKeys"
} else {
"aws:username"
}
}
#[test]
fn whatever_parse_lets_through_evaluates_without_an_error() {
let context = ConditionContext::builder()
.principal_arn("arn:aws:iam::123456789012:user/alice")
.username("alice")
.source_ip("203.0.113.42")
.current_time(chrono::Utc::now())
.mfa_age(300)
.secure_transport(true)
.tag_keys(vec!["env".to_string()])
.build();
let candidates = [
serde_json::json!("alice"),
serde_json::json!("arn:aws:iam::*"),
serde_json::json!("10.0.0.1"),
serde_json::json!("10.0.0.0/8"),
serde_json::json!("2001:db8::/32"),
serde_json::json!(["10.0.0.0/8", "::1"]),
serde_json::json!(["env", "team"]),
serde_json::json!(["alice"]),
serde_json::json!([]),
serde_json::json!("600"),
serde_json::json!(600),
serde_json::json!("1e3"),
serde_json::json!("NaN"),
serde_json::json!(true),
serde_json::json!("false"),
serde_json::json!("2020-01-01T00:00:00Z"),
serde_json::json!(["2020-01-01T00:00:00Z"]),
serde_json::json!("QQ=="),
];
let mut accepted = 0;
for operator in EVERY_OPERATOR {
let key = a_key_for(operator);
for value in &candidates {
let condition = serde_json::json!({ operator: { key: value } });
let Ok(block) = parse_condition_block(&condition) else {
continue;
};
accepted += 1;
if let Err(e) = evaluate_condition_block(&block, &context) {
panic!("{condition} parsed, then failed at evaluation: {e}");
}
}
}
assert!(accepted >= EVERY_OPERATOR.len() - 10, "{accepted}");
}
#[test]
fn every_declared_key_resolves_to_the_type_it_declares() {
use crate::keys::{declared_keys, key_type, KeyType};
let now = chrono::Utc::now();
let context = ConditionContext::builder()
.principal_arn("arn:aws:iam::1:user/a")
.principal_account("1")
.principal_type("User")
.username("a")
.userid("AID")
.mfa_present(true)
.mfa_age(1)
.token_issue_time(now)
.secure_transport(true)
.source_ip("10.0.0.1")
.source_vpc("vpc")
.source_vpce("vpce")
.current_time(now)
.requested_region("eu")
.referer("r")
.user_agent("ua")
.resource_arn("arn:aws:s3:::b")
.resource_account("2")
.tag_keys(vec!["env".to_string()])
.tenant_id(1)
.principal_tenant_id(1)
.resource_tenant_id(1)
.provider("p")
.source_provider("p")
.target_provider("p")
.tenant_name("t")
.tenant_status("active")
.cross_tenant_request(false)
.provider_region("eu")
.cross_provider_request(false)
.request_method("GET")
.request_protocol("https")
.api_version("1")
.request_path("/")
.request_query("q")
.content_type("json")
.accept_header("*/*")
.origin("o")
.host("h")
.application_id("app")
.application_version("1")
.client_id("c")
.client_type("web")
.device_id("d")
.device_type("phone")
.platform("ios")
.session_id("s")
.session_age(1)
.authentication_method("password")
.authentication_strength("strong")
.session_risk_score(0.5)
.ip_reputation("good")
.geolocation_country("FR")
.geolocation_city("Paris")
.vpn_detected(false)
.proxy_detected(false)
.requests_per_minute(1)
.requests_per_hour(1)
.requests_per_day(1)
.quota_remaining(1)
.quota_limit(1)
.burst_capacity_used(0.5)
.request_id("r")
.correlation_id("c")
.trace_id("t")
.span_id("s")
.debug_mode(false)
.dry_run_mode(false)
.data_classification("secret")
.encryption_required(true)
.encryption_algorithm("AES")
.data_residency_region("eu")
.build();
let mut seen = 0;
for (key, declared) in declared_keys() {
seen += 1;
let value = get_context_value(key, &context)
.unwrap()
.unwrap_or_else(|| panic!("{key} resolved to nothing in a full context"));
let holds = match declared {
KeyType::String | KeyType::Arn => matches!(value, ConditionValue::String(_)),
KeyType::Date => value
.as_string()
.is_ok_and(|s| crate::operators::parse_rfc3339(&s).is_ok()),
KeyType::Ip => matches!(value, ConditionValue::String(_)),
KeyType::Number => matches!(value, ConditionValue::Number(_)),
KeyType::Boolean => matches!(value, ConditionValue::Boolean(_)),
KeyType::StringList => matches!(value, ConditionValue::Array(_)),
};
assert!(
holds,
"{key} is declared {declared:?} and resolves to {value:?}"
);
assert_eq!(key_type(key), Some(declared), "{key}");
}
assert!(seen > 70, "{seen}");
assert_eq!(key_type("aws:PrincipalTag/team"), Some(KeyType::String));
assert_eq!(key_type("wami:Team"), None);
}
#[test]
fn the_set_operators_no_key_can_feed_are_refused_at_parse() {
let cases = [
r#"{"ForAllValues:NumericLessThan":{"wami:SessionAge":"10"}}"#,
r#"{"ForAllValues:NumericGreaterThan":{"aws:MultiFactorAuthAge":"1"}}"#,
r#"{"ForAnyValue:NumericLessThan":{"aws:TagKeys":"5"}}"#,
r#"{"ForAnyValue:NumericGreaterThan":{"aws:EpochTime":"1"}}"#,
r#"{"ForAllValues:DateLessThan":{"aws:CurrentTime":"2020-01-01T00:00:00Z"}}"#,
r#"{"ForAllValues:DateGreaterThan":{"aws:TokenIssueTime":"2020-01-01T00:00:00Z"}}"#,
r#"{"ForAnyValue:DateLessThan":{"aws:CurrentTime":"2020-01-01T00:00:00Z"}}"#,
r#"{"ForAnyValue:DateGreaterThan":{"aws:CurrentTime":"2020-01-01T00:00:00Z"}}"#,
r#"{"ForAllValues:IpAddress":{"aws:SourceIp":["10.0.0.0/8"]}}"#,
r#"{"ForAnyValue:IpAddress":{"aws:SourceIp":["10.0.0.0/8"]}}"#,
];
for json in cases {
let message = parse_err(json);
assert!(
message.contains("no key of that kind holds a list"),
"{json}: {message}"
);
let operator = json.split('"').nth(1).unwrap();
assert!(message.contains(operator), "{json}: {message}");
}
let lists: Vec<_> = crate::keys::declared_keys()
.filter(|(_, t)| *t == crate::keys::KeyType::StringList)
.map(|(key, _)| key)
.collect();
assert_eq!(lists, ["aws:TagKeys"]);
}
#[test]
fn a_hand_built_block_cannot_reach_a_set_operator_no_key_can_feed() {
let context = ConditionContext::builder().mfa_age(300).build();
let block = unchecked(r#"{"ForAllValues:NumericLessThan":{"aws:MultiFactorAuthAge":"600"}}"#);
assert_eq!(
evaluate_condition_block(&block, &context),
Err(ConditionError::OperatorWithoutKey {
operator: "ForAllValues:NumericLessThan".to_string(),
})
);
}
#[test]
fn every_declared_key_is_written_where_it_is_read() {
use crate::keys::{assign_context_value, declared_keys, KeyType};
for (key, declared) in declared_keys() {
let sample: Vec<String> = match declared {
KeyType::String | KeyType::Arn => vec!["7".to_string()],
KeyType::Number => vec!["1600000000".to_string()],
KeyType::Boolean => vec!["true".to_string()],
KeyType::Date => vec!["2020-01-01T00:00:00Z".to_string()],
KeyType::Ip => vec!["10.0.0.1".to_string()],
KeyType::StringList => vec!["a".to_string(), "b".to_string()],
};
let mut context = ConditionContext::builder().build();
assert_eq!(
assign_context_value(&mut context, key, &sample),
Ok(true),
"{key}"
);
assert!(
context.custom_values.is_empty(),
"{key} went to the custom values"
);
let read = get_context_value(key, &context)
.unwrap()
.unwrap_or_else(|| panic!("{key} written, then read as absent"));
let expected = match declared {
KeyType::String | KeyType::Arn => ConditionValue::String("7".to_string()),
KeyType::Number => ConditionValue::Number(1_600_000_000.0),
KeyType::Boolean => ConditionValue::Boolean(true),
KeyType::Ip => ConditionValue::String("10.0.0.1".to_string()),
KeyType::StringList => ConditionValue::Array(vec!["a".to_string(), "b".to_string()]),
KeyType::Date => {
let instant = |v: &ConditionValue| {
crate::operators::parse_rfc3339(&v.as_string().unwrap()).unwrap()
};
let written = ConditionValue::String(sample[0].clone());
assert_eq!(instant(&read), instant(&written), "{key}");
continue;
}
};
assert_eq!(read, expected, "{key}");
}
let mut context = ConditionContext::builder().build();
let core = ["core".to_string()];
assert_eq!(
assign_context_value(&mut context, "aws:PrincipalTag/team", &core),
Ok(true)
);
assert_eq!(
get_context_value("aws:PrincipalTag/team", &context).unwrap(),
Some(ConditionValue::String("core".to_string()))
);
assert_eq!(
assign_context_value(&mut context, "wami:Team", &core),
Ok(false)
);
}
#[test]
fn a_tenant_path_is_read_only_in_its_canonical_form() {
use crate::keys::assign_context_value;
for key in [
"wami:TenantId",
"wami:PrincipalTenantId",
"wami:ResourceTenantId",
] {
for raw in ["05/7", "+5", "5/07", "007", "5/+7"] {
let mut context = ConditionContext::builder().build();
let got = assign_context_value(&mut context, key, &[raw.to_string()]);
assert!(got.is_err(), "{key} took {raw}: {got:?}");
}
for canonical in ["5/7", "0", "12345678/87654321"] {
let mut context = ConditionContext::builder().build();
let got = assign_context_value(&mut context, key, &[canonical.to_string()]);
assert!(got.is_ok(), "{key} refused {canonical}: {got:?}");
}
}
}
#[test]
fn a_value_that_does_not_read_as_its_key_is_refused_without_being_quoted() {
use crate::keys::assign_context_value;
let secret = "s3cr3t".to_string();
for key in [
"aws:SecureTransport",
"wami:SessionAge",
"wami:SessionRiskScore",
"aws:CurrentTime",
"aws:EpochTime",
"aws:SourceIp",
"wami:TenantId",
] {
let mut context = ConditionContext::builder().build();
let err =
assign_context_value(&mut context, key, std::slice::from_ref(&secret)).expect_err(key);
assert!(!format!("{err:?}").contains("s3cr3t"), "{key}: {err:?}");
}
let mut context = ConditionContext::builder().build();
let two = ["a".to_string(), "b".to_string()];
assert!(assign_context_value(&mut context, "aws:username", &two).is_err());
}
#[test]
fn every_part_of_a_condition_is_read_before_it_answers() {
let context = ConditionContext::builder()
.username("alice")
.source_ip("not-an-ip")
.custom_value("wami:Team", ConditionValue::Number(5.0))
.build();
for json in [
r#"{"StringEquals":{"aws:username":"bob"},"IpAddress":{"aws:SourceIp":"10.0.0.0/8"}}"#,
r#"{"StringEquals":{"aws:username":"bob","wami:Team":"5"}}"#,
] {
let outcomes: std::collections::BTreeSet<String> = (0..200)
.map(|_| {
format!(
"{:?}",
evaluate_condition_block(&parse_condition_block_from_json(json), &context)
)
})
.collect();
assert_eq!(outcomes.len(), 1, "{json}: {outcomes:?}");
let outcome = outcomes.into_iter().next().unwrap();
assert!(outcome.starts_with("Err(TypeMismatch"), "{json}: {outcome}");
}
}