reputation_core/

lib.rs

//! # Reputation Core
//! 
//! This crate provides the core reputation calculation engine for the MCP agent
//! reputation system. It implements a hybrid approach combining prior reputation
//! scores with performance-based calculations.

// Forbid unsafe code to ensure memory safety
#![forbid(unsafe_code)] 
//! ## Overview
//! 
//! The reputation system uses a weighted calculation that considers:
//! - **Prior Score**: Initial reputation based on agent credentials (50-80 points)
//! - **Performance Score**: Based on reviews and ratings (0-100 points)
//! - **Confidence Factor**: How much we trust the performance data (0-1)
//! 
//! ## Features (Phase 2)
//! 
//! - **Enhanced Score Structure**: Detailed breakdowns with confidence levels
//! - **Batch Processing**: Efficient parallel processing of multiple agents
//! - **Builder Pattern**: Fluent API for calculator configuration
//! - **Utility Methods**: Score analysis, predictions, and comparisons
//! - **Property Testing**: Comprehensive test coverage with invariant verification
//! 
//! ## Algorithm
//! 
//! The final reputation score is calculated as:
//! ```text
//! final_score = (1 - confidence) * prior_score + confidence * empirical_score
//! ```
//! 
//! Where confidence grows with the number of interactions:
//! ```text
//! confidence = interactions / (interactions + k)
//! ```
//! 
//! ## Examples
//! 
//! ### Basic Usage
//! ```no_run
//! use reputation_core::Calculator;
//! use reputation_types::{AgentData, AgentDataBuilder};
//! 
//! let agent = AgentDataBuilder::new("did:example:123")
//!     .with_reviews(100, 4.3)
//!     .mcp_level(2)
//!     .identity_verified(true)
//!     .build()
//!     .unwrap();
//! 
//! let calculator = Calculator::default();
//! let score = calculator.calculate(&agent).unwrap();
//! 
//! println!("Reputation Score: {:.1}", score.score);
//! println!("Confidence: {:.2}", score.confidence);
//! println!("Level: {:?}", score.level);
//! println!("Is Provisional: {}", score.is_provisional);
//! ```
//! 
//! ### Builder Pattern (Phase 2)
//! ```no_run
//! use reputation_core::{Calculator, CalculatorPreset};
//! 
//! let calculator = Calculator::builder()
//!     .preset(CalculatorPreset::Conservative)
//!     .prior_base(55.0)
//!     .build()
//!     .unwrap();
//! ```
//! 
//! ### Batch Processing (Phase 2)
//! ```no_run
//! use reputation_core::{Calculator, BatchOptions};
//! use reputation_types::AgentData;
//! 
//! # fn load_agents() -> Vec<AgentData> { vec![] }
//! let agents = load_agents(); // Vec<AgentData>
//! let calculator = Calculator::default();
//! 
//! // Simple batch processing
//! let scores = calculator.calculate_batch(&agents);
//! 
//! // With progress tracking
//! let options = BatchOptions {
//!     chunk_size: Some(100),
//!     fail_fast: false,
//!     progress_callback: Some(Box::new(|completed, total| {
//!         println!("Progress: {}/{}", completed, total);
//!     })),
//! };
//! 
//! let result = calculator.calculate_batch_with_options(&agents, options);
//! println!("Processed {} agents in {:?}", 
//!     result.successful_count, result.total_duration);
//! ```
//! 
//! ### Utility Methods (Phase 2)
//! ```no_run
//! use reputation_core::Calculator;
//! use reputation_types::AgentData;
//! 
//! # fn get_agent() -> AgentData { 
//! #     reputation_types::AgentDataBuilder::new("did:test:1")
//! #         .with_reviews(50, 4.0)
//! #         .total_interactions(60)
//! #         .build()
//! #         .unwrap()
//! # }
//! let agent = get_agent();
//! let calculator = Calculator::default();
//! 
//! // Get detailed explanation
//! let explanation = calculator.explain_score(&agent).unwrap();
//! println!("{}", explanation.explanation);
//! 
//! // Calculate needed interactions for target confidence
//! let needed = calculator.interactions_for_confidence(
//!     agent.total_interactions, 0.9
//! ).unwrap();
//! println!("Need {} more interactions for 90% confidence", needed);
//! 
//! // Predict score changes
//! let prediction = calculator.predict_score_change(&agent, 50, 4.5).unwrap();
//! println!("Score would change by {:+.1} points", prediction.score_change);
//! ```
//! 
//! ## Performance Characteristics
//! 
//! - Single calculation: ~50-100μs
//! - Batch 1000 agents: ~388μs (far exceeding <100ms target)
//! - Memory usage: O(1) - no allocations during calculation
//! - Thread-safe: Calculator can be shared across threads
//! - Cache-friendly: Optimized for batch processing

