elif-http 0.8.8

HTTP server core for the elif.rs LLM-friendly web framework
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

//! Tests for HTTP server functionality

#[cfg(test)]
mod tests {
    use super::*;
    use crate::{HttpConfig, Server};
    use elif_core::{
        container::IocContainer,
        app_config::{AppConfigTrait},
    };
    use std::sync::Arc;

    fn create_test_container() -> Arc<IocContainer> {
        // TODO: Implement proper test container setup after refactor
        let mut container = IocContainer::new();
        container.build().expect("Test container build failed");
        Arc::new(container)
    }

    #[test]
    fn test_http_config_defaults() {
        let config = HttpConfig::default();
        
        assert_eq!(config.request_timeout_secs, 30);
        assert_eq!(config.keep_alive_timeout_secs, 75);
        assert_eq!(config.max_request_size, 16 * 1024 * 1024);
        assert!(config.enable_tracing);
        assert_eq!(config.health_check_path, "/health");
        assert_eq!(config.shutdown_timeout_secs, 10);
    }

    #[test]
    fn test_http_config_from_env() {
        std::env::remove_var("HTTP_REQUEST_TIMEOUT");
        std::env::remove_var("HTTP_KEEP_ALIVE_TIMEOUT");
        
        let config = HttpConfig::from_env().unwrap();
        config.validate().unwrap();
        
        // Test duration helpers
        assert_eq!(config.request_timeout().as_secs(), 30);
        assert_eq!(config.keep_alive_timeout().as_secs(), 75);
        assert_eq!(config.shutdown_timeout().as_secs(), 10);
    }

    #[test]
    fn test_http_config_validation() {
        let mut config = HttpConfig::default();
        assert!(config.validate().is_ok());

        // Test invalid request timeout
        config.request_timeout_secs = 0;
        assert!(config.validate().is_err());

        // Test invalid health check path
        config = HttpConfig::default();
        config.health_check_path = "no-slash".to_string();
        assert!(config.validate().is_err());

        config.health_check_path = "".to_string();
        assert!(config.validate().is_err());
    }

    #[test]
    fn test_server_creation_with_container() {
        let container = create_test_container();
        let http_config = HttpConfig::default();

        let server = Server::with_container(container, http_config);
        assert!(server.is_ok());
    }

    #[test]
    fn test_server_with_invalid_address() {
        let container = create_test_container();
        let http_config = HttpConfig::default();
        
        let server = Server::with_container(container, http_config).unwrap();
        
        // Test with invalid address - this should fail during listen, not creation
        // For now, just verify server can be created with valid configuration
        // Invalid address testing would be done in integration tests with actual listen() calls
    }

    #[tokio::test]
    async fn test_health_check_endpoint() {
        use crate::server::health_check;
        
        let container = create_test_container();
        let config = HttpConfig::default();
        
        let response = health_check(container, config).await;
        let value = response.0;
        
        assert_eq!(value["status"], "healthy");
        assert_eq!(value["framework"], "Elif.rs");
        assert!(value["timestamp"].is_number());
    }

    #[test]
    fn test_http_error_types() {
        use crate::error::HttpError;
        use crate::response::ElifStatusCode as StatusCode;
        
        let startup_error = HttpError::startup("Failed to bind");
        assert_eq!(startup_error.status_code(), StatusCode::INTERNAL_SERVER_ERROR);
        assert_eq!(startup_error.error_code(), "SERVER_STARTUP_FAILED");
        
        let timeout_error = HttpError::RequestTimeout;
        assert_eq!(timeout_error.status_code(), StatusCode::REQUEST_TIMEOUT);
        assert_eq!(timeout_error.error_code(), "REQUEST_TIMEOUT");
        
        let bad_request = HttpError::bad_request("Invalid input");
        assert_eq!(bad_request.status_code(), StatusCode::BAD_REQUEST);
        assert_eq!(bad_request.error_code(), "BAD_REQUEST");
    }

    #[test]
    fn test_error_conversions() {
        use crate::error::HttpError;
        use elif_core::ConfigError;
        
        // Test ConfigError conversion
        let config_error = ConfigError::validation_failed("Test validation error");
        let http_error: HttpError = config_error.into();
        assert!(matches!(http_error, HttpError::ConfigError { .. }));
        
        // Test IO error conversion
        let io_error = std::io::Error::new(std::io::ErrorKind::PermissionDenied, "Access denied");
        let http_error: HttpError = io_error.into();
        assert!(matches!(http_error, HttpError::InternalError { .. }));
    }
}