mod fixtures;

use fixtures::builders::{OidcClaimsBuilder, AccessPolicyBuilder};
use fixtures::mocks::{MockPolicyProvider, MockAuditLogger, ConstantScorer};

#[test]
fn test_oidc_claims_builder() {
    let claims = OidcClaimsBuilder::new("charlie")
        .group("platform-team")
        .group("devops-team")
        .permission("memory:read")
        .build();

    assert_eq!(claims.sub, "charlie");
    assert_eq!(claims.groups.len(), 2);
    assert!(claims.permissions.contains(&"memory:read".to_string()));
}

#[test]
fn test_access_policy_builder_public() {
    let policy = AccessPolicyBuilder::public().build();

    assert_eq!(policy.access_level, "public");
    assert!(policy.owner_group.is_empty());
}

#[test]
fn test_access_policy_builder_private() {
    let policy = AccessPolicyBuilder::public()
        .private("ml-team")
        .build();

    assert_eq!(policy.access_level, "private");
    assert_eq!(policy.owner_group, "ml-team");
}

#[tokio::test]
async fn test_mock_policy_provider() {
    let provider = MockPolicyProvider::new();
    let policy = AccessPolicyBuilder::public()
        .group(vec!["platform-team", "devops-team"])
        .build();

    let provider = provider.with_policy("project", "poimen", policy.clone());
    let retrieved = provider.get_policy("project", "poimen").await.unwrap();

    assert_eq!(retrieved.access_level, policy.access_level);
}

#[test]
fn test_mock_audit_logger() {
    let logger = MockAuditLogger::new();
    logger.log_decision_sync("charlie:allow".to_string());

    let decisions = logger.decisions();
    assert_eq!(decisions.len(), 1);
    assert!(decisions[0].contains("charlie"));
}

#[test]
fn test_constant_scorer() {
    let scorer = ConstantScorer::new(0.75);
    assert_eq!(scorer.name(), "constant-mock");
}