pub mod calculator;
pub mod config;
pub mod error;
pub mod validation;
pub mod performance;

// Re-export main types
pub use calculator::{Calculator, BatchOptions, BatchResult, BatchCalculation};
pub use calculator::builder::{CalculatorBuilder, BonusConfig, CalculatorPreset};
pub use calculator::utils::{ScoreExplanation, ScorePrediction, AgentComparison};
pub use config::CalculatorConfig;
pub use error::{ReputationError, ValidationError, BuilderError, CalculationError, Result};

// Re-export new types from reputation-types for convenience
pub use reputation_types::{ConfidenceLevel, ScoreComponents, PriorBreakdown};

/// Version of the reputation calculation algorithm
pub const ALGORITHM_VERSION: &str = "1.0.0";

#[cfg(test)]
mod tests {
    use super::*;
    use chrono::{Duration, Utc};
    use reputation_types::AgentData;

    fn create_valid_agent() -> AgentData {
        AgentData {
            did: "did:test:123".to_string(),
            created_at: Utc::now() - Duration::days(1),
            mcp_level: None,
            identity_verified: false,
            security_audit_passed: false,
            open_source: false,
            total_interactions: 0,
            total_reviews: 0,
            average_rating: None,
            positive_reviews: 0,
            negative_reviews: 0,
        }
    }

    #[test]
    fn test_default_calculation() {
        let agent = create_valid_agent();
        let calc = Calculator::default();
        let score = calc.calculate(&agent).unwrap();

        assert_eq!(score.score, 50.0);
        assert_eq!(score.confidence, 0.0);
    }

    #[test]
    fn test_invalid_did_format() {
        let mut agent = create_valid_agent();
        agent.did = "invalid-did".to_string();

        let calc = Calculator::default();
        let result = calc.calculate(&agent);

        assert!(result.is_err());
        match result.unwrap_err() {
            ReputationError::ValidationError(ValidationError::InvalidDid(msg)) => {
                // The validation now returns a specific error message about DID format
                assert!(msg.contains("DID must start with 'did:' prefix"));
            }
            _ => panic!("Expected InvalidDid error"),
        }
    }

    #[test]
    fn test_future_date_error() {
        let mut agent = create_valid_agent();
        agent.created_at = Utc::now() + Duration::days(1);

        let calc = Calculator::default();
        let result = calc.calculate(&agent);

        assert!(result.is_err());
        match result.unwrap_err() {
            ReputationError::ValidationError(ValidationError::FutureDate(_)) => {}
            _ => panic!("Expected FutureDate error"),
        }
    }

    #[test]
    fn test_invalid_rating_error() {
        let mut agent = create_valid_agent();
        agent.average_rating = Some(6.0);
        agent.total_reviews = 10;
        agent.positive_reviews = 6;
        agent.negative_reviews = 4;
        agent.total_interactions = 10;

        let calc = Calculator::default();
        let result = calc.calculate(&agent);

        assert!(result.is_err());
        match result.unwrap_err() {
            ReputationError::ValidationError(ValidationError::InvalidRating(rating)) => {
                assert_eq!(rating, 6.0);
            }
            _ => panic!("Expected InvalidRating error"),
        }
    }

    #[test]
    fn test_invalid_mcp_level_error() {
        let mut agent = create_valid_agent();
        agent.mcp_level = Some(5);

        let calc = Calculator::default();
        let result = calc.calculate(&agent);

        assert!(result.is_err());
        match result.unwrap_err() {
            ReputationError::ValidationError(ValidationError::InvalidMcpLevel(level)) => {
                assert_eq!(level, 5);
            }
            _ => panic!("Expected InvalidMcpLevel error"),
        }
    }

