refactor: unify error handling, graceful shutdown, and constants across framework
This commit is contained in:
ForgeCode
@@ -0,0 +1,315 @@
|
||||
//! Integration tests for the Servme HTTP framework.
|
||||
//!
|
||||
//! These tests verify the end-to-end functionality of the server
|
||||
//! including middleware chains and request handling.
|
||||
|
||||
use http_body_util::Full;
|
||||
use hyper::{body::Bytes, Request, Response};
|
||||
use servme::{
|
||||
Responder, Server, ServerBuilder, ServerConfig, ServerError, UrlExtract,
|
||||
middleware::{Claims, Middleware, MiddlewareFuture, MiddlewareResult},
|
||||
};
|
||||
use std::net::IpAddr;
|
||||
use tokio::time::{timeout, Duration};
|
||||
|
||||
// Helper to create a simple in-memory test
|
||||
mod helpers {
|
||||
use super::*;
|
||||
|
||||
/// A simple middleware that adds a custom header
|
||||
pub struct TestMiddleware;
|
||||
|
||||
impl TestMiddleware {
|
||||
pub fn new() -> Self {
|
||||
Self
|
||||
}
|
||||
}
|
||||
|
||||
impl Middleware for TestMiddleware {
|
||||
fn run(&self, req: Request<Incoming>) -> MiddlewareFuture<'_> {
|
||||
Box::pin(async move {
|
||||
MiddlewareResult::Continue(req)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
use http::Request;
|
||||
use hyper::body::Incoming;
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Server Configuration Tests
|
||||
// ============================================================================
|
||||
|
||||
#[test]
|
||||
fn test_server_builder_default_config() {
|
||||
let builder = ServerBuilder::new();
|
||||
|
||||
// Verify default values
|
||||
assert_eq!(builder.config.ip, "127.0.0.1");
|
||||
assert_eq!(builder.config.port, 8080);
|
||||
assert!(builder.middlewares.is_empty());
|
||||
assert!(builder.data.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_server_builder_with_address() {
|
||||
let builder = ServerBuilder::new()
|
||||
.address("0.0.0.0", 3000);
|
||||
|
||||
assert_eq!(builder.config.ip, "0.0.0.0");
|
||||
assert_eq!(builder.config.port, 3000);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_server_builder_chaining() {
|
||||
let server = ServerBuilder::new()
|
||||
.address("127.0.0.1", 8080)
|
||||
.add_api_key_middleware("test-key")
|
||||
.build();
|
||||
|
||||
assert_eq!(server.config.ip, "127.0.0.1");
|
||||
assert_eq!(server.config.port, 8080);
|
||||
assert_eq!(server.middlewares.len(), 1);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_server_config_default() {
|
||||
let config = ServerConfig::default();
|
||||
assert_eq!(config.ip, "127.0.0.1");
|
||||
assert_eq!(config.port, 8080);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Responder Tests
|
||||
// ============================================================================
|
||||
|
||||
#[test]
|
||||
fn test_responder_ok() {
|
||||
let result = Responder::ok("Hello");
|
||||
assert!(result.is_ok());
|
||||
|
||||
let response = result.unwrap();
|
||||
assert_eq!(response.status(), http::StatusCode::OK);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_responder_json() {
|
||||
#[derive(serde::Serialize)]
|
||||
struct TestData {
|
||||
name: String,
|
||||
value: i32,
|
||||
}
|
||||
|
||||
let data = TestData {
|
||||
name: "test".to_string(),
|
||||
value: 42,
|
||||
};
|
||||
|
||||
let result = Responder::json(&data);
|
||||
assert!(result.is_ok());
|
||||
|
||||
let response = result.unwrap();
|
||||
assert_eq!(response.status(), http::StatusCode::OK);
|
||||
assert_eq!(
|
||||
response.headers().get("content-type").unwrap(),
|
||||
"application/json"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_responder_redirect() {
|
||||
let result = Responder::redirect("/new-location");
|
||||
assert!(result.is_ok());
|
||||
|
||||
let response = result.unwrap();
|
||||
assert_eq!(response.status(), http::StatusCode::SEE_OTHER);
|
||||
assert_eq!(
|
||||
response.headers().get("location").unwrap(),
|
||||
"/new-location"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_responder_redirect_empty_fails() {
|
||||
let result = Responder::redirect("");
|
||||
assert!(result.is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_responder_status_codes() {
|
||||
assert!(Responder::not_found().is_ok());
|
||||
assert!(Responder::unauthorized().is_ok());
|
||||
assert!(Responder::forbidden().is_ok());
|
||||
assert!(Responder::bad_request("bad").is_ok());
|
||||
assert!(Responder::no_content().is_ok());
|
||||
assert!(Responder::internal_error("error").is_ok());
|
||||
|
||||
let response = Responder::not_found().unwrap();
|
||||
assert_eq!(response.status(), http::StatusCode::NOT_FOUND);
|
||||
|
||||
let response = Responder::unauthorized().unwrap();
|
||||
assert_eq!(response.status(), http::StatusCode::UNAUTHORIZED);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Middleware Tests
|
||||
// ============================================================================
|
||||
|
||||
#[test]
|
||||
fn test_api_key_middleware_creation() {
|
||||
use servme::middleware::ApiKeyMiddleware;
|
||||
|
||||
let middleware = ApiKeyMiddleware::new("test-key");
|
||||
assert_eq!(middleware.api_key, "test-key");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ip_filter_middleware_validation() {
|
||||
use servme::middleware::IpFilterMiddleware;
|
||||
|
||||
// Valid IPs should work
|
||||
let result = IpFilterMiddleware::new(vec![], false);
|
||||
assert!(result.is_ok());
|
||||
|
||||
let result = IpFilterMiddleware::new(
|
||||
vec!["192.168.1.1".to_string(), "10.0.0.1".to_string()],
|
||||
false
|
||||
);
|
||||
assert!(result.is_ok());
|
||||
|
||||
// Invalid IP should fail
|
||||
let result = IpFilterMiddleware::new(
|
||||
vec!["not-an-ip".to_string()],
|
||||
false
|
||||
);
|
||||
assert!(result.is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ip_filter_authorization() {
|
||||
use servme::middleware::IpFilterMiddleware;
|
||||
|
||||
// Test with unchecked for simpler testing
|
||||
let middleware = IpFilterMiddleware::new_unchecked(
|
||||
vec!["192.168.1.100".to_string()],
|
||||
false
|
||||
);
|
||||
|
||||
let allowed_ip: IpAddr = "192.168.1.100".parse().unwrap();
|
||||
let denied_ip: IpAddr = "192.168.1.200".parse().unwrap();
|
||||
|
||||
assert!(middleware.is_authorized(&allowed_ip));
|
||||
assert!(!middleware.is_authorized(&denied_ip));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_ip_filter_ipv6() {
|
||||
use servme::middleware::IpFilterMiddleware;
|
||||
|
||||
let middleware = IpFilterMiddleware::new_unchecked(
|
||||
vec!["::1".to_string()],
|
||||
false,
|
||||
);
|
||||
|
||||
let ipv6_local: IpAddr = "::1".parse().unwrap();
|
||||
let ipv6_other: IpAddr = "::2".parse().unwrap();
|
||||
|
||||
assert!(middleware.is_authorized(&ipv6_local));
|
||||
assert!(!middleware.is_authorized(&ipv6_other));
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// URL Extract Tests
|
||||
// ============================================================================
|
||||
|
||||
#[test]
|
||||
fn test_url_extract_params() {
|
||||
use http::Uri;
|
||||
|
||||
let uri: Uri = "/api?name=test&value=42".parse().unwrap();
|
||||
let extractor = UrlExtract::new(&uri);
|
||||
|
||||
assert_eq!(extractor.param_str("name"), Some("test".to_string()));
|
||||
assert_eq!(extractor.param_i64("value"), Some(42));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_url_extract_missing_param() {
|
||||
use http::Uri;
|
||||
|
||||
let uri: Uri = "/api".parse().unwrap();
|
||||
let extractor = UrlExtract::new(&uri);
|
||||
|
||||
assert_eq!(extractor.param_str("missing"), None);
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Claims Tests
|
||||
// ============================================================================
|
||||
|
||||
#[test]
|
||||
fn test_claims_is_expired() {
|
||||
use servme::middleware::auth_types::Claims;
|
||||
|
||||
let claims = Claims {
|
||||
sub: "user123".to_string(),
|
||||
exp: 1000, // Very old timestamp
|
||||
};
|
||||
|
||||
assert!(claims.is_expired(2000)); // Current time > exp
|
||||
assert!(!claims.is_expired(500)); // Current time < exp
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_claims_username() {
|
||||
use servme::middleware::auth_types::Claims;
|
||||
|
||||
let claims = Claims {
|
||||
sub: "testuser".to_string(),
|
||||
exp: 9999999999,
|
||||
};
|
||||
|
||||
assert_eq!(claims.username(), "testuser");
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Error Handling Tests
|
||||
// ============================================================================
|
||||
|
||||
#[test]
|
||||
fn test_server_error_display() {
|
||||
let error = ServerError::bind("127.0.0.1:8080", std::io::Error::new(
|
||||
std::io::ErrorKind::AddrInUse,
|
||||
"Address already in use"
|
||||
));
|
||||
|
||||
let display = format!("{}", error);
|
||||
assert!(display.contains("Failed to bind"));
|
||||
assert!(display.contains("127.0.0.1:8080"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_server_error_validation() {
|
||||
let error = ServerError::validation("field", "must not be empty");
|
||||
|
||||
let display = format!("{}", error);
|
||||
assert!(display.contains("Validation failed"));
|
||||
assert!(display.contains("field"));
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Constants Tests
|
||||
// ============================================================================
|
||||
|
||||
#[test]
|
||||
fn test_constants_values() {
|
||||
use servme::constants::*;
|
||||
|
||||
assert_eq!(DEFAULT_HOST, "127.0.0.1");
|
||||
assert_eq!(DEFAULT_PORT, 8080);
|
||||
assert_eq!(JWT_COOKIE_NAME, "access_token");
|
||||
assert_eq!(BEARER_PREFIX, "Bearer ");
|
||||
assert!(FILE_EXTENSIONS.contains(&".json"));
|
||||
assert!(FILE_EXTENSIONS.contains(&".html"));
|
||||
}
|
||||
Reference in New Issue
Block a user