mockforge-http 0.3.116

HTTP/REST protocol support for MockForge
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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

//! Production headers middleware for deceptive deploy
//!
//! This module provides middleware that adds production-like headers to all responses,
//! supporting template expansion for dynamic values like request IDs.

use axum::{
    body::Body,
    extract::State,
    http::{HeaderName, HeaderValue, Request},
    middleware::Next,
    response::Response,
};
use tracing::debug;
use uuid::Uuid;

use crate::HttpServerState;

/// Production headers middleware
///
/// Adds configured headers to all responses, with support for template expansion.
/// Templates supported:
/// - `{{uuid}}` - Generates a new UUID for each request
/// - `{{now}}` - Current timestamp in RFC3339 format
/// - `{{timestamp}}` - Current Unix timestamp
pub async fn production_headers_middleware(
    State(state): State<HttpServerState>,
    req: Request<Body>,
    next: Next,
) -> Response<Body> {
    // Process the request
    let mut response = next.run(req).await;

    // Get headers configuration from state
    if let Some(headers) = &state.production_headers {
        for (key, value) in headers.iter() {
            // Expand templates in header values
            let expanded_value = expand_templates(value);

            // Parse header name and value
            if let (Ok(header_name), Ok(header_value)) =
                (key.parse::<HeaderName>(), expanded_value.parse::<HeaderValue>())
            {
                // Only add if not already present (don't override existing headers)
                if !response.headers().contains_key(&header_name) {
                    response.headers_mut().insert(header_name, header_value);
                    debug!("Added production header: {} = {}", key, expanded_value);
                }
            } else {
                tracing::warn!("Failed to parse production header: {} = {}", key, expanded_value);
            }
        }
    }

    response
}

/// Expand template placeholders in header values
///
/// Supported templates:
/// - `{{uuid}}` - Generates a new UUID v4
/// - `{{now}}` - Current timestamp in RFC3339 format
/// - `{{timestamp}}` - Current Unix timestamp (seconds)
fn expand_templates(value: &str) -> String {
    let mut result = value.to_string();

    // Replace {{uuid}} with a new UUID
    if result.contains("{{uuid}}") {
        let uuid = Uuid::new_v4().to_string();
        result = result.replace("{{uuid}}", &uuid);
    }

    // Replace {{now}} with current RFC3339 timestamp
    if result.contains("{{now}}") {
        let now = chrono::Utc::now().to_rfc3339();
        result = result.replace("{{now}}", &now);
    }

    // Replace {{timestamp}} with Unix timestamp
    if result.contains("{{timestamp}}") {
        let timestamp = chrono::Utc::now().timestamp().to_string();
        result = result.replace("{{timestamp}}", &timestamp);
    }

    result
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_expand_uuid_template() {
        let value = "{{uuid}}";
        let expanded = expand_templates(value);
        // UUID should be 36 characters (with hyphens)
        assert_eq!(expanded.len(), 36);
        assert!(!expanded.contains("{{uuid}}"));
    }

    #[test]
    fn test_expand_now_template() {
        let value = "{{now}}";
        let expanded = expand_templates(value);
        // RFC3339 timestamp should be around 20 characters
        assert!(expanded.len() > 15);
        assert!(!expanded.contains("{{now}}"));
        // Should contain 'T' separator (RFC3339 format)
        assert!(expanded.contains('T'));
    }

    #[test]
    fn test_expand_timestamp_template() {
        let value = "{{timestamp}}";
        let expanded = expand_templates(value);
        // Unix timestamp should be numeric
        assert!(expanded.parse::<i64>().is_ok());
        assert!(!expanded.contains("{{timestamp}}"));
    }

    #[test]
    fn test_expand_multiple_templates() {
        let value = "Request-{{uuid}} at {{timestamp}}";
        let expanded = expand_templates(value);
        assert!(!expanded.contains("{{uuid}}"));
        assert!(!expanded.contains("{{timestamp}}"));
        assert!(expanded.starts_with("Request-"));
    }

    #[test]
    fn test_no_templates() {
        let value = "Static header value";
        let expanded = expand_templates(value);
        assert_eq!(expanded, value);
    }
}