    #[test]
    fn test_inconsistent_reviews_error() {
        let mut agent = create_valid_agent();
        agent.positive_reviews = 10;
        agent.negative_reviews = 5;
        agent.total_reviews = 20; // Should be 15
        agent.total_interactions = 20;
        agent.average_rating = Some(4.0);

        let calc = Calculator::default();
        let result = calc.calculate(&agent);

        assert!(result.is_err());
        match result.unwrap_err() {
            ReputationError::ValidationError(ValidationError::InconsistentReviews) => {
                // The new validation module returns a simpler error without the specific counts
            }
            _ => panic!("Expected InconsistentReviews error"),
        }
    }

    #[test]
    fn test_reviews_exceed_interactions_error() {
        let mut agent = create_valid_agent();
        agent.total_reviews = 10;
        agent.positive_reviews = 6;
        agent.negative_reviews = 4;
        agent.total_interactions = 5;
        agent.average_rating = Some(4.0); // Add rating to avoid rating consistency error

        let calc = Calculator::default();
        let result = calc.calculate(&agent);

        assert!(result.is_err());
        match result.unwrap_err() {
            ReputationError::ValidationError(ValidationError::InvalidField { field, .. }) => {
                assert_eq!(field, "total_reviews");
            }
            _ => panic!("Expected InvalidField error"),
        }
    }

    #[test]
    fn test_calculator_new_invalid_confidence_k() {
        let result = Calculator::new(-1.0, 50.0, 80.0);
        assert!(result.is_err());
        match result.unwrap_err() {
            ReputationError::CalculationError(msg) => {
                assert!(msg.contains("confidence_k must be positive"));
            }
            _ => panic!("Expected BuilderError for negative confidence_k"),
        }
    }

    #[test]
    fn test_calculator_new_invalid_prior_base() {
        let result = Calculator::new(15.0, -10.0, 80.0);
        assert!(result.is_err());

        let result = Calculator::new(15.0, 110.0, 80.0);
        assert!(result.is_err());
    }

    #[test]
    fn test_calculator_new_invalid_prior_max() {
        let result = Calculator::new(15.0, 50.0, 40.0); // max < base
        assert!(result.is_err());

        let result = Calculator::new(15.0, 50.0, 110.0); // max > 100
        assert!(result.is_err());
    }

    #[test]
    fn test_valid_calculation_with_reviews() {
        let mut agent = create_valid_agent();
        agent.total_interactions = 100;
        agent.total_reviews = 50;
        agent.positive_reviews = 40;
        agent.negative_reviews = 10;
        agent.average_rating = Some(4.2);
        agent.mcp_level = Some(2);

        let calc = Calculator::default();
        let score = calc.calculate(&agent).unwrap();

        assert!(score.score > 50.0); // Should be above base due to good rating
        assert!(score.confidence > 0.0 && score.confidence < 1.0);
    }

    #[test]
    fn test_edge_case_minimum_rating() {
        let mut agent = create_valid_agent();
        agent.total_interactions = 10;
        agent.total_reviews = 10;
        agent.positive_reviews = 0;
        agent.negative_reviews = 10;
        agent.average_rating = Some(1.0);

        let calc = Calculator::default();
        let score = calc.calculate(&agent).unwrap();

        assert!(score.score >= 0.0);
        assert!(score.score <= 100.0);
    }

    #[test]
    fn test_edge_case_maximum_rating() {
        let mut agent = create_valid_agent();
        agent.total_interactions = 10;
        agent.total_reviews = 10;
        agent.positive_reviews = 10;
        agent.negative_reviews = 0;
        agent.average_rating = Some(5.0);

        let calc = Calculator::default();
        let score = calc.calculate(&agent).unwrap();

        assert!(score.score >= 0.0);
        assert!(score.score <= 100.0);
    }

    #[test]
    fn test_mcp_level_bonuses() {
        let base_agent = create_valid_agent();
        let calc = Calculator::default();

        // Test each MCP level
        for level in 0..=3 {
            let mut agent = base_agent.clone();
            agent.mcp_level = Some(level);
            let score = calc.calculate(&agent).unwrap();
            
            // With no reviews, score should be prior (base + mcp bonus)
            let expected_bonus = match level {
                1 => 5.0,
                2 => 10.0,
                3 => 15.0,
                _ => 0.0,
            };
            assert_eq!(score.score, 50.0 + expected_bonus);
        }
    }

