mockforge-core 0.3.114

Shared logic for MockForge - routing, validation, latency, proxy
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

//! Behavioral Economics configuration
//!
//! Defines the configuration structure for the behavioral economics engine,
//! including rule definitions and engine settings.

use crate::behavioral_economics::rules::BehaviorRule;
use serde::{Deserialize, Serialize};

/// Behavioral Economics configuration
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
pub struct BehavioralEconomicsConfig {
    /// Enable behavioral economics engine
    #[serde(default)]
    pub enabled: bool,

    /// List of behavior rules
    #[serde(default)]
    pub rules: Vec<BehaviorRule>,

    /// Evaluation interval in milliseconds (how often to re-evaluate conditions)
    #[serde(default = "default_evaluation_interval")]
    pub evaluation_interval_ms: u64,

    /// Enable metrics collection
    #[serde(default = "default_true")]
    pub enable_metrics: bool,
}

fn default_evaluation_interval() -> u64 {
    1000 // 1 second
}

fn default_true() -> bool {
    true
}

impl BehavioralEconomicsConfig {
    /// Create a new configuration
    pub fn new() -> Self {
        Self::default()
    }

    /// Add a rule
    pub fn with_rule(mut self, rule: BehaviorRule) -> Self {
        self.rules.push(rule);
        self
    }

    /// Enable the engine
    pub fn enable(mut self) -> Self {
        self.enabled = true;
        self
    }

    /// Disable the engine
    pub fn disable(mut self) -> Self {
        self.enabled = false;
        self
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::behavioral_economics::actions::BehaviorAction;
    use crate::behavioral_economics::conditions::BehaviorCondition;
    use crate::behavioral_economics::rules::BehaviorRule;

    #[test]
    fn test_config_creation() {
        let config = BehavioralEconomicsConfig::new();
        assert!(!config.enabled);
        assert!(config.rules.is_empty());
    }

    #[test]
    fn test_config_with_rule() {
        let rule = BehaviorRule::declarative(
            "test-rule".to_string(),
            BehaviorCondition::Always,
            BehaviorAction::NoOp,
            100,
        );
        let config = BehavioralEconomicsConfig::new().with_rule(rule);
        assert_eq!(config.rules.len(), 1);
    }
}