    #[test]
    fn test_confidence_calculation() {
        let calc = Calculator::default();
        let mut agent = create_valid_agent();
        
        // Test various interaction counts
        let test_cases = vec![(0, 0.0), (15, 0.5), (30, 0.667), (150, 0.909)];
        
        for (interactions, expected_confidence) in test_cases {
            agent.total_interactions = interactions;
            let score = calc.calculate(&agent).unwrap();
            assert!((score.confidence - expected_confidence).abs() < 0.01);
        }
    }

    #[test]
    fn test_error_propagation_chain() {
        // Test that errors properly propagate through the calculation chain
        let mut agent = create_valid_agent();
        agent.did = "bad-did".to_string();
        agent.average_rating = Some(10.0); // Also invalid
        
        let calc = Calculator::default();
        let result = calc.calculate(&agent);
        
        assert!(result.is_err());
        // Should get the first error (DID validation)
        match result.unwrap_err() {
            ReputationError::ValidationError(ValidationError::InvalidDid(_)) => {}
            _ => panic!("Expected InvalidDid error to be caught first"),
        }
    }

    #[test]
    fn test_valid_edge_case_ratings() {
        let calc = Calculator::default();
        
        // Test exact boundary values
        let test_ratings = vec![1.0, 5.0, 3.0];
        
        for rating in test_ratings {
            let mut agent = create_valid_agent();
            agent.total_interactions = 50;
            agent.total_reviews = 50;
            agent.positive_reviews = 25;
            agent.negative_reviews = 25;
            agent.average_rating = Some(rating);
            
            let result = calc.calculate(&agent);
            assert!(result.is_ok(), "Rating {} should be valid", rating);
        }
    }

    #[test]
    fn test_zero_confidence_k_prevention() {
        let result = Calculator::new(0.0, 50.0, 80.0);
        assert!(result.is_err());
    }

    #[test]
    fn test_nan_prevention_in_calculation() {
        // This test ensures our NaN checks work
        // Even though with current logic it's hard to produce NaN,
        // the check exists for robustness
        let calc = Calculator::default();
        let agent = create_valid_agent();
        
        // Normal calculation shouldn't produce NaN
        let result = calc.calculate(&agent);
        assert!(result.is_ok());
        let score = result.unwrap();
        assert!(!score.score.is_nan());
        assert!(!score.confidence.is_nan());
    }

    #[test]
    fn test_all_identity_flags() {
        let calc = Calculator::default();
        let mut agent = create_valid_agent();
        
        // Test with all identity flags set
        agent.identity_verified = true;
        agent.security_audit_passed = true;
        agent.open_source = true;
        agent.mcp_level = Some(3);
        
        let result = calc.calculate(&agent);
        assert!(result.is_ok());
        
        // With all bonuses: 50 base + 15 (MCP3) + 5 (identity) + 7 (security) + 3 (open source) = 80
        let score = result.unwrap();
        assert_eq!(score.score, 80.0); // Hits the cap
    }

    #[test]
    fn test_identity_verified_bonus() {
        let calc = Calculator::default();
        
        // Test without identity verified
        let mut agent = create_valid_agent();
        let score_without = calc.calculate(&agent).unwrap();
        
        // Test with identity verified
        agent.identity_verified = true;
        let score_with = calc.calculate(&agent).unwrap();
        
        // Should add 5 points
        assert_eq!(score_with.score - score_without.score, 5.0);
        assert_eq!(score_with.score, 55.0); // 50 base + 5 identity
    }

    #[test]
    fn test_security_audit_bonus() {
        let calc = Calculator::default();
        
        // Test without security audit
        let mut agent = create_valid_agent();
        let score_without = calc.calculate(&agent).unwrap();
        
        // Test with security audit
        agent.security_audit_passed = true;
        let score_with = calc.calculate(&agent).unwrap();
        
        // Should add 7 points
        assert_eq!(score_with.score - score_without.score, 7.0);
        assert_eq!(score_with.score, 57.0); // 50 base + 7 security
    }

    #[test]
    fn test_open_source_bonus() {
        let calc = Calculator::default();
        
        // Test without open source
        let mut agent = create_valid_agent();
        let score_without = calc.calculate(&agent).unwrap();
        
        // Test with open source
        agent.open_source = true;
        let score_with = calc.calculate(&agent).unwrap();
        
        // Should add 3 points
        assert_eq!(score_with.score - score_without.score, 3.0);
        assert_eq!(score_with.score, 53.0); // 50 base + 3 open source
    }

    #[test]
    fn test_age_bonus() {
        let calc = Calculator::default();
        
        // Test with young agent (1 day old)
        let mut agent = create_valid_agent();
        agent.created_at = Utc::now() - Duration::days(1);
        let score_young = calc.calculate(&agent).unwrap();
        
        // Test with old agent (400 days old)
        agent.created_at = Utc::now() - Duration::days(400);
        let score_old = calc.calculate(&agent).unwrap();
        
        // Should add 5 points for agents > 365 days
        assert_eq!(score_old.score - score_young.score, 5.0);
        assert_eq!(score_young.score, 50.0); // 50 base, no age bonus
        assert_eq!(score_old.score, 55.0); // 50 base + 5 age bonus
    }

    #[test]
    fn test_age_bonus_edge_cases() {
        let calc = Calculator::default();
        let mut agent = create_valid_agent();
        
        // Test exactly 365 days (no bonus)
        agent.created_at = Utc::now() - Duration::days(365);
        let score_365 = calc.calculate(&agent).unwrap();
        assert_eq!(score_365.score, 50.0); // No age bonus
        
        // Test 366 days (gets bonus)
        agent.created_at = Utc::now() - Duration::days(366);
        let score_366 = calc.calculate(&agent).unwrap();
        assert_eq!(score_366.score, 55.0); // Gets age bonus
    }

    #[test]
    fn test_combined_bonuses() {
        let calc = Calculator::default();
        let mut agent = create_valid_agent();
        
        // Test various combinations
        agent.mcp_level = Some(2); // +10
        agent.identity_verified = true; // +5
        let score = calc.calculate(&agent).unwrap();
        assert_eq!(score.score, 65.0); // 50 + 10 + 5
        
        // Add more bonuses
        agent.open_source = true; // +3
        let score = calc.calculate(&agent).unwrap();
        assert_eq!(score.score, 68.0); // 50 + 10 + 5 + 3
        
        // Add security audit
        agent.security_audit_passed = true; // +7
        let score = calc.calculate(&agent).unwrap();
        assert_eq!(score.score, 75.0); // 50 + 10 + 5 + 3 + 7
    }

    #[test]
    fn test_prior_score_cap() {
        let calc = Calculator::default();
        let mut agent = create_valid_agent();
        
        // Set all bonuses to exceed the cap
        agent.mcp_level = Some(3); // +15
        agent.identity_verified = true; // +5
        agent.security_audit_passed = true; // +7
        agent.open_source = true; // +3
        agent.created_at = Utc::now() - Duration::days(400); // +5 age bonus
        
        // Total would be 50 + 15 + 5 + 7 + 3 + 5 = 85, but capped at 80
        let score = calc.calculate(&agent).unwrap();
        assert_eq!(score.score, 80.0);
    }

    #[test]
    fn test_prior_score_cap_with_interactions() {
        let calc = Calculator::default();
        let mut agent = create_valid_agent();
        
        // Max out prior bonuses
        agent.mcp_level = Some(3);
        agent.identity_verified = true;
        agent.security_audit_passed = true;
        agent.open_source = true;
        agent.created_at = Utc::now() - Duration::days(400);
        
        // Add some interactions with good rating
        agent.total_interactions = 50;
        agent.total_reviews = 50;
        agent.positive_reviews = 45;
        agent.negative_reviews = 5;
        agent.average_rating = Some(4.5);
        
        let score = calc.calculate(&agent).unwrap();
        
        // Prior is capped at 80, empirical is 87.5 ((4.5-1)*25)
        // With 50 interactions, confidence = 50/(50+15) ≈ 0.769
        // Final score = 0.231 * 80 + 0.769 * 87.5 ≈ 85.76
        assert!(score.score > 80.0); // Shows that prior cap doesn't limit final score
        assert!(score.score < 90.0);
    }

    #[test]
    fn test_enhanced_score_structure() {
        let calc = Calculator::default();
        let mut agent = create_valid_agent();
        
        // Set up an agent with some data
        agent.total_interactions = 50;
        agent.total_reviews = 30;
        agent.positive_reviews = 25;
        agent.negative_reviews = 5;
        agent.average_rating = Some(4.2);
        agent.mcp_level = Some(2);
        agent.identity_verified = true;
        
        let score = calc.calculate(&agent).unwrap();
        
        // Test new fields
        assert_eq!(score.level, ConfidenceLevel::High); // 50/(50+15) ≈ 0.77 which is > 0.7
        assert!(!score.is_provisional); // confidence > 0.2
        assert_eq!(score.data_points, 80); // 50 + 30
        
        // Test components
        assert_eq!(score.components.prior_score, 65.0); // 50 + 10 + 5
        assert_eq!(score.components.empirical_score, 80.0); // (4.2-1)*25
        assert_eq!(score.components.confidence_level, ConfidenceLevel::High);
        assert!(score.components.confidence_value > 0.7);
        
        // Test prior breakdown
        assert_eq!(score.components.prior_breakdown.base_score, 50.0);
        assert_eq!(score.components.prior_breakdown.mcp_bonus, 10.0);
        assert_eq!(score.components.prior_breakdown.identity_bonus, 5.0);
        assert_eq!(score.components.prior_breakdown.total, 65.0);
    }

    #[test]
    fn test_provisional_score() {
        let calc = Calculator::default();
        let mut agent = create_valid_agent();
        
        // Very few interactions
        agent.total_interactions = 2;
        agent.total_reviews = 2;
        agent.positive_reviews = 1;
        agent.negative_reviews = 1;
        agent.average_rating = Some(3.0);
        
        let score = calc.calculate(&agent).unwrap();
        
        // Should be provisional
        assert!(score.is_provisional);
        assert_eq!(score.level, ConfidenceLevel::Low);
        assert!(score.confidence < 0.2);
    }

    #[test]
    fn test_confidence_level_boundaries() {
        let calc = Calculator::default();
        let mut agent = create_valid_agent();
        
        // Test Low confidence (< 0.2)
        agent.total_interactions = 3; // 3/(3+15) = 0.167
        agent.total_reviews = 3;
        agent.positive_reviews = 2;
        agent.negative_reviews = 1;
        agent.average_rating = Some(4.0);
        let score = calc.calculate(&agent).unwrap();
        assert_eq!(score.level, ConfidenceLevel::Low);
        
        // Test Medium confidence (0.2-0.7)
        agent.total_interactions = 15; // 15/(15+15) = 0.5
        agent.total_reviews = 15;
        agent.positive_reviews = 12;
        agent.negative_reviews = 3;
        let score = calc.calculate(&agent).unwrap();
        assert_eq!(score.level, ConfidenceLevel::Medium);
        
        // Test High confidence (>= 0.7)
        agent.total_interactions = 50; // 50/(50+15) ≈ 0.77
        agent.total_reviews = 40;
        agent.positive_reviews = 32;
        agent.negative_reviews = 8;
        let score = calc.calculate(&agent).unwrap();
        assert_eq!(score.level, ConfidenceLevel::High);
    }

    #[test]
    fn test_individual_bonus_independence() {
        let calc = Calculator::default();
        
        // Test that each bonus works independently
        let base_agent = create_valid_agent();
        let base_score = calc.calculate(&base_agent).unwrap().score;
        
        // Test identity verified bonus
        let mut agent = base_agent.clone();
        agent.identity_verified = true;
        let score = calc.calculate(&agent).unwrap().score;
        assert_eq!(score - base_score, 5.0, "Identity bonus should be 5");
        
        // Test security audit bonus
        let mut agent = base_agent.clone();
        agent.security_audit_passed = true;
        let score = calc.calculate(&agent).unwrap().score;
        assert_eq!(score - base_score, 7.0, "Security audit bonus should be 7");
        
        // Test open source bonus
        let mut agent = base_agent.clone();
        agent.open_source = true;
        let score = calc.calculate(&agent).unwrap().score;
        assert_eq!(score - base_score, 3.0, "Open source bonus should be 3");
        
        // Test MCP level 1 bonus
        let mut agent = base_agent.clone();
        agent.mcp_level = Some(1);
        let score = calc.calculate(&agent).unwrap().score;
        assert_eq!(score - base_score, 5.0, "MCP level 1 bonus should be 5");
        
        // Test age bonus
        let mut agent = base_agent.clone();
        agent.created_at = Utc::now() - Duration::days(400);
        let score = calc.calculate(&agent).unwrap().score;
        assert_eq!(score - base_score, 5.0, "Age bonus should be 5");
    }
}