use base64::Engine;
use std::sync::Arc;
use aria2_core::error::Aria2Error;
use crate::engine::RpcEngine;
pub use super::types::{
DownloadStatus, FileInfo, GlobalOptions, GlobalStat, PeerInfo, ServerInfo, ServerInfoIndex,
SessionInfo, StatusInfo, TaskOptions, UriEntry, UriInfo, UriStatus, VersionInfo, create_gid,
};
#[derive(Debug, Clone, Default)]
pub struct AuthConfig {
pub token: Option<String>,
pub username: Option<String>,
pub password: Option<String>,
}
impl AuthConfig {
pub fn with_token(mut self, token: impl Into<String>) -> Self {
self.token = Some(token.into());
self
}
pub fn with_basic_auth(mut self, user: impl Into<String>, pass: impl Into<String>) -> Self {
self.username = Some(user.into());
self.password = Some(pass.into());
self
}
pub fn has_token(&self) -> bool {
self.token.is_some()
}
pub fn has_basic(&self) -> bool {
self.username.is_some() && self.password.is_some()
}
pub fn verify_token(&self, provided: &str) -> bool {
match &self.token {
None => true,
Some(t) => t == provided,
}
}
pub fn verify_basic(&self, encoded: &str) -> bool {
let decoded = base64_decode(encoded).unwrap_or_default();
if let Some(colon_pos) = decoded.find(':') {
let (user, pass) = decoded.split_at(colon_pos);
let pass = &pass[1..];
match (&self.username, &self.password) {
(Some(u), Some(p)) => u == user && p == pass,
_ => false,
}
} else {
false
}
}
}
fn base64_decode(s: &str) -> Result<String, Aria2Error> {
let bytes = base64::engine::general_purpose::STANDARD
.decode(s)
.map_err(Aria2Error::from)?;
String::from_utf8(bytes).map_err(Aria2Error::from)
}
use crate::json_rpc::JsonRpcError;
pub struct RpcAuthMiddleware {
secret: String,
}
impl RpcAuthMiddleware {
pub fn new(secret: &str) -> Self {
Self {
secret: secret.to_string(),
}
}
pub fn validate(&self, token: Option<&str>) -> Result<(), JsonRpcError> {
if self.secret.is_empty() {
return Ok(());
}
match token {
Some(t) if t == self.secret => Ok(()),
Some(_) => Err(JsonRpcError::Unauthorized("Invalid token".to_string())),
None => Err(JsonRpcError::Unauthorized(
"Token required (set rpc-secret)".to_string(),
)),
}
}
pub fn is_auth_enabled(&self) -> bool {
!self.secret.is_empty()
}
#[allow(dead_code)] pub fn secret(&self) -> &str {
&self.secret
}
}
impl Default for RpcAuthMiddleware {
fn default() -> Self {
Self::new("")
}
}
#[derive(Debug, Clone)]
pub struct CorsConfig {
pub allow_origin: String,
pub allow_methods: String,
pub allow_headers: String,
pub allow_credentials: bool,
allowed_origins: Vec<String>,
}
impl Default for CorsConfig {
fn default() -> Self {
Self::with_allowed_origins(vec![crate::constants::CORS_DEFAULT_ORIGIN.to_string()])
}
}
impl CorsConfig {
pub fn with_allowed_origins(origins: Vec<String>) -> Self {
let allow_origin = if origins.len() == 1 && origins[0] == "*" {
"*".to_string()
} else {
origins.join(", ")
};
Self {
allow_origin: allow_origin.clone(),
allow_methods: aria2_core::constants::CORS_ALLOW_METHODS.to_string(),
allow_headers: aria2_core::constants::CORS_ALLOW_HEADERS.to_string(),
allow_credentials: false,
allowed_origins: origins,
}
}
pub fn from_option_value(value: &str) -> Self {
let trimmed = value.trim();
if trimmed.is_empty() || trimmed == crate::constants::CORS_DEFAULT_ORIGIN {
return Self::default();
}
let origins: Vec<String> = if trimmed == crate::constants::CORS_DEFAULT_ORIGIN {
vec![crate::constants::CORS_DEFAULT_ORIGIN.to_string()]
} else {
trimmed
.split(',')
.map(|s| s.trim().to_string())
.filter(|s| !s.is_empty())
.collect()
};
Self::with_allowed_origins(origins)
}
pub fn with_origin(mut self, origin: impl Into<String>) -> Self {
self.allow_origin = origin.into();
self
}
pub fn with_credentials(mut self) -> Self {
self.allow_credentials = true;
self
}
pub fn allows_origin(&self, origin: Option<&str>) -> bool {
if self
.allowed_origins
.iter()
.any(|s| s == crate::constants::CORS_DEFAULT_ORIGIN)
{
return true;
}
match origin {
Some(o) => self.allowed_origins.iter().any(|allowed| allowed == o),
None => true, }
}
pub fn headers_for_origin(&self, origin: Option<&str>) -> Option<Vec<(&'static str, String)>> {
let origin_str = match origin {
Some(o) if self.allows_origin(Some(o)) => o.to_string(),
None if self.allows_origin(None) => {
if self
.allowed_origins
.iter()
.any(|s| s == crate::constants::CORS_DEFAULT_ORIGIN)
{
crate::constants::CORS_DEFAULT_ORIGIN.to_string()
} else {
return Some(vec![]); }
}
_ => return None, };
Some(vec![
("Access-Control-Allow-Origin", origin_str),
("Access-Control-Allow-Methods", self.allow_methods.clone()),
("Access-Control-Allow-Headers", self.allow_headers.clone()),
(
"Access-Control-Max-Age",
aria2_core::constants::CORS_MAX_AGE.to_string(),
),
])
}
pub fn to_headers(&self) -> Vec<(&str, &str)> {
vec![
("Access-Control-Allow-Origin", &self.allow_origin),
("Access-Control-Allow-Methods", &self.allow_methods),
("Access-Control-Allow-Headers", &self.allow_headers),
(
"Access-Control-Max-Age",
aria2_core::constants::CORS_MAX_AGE,
),
]
}
pub fn handle_preflight(&self, origin: Option<&str>) -> bool {
self.allows_origin(origin)
}
}
#[derive(Debug, Clone)]
pub struct TlsConfig {
pub cert_path: String,
pub key_path: String,
}
impl TlsConfig {
pub fn new(cert_path: impl Into<String>, key_path: impl Into<String>) -> Self {
Self {
cert_path: cert_path.into(),
key_path: key_path.into(),
}
}
pub fn load_server_config(&self) -> Result<Arc<rustls::ServerConfig>, TlsError> {
use rustls_pemfile::{certs, private_key};
use std::io::BufReader;
let cert_file = std::fs::File::open(&self.cert_path)
.map_err(|e| TlsError::CertificateRead(self.cert_path.clone(), e))?;
let mut cert_reader = BufReader::new(cert_file);
let cert_chain: Vec<rustls::pki_types::CertificateDer> = certs(&mut cert_reader)
.collect::<Result<Vec<_>, _>>()
.map_err(TlsError::CertificateParse)?;
if cert_chain.is_empty() {
return Err(TlsError::NoCertificates);
}
let key_file = std::fs::File::open(&self.key_path)
.map_err(|e| TlsError::KeyRead(self.key_path.clone(), e))?;
let mut key_reader = BufReader::new(key_file);
let key = private_key(&mut key_reader)
.map_err(TlsError::KeyParse)?
.ok_or(TlsError::NoPrivateKey)?;
let config = rustls::ServerConfig::builder()
.with_no_client_auth()
.with_single_cert(cert_chain, key)
.map_err(TlsError::InvalidConfig)?;
Ok(Arc::new(config))
}
}
#[derive(Debug, thiserror::Error)]
pub enum TlsError {
#[error("Failed to read certificate file '{0}': {1}")]
CertificateRead(String, std::io::Error),
#[error("Failed to parse certificates: {0}")]
CertificateParse(std::io::Error),
#[error("No certificates found in certificate file")]
NoCertificates,
#[error("Failed to read private key file '{0}': {1}")]
KeyRead(String, std::io::Error),
#[error("Failed to parse private key: {0}")]
KeyParse(std::io::Error),
#[error("No private key found in key file")]
NoPrivateKey,
#[error("Invalid TLS configuration: {0}")]
InvalidConfig(rustls::Error),
}
#[derive(Debug, Clone)]
pub struct ServerConfig {
pub host: String,
pub port: u16,
pub auth: AuthConfig,
pub cors: CorsConfig,
pub tls: Option<TlsConfig>,
}
impl Default for ServerConfig {
fn default() -> Self {
Self {
host: "127.0.0.1".to_string(),
port: 6800,
auth: AuthConfig::default(),
cors: CorsConfig::default(),
tls: None,
}
}
}
impl ServerConfig {
pub fn with_port(mut self, port: u16) -> Self {
self.port = port;
self
}
pub fn with_host(mut self, host: impl Into<String>) -> Self {
self.host = host.into();
self
}
pub fn with_auth(mut self, auth: AuthConfig) -> Self {
self.auth = auth;
self
}
pub fn with_cors(mut self, cors: CorsConfig) -> Self {
self.cors = cors;
self
}
pub fn with_tls(mut self, tls: TlsConfig) -> Self {
self.tls = Some(tls);
self
}
pub fn addr(&self) -> String {
format!("{}:{}", self.host, self.port)
}
pub fn is_secure(&self) -> bool {
self.tls.is_some()
}
pub fn scheme(&self) -> &'static str {
if self.is_secure() { "https" } else { "http" }
}
}
pub struct RpcServer {
config: ServerConfig,
tls_acceptor: Option<tokio_rustls::TlsAcceptor>,
engine: Arc<RpcEngine>,
}
impl RpcServer {
pub fn new(config: ServerConfig) -> Result<Self, TlsError> {
let tls_acceptor = if let Some(ref tls_config) = config.tls {
let server_config = tls_config.load_server_config()?;
Some(tokio_rustls::TlsAcceptor::from(server_config))
} else {
None
};
Ok(Self {
config,
tls_acceptor,
engine: Arc::new(RpcEngine::new()),
})
}
pub fn new_with_engine(config: ServerConfig, engine: Arc<RpcEngine>) -> Result<Self, TlsError> {
let tls_acceptor = if let Some(ref tls_config) = config.tls {
let server_config = tls_config.load_server_config()?;
Some(tokio_rustls::TlsAcceptor::from(server_config))
} else {
None
};
Ok(Self {
config,
tls_acceptor,
engine,
})
}
pub fn new_http(host: impl Into<String>, port: u16) -> Self {
Self {
config: ServerConfig::default().with_host(host).with_port(port),
tls_acceptor: None,
engine: Arc::new(RpcEngine::new()),
}
}
pub fn new_https(
host: impl Into<String>,
port: u16,
cert_path: impl Into<String>,
key_path: impl Into<String>,
) -> Result<Self, TlsError> {
let tls_config = TlsConfig::new(cert_path, key_path);
let server_config = tls_config.load_server_config()?;
let tls_acceptor = tokio_rustls::TlsAcceptor::from(server_config);
Ok(Self {
config: ServerConfig::default()
.with_host(host)
.with_port(port)
.with_tls(tls_config),
tls_acceptor: Some(tls_acceptor),
engine: Arc::new(RpcEngine::new()),
})
}
pub fn addr(&self) -> String {
self.config.addr()
}
pub fn port(&self) -> u16 {
self.config.port
}
pub fn is_secure(&self) -> bool {
self.tls_acceptor.is_some()
}
pub fn scheme(&self) -> &'static str {
self.config.scheme()
}
pub fn rpc_url(&self) -> String {
format!(
"{}://{}{}",
self.scheme(),
self.addr(),
crate::constants::RPC_ENDPOINT_PATH
)
}
pub fn config(&self) -> &ServerConfig {
&self.config
}
pub fn tls_acceptor(&self) -> Option<&tokio_rustls::TlsAcceptor> {
self.tls_acceptor.as_ref()
}
pub async fn serve(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
use axum::{
Router,
http::{Method, header},
routing::{get, post},
};
use std::net::SocketAddr;
use tokio::net::TcpListener;
use tower_http::cors::{Any, CorsLayer};
let state = RpcState {
engine: self.engine.clone(),
};
let cors_layer = CorsLayer::new()
.allow_origin(Any)
.allow_methods([Method::GET, Method::POST, Method::OPTIONS])
.allow_headers([header::CONTENT_TYPE, header::AUTHORIZATION]);
let app = Router::new()
.route("/jsonrpc", post(handle_jsonrpc))
.route("/jsonrpc", get(handle_jsonrpc_get)) .route("/", get(root_handler))
.layer(cors_layer)
.with_state(state);
let addr: SocketAddr = self.addr().parse()?;
tracing::info!("RPC server listening on {}://{}", self.scheme(), addr);
let listener = TcpListener::bind(addr).await?;
if let Some(ref _tls_acceptor) = self.tls_acceptor {
tracing::info!("TLS enabled, serving HTTPS");
axum::serve(
listener,
app.into_make_service_with_connect_info::<SocketAddr>(),
)
.await?;
} else {
axum::serve(
listener,
app.into_make_service_with_connect_info::<SocketAddr>(),
)
.await?;
}
Ok(())
}
}
#[derive(Clone)]
struct RpcState {
engine: Arc<RpcEngine>,
}
async fn root_handler() -> impl axum::response::IntoResponse {
use axum::http::StatusCode;
use axum::response::Json;
use serde_json::json;
(
StatusCode::OK,
Json(json!({
"name": crate::constants::RPC_SERVER_NAME,
"version": env!("CARGO_PKG_VERSION"),
"endpoints": {
"jsonrpc": crate::constants::RPC_ENDPOINT_PATH
}
})),
)
}
async fn handle_jsonrpc(
axum::extract::State(state): axum::extract::State<RpcState>,
axum::Json(req): axum::Json<crate::json_rpc::JsonRpcRequest>,
) -> impl axum::response::IntoResponse {
use axum::http::StatusCode;
use axum::response::Json;
let response = state.engine.handle_request(&req).await;
(StatusCode::OK, Json(response))
}
async fn handle_jsonrpc_get() -> impl axum::response::IntoResponse {
use axum::http::StatusCode;
use axum::response::Json;
use serde_json::json;
(
StatusCode::OK,
Json(json!({
"error": "GET method not supported. Use POST for JSON-RPC requests."
})),
)
}
impl std::fmt::Debug for RpcServer {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("RpcServer")
.field("addr", &self.addr())
.field("secure", &self.is_secure())
.field("config", &self.config)
.finish()
}
}
#[cfg(test)]
pub fn generate_test_cert() -> (String, String) {
let cert = r#"-----BEGIN CERTIFICATE-----
MIIBkTCB+wIJAKHHCgVZwjBUMA0GCSqGSIb3DQEBCwUAMBExDzANBgNVBAMMBnRl
c3RDQTAeFw0yNDAxMDEwMDAwMDBaFw0yNTAxMDEwMDAwMDBaMBExDzANBgNVBAMM
BnRlc3RDQTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAyZ7vN5eQ3J9K8mN
pL2Q4R5T6V7W8X9Y0Z1a2b3c4d5e6f7g8h9i0j1k2l3m4n5o6p7q8r9s0t1u2v3
w4x5y6z7a8b9c0d1e2f3g4h5i6j7k8l9m0n1o2p3q4r5s6t7u8v9w0x1y2z3a4b
5c6d7e8f9g0h1i2j3k4l5m6n7o8p9q0r1s2t3u4v5w6x7y8z9CAwEAAaMgMB4w
DQYJKoZIhvcNAQELBQADgYEAB9c8Z7Q6R5T4S3P2O1N0M9L8K7J6I5H4G3F2E1D
0C9B8A7z6y5x4w3v2u1t0s9r8q7p6o5n4m3l2k1j0i9h8g7f6e5d4c3b2a1z0y9
x8w7v6u5t4s3r2q1p0o9n8m7l6k5j4i3h2g1f0e9d8c7b6a5z4y3x2w1v0u9t8
s7r6q5p4o3n2m1l0k9j8i7h6g5f4e3d2c1b0a9z8y7x6w5v4u3t2s1r0q9p8o7
n6m5l4k3j2i1h0g9f8e7d6c5b4a3z2y1x0w9v8u7t6s5r4q3p2o1n0m9l8k7j6
i5h4g3f2e1d0c9b8a7z6y5x4w3v2u1t0s9r8q7p6o5n4m3l2k1j0i=
-----END CERTIFICATE-----
"#;
let key = r#"-----BEGIN PRIVATE KEY-----
MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAMme7zeXkNyfSvJj
aS9kOEeU+le1vF/WNGdWtm93OHXu4f7h9i0j1k2l3m4n5o6p7q8r9s0t1u2v3w4x
5y6z7a8b9c0d1e2f3g4h5i6j7k8l9m0n1o2p3q4r5s6t7u8v9w0x1y2z3a4b5c6d
7e8f9g0h1i2j3k4l5m6n7o8p9q0r1s2t3u4v5w6x7y8z9AgMBAAECgYEAyZ7vN5
eQ3J9K8mNpL2Q4R5T6V7W8X9Y0Z1a2b3c4d5e6f7g8h9i0j1k2l3m4n5o6p7q8r
9s0t1u2v3w4x5y6z7a8b9c0d1e2f3g4h5i6j7k8l9m0n1o2p3q4r5s6t7u8v9w0
x1y2z3a4b5c6d7e8f9g0h1i2j3k4l5m6n7o8p9q0r1s2t3u4v5w6x7y8z9ECgYE
AMme7zeXkNyfSvJjaS9kOEeU+le1vF/WNGdWtm93OHXu4f7h9i0j1k2l3m4n5o6
p7q8r9s0t1u2v3w4x5y6z7a8b9c0d1e2f3g4h5i6j7k8l9m0n1o2p3q4r5s6t7u
8v9w0x1y2z3a4b5c6d7e8f9g0h1i2j3k4l5m6n7o8p9q0r1s2t3u4v5w6x7y8z9
ECgYEAMme7zeXkNyfSvJjaS9kOEeU+le1vF/WNGdWtm93OHXu4f7h9i0j1k2l3m
4n5o6p7q8r9s0t1u2v3w4x5y6z7a8b9c0d1e2f3g4h5i6j7k8l9m0n1o2p3q4r5
s6t7u8v9w0x1y2z3a4b5c6d7e8f9g0h1i2j3k4l5m6n7o8p9q0r1s2t3u4v5w6x
7y8z9ECgYEAMme7zeXkNyfSvJjaS9kOEeU+le1vF/WNGdWtm93OHXu4f7h9i0j1
k2l3m4n5o6p7q8r9s0t1u2v3w4x5y6z7a8b9c0d1e2f3g4h5i6j7k8l9m0n1o2p
3q4r5s6t7u8v9w0x1y2z3a4b5c6d7e8f9g0h1i2j3k4l5m6n7o8p9q0r1s2t3u4
v5w6x7y8z9ECgYEAMme7zeXkNyfSvJjaS9kOEeU+le1vF/WNGdWtm93OHXu4f7h
9i0j1k2l3m4n5o6p7q8r9s0t1u2v3w4x5y6z7a8b9c0d1e2f3g4h5i6j7k8l9m0
n1o2p3q4r5s6t7u8v9w0x1y2z3a4b5c6d7e8f9g0h1i2j3k4l5m6n7o8p9q0r1s
2t3u4v5w6x7y8z9=
-----END PRIVATE KEY-----
"#;
(cert.to_string(), key.to_string())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_auth_config_default() {
let auth = AuthConfig::default();
assert!(!auth.has_token());
assert!(!auth.has_basic());
assert!(auth.verify_token(""));
}
#[test]
fn test_auth_config_token() {
let auth = AuthConfig::default().with_token("my-secret");
assert!(auth.has_token());
assert!(auth.verify_token("my-secret"));
assert!(!auth.verify_token("wrong"));
}
#[test]
fn test_auth_config_basic() {
let auth = AuthConfig::default().with_basic_auth("admin", "pass123");
assert!(auth.has_basic());
let encoded = base64::engine::general_purpose::STANDARD.encode(b"admin:pass123");
assert!(auth.verify_basic(&encoded));
assert!(
!auth.verify_basic(
base64::engine::general_purpose::STANDARD
.encode(b"admin:wrong")
.as_str()
)
);
}
#[test]
fn test_cors_config_default() {
let cors = CorsConfig::default();
let headers = cors.to_headers();
assert!(
headers
.iter()
.any(|(k, _)| k == &"Access-Control-Allow-Origin")
);
}
#[test]
fn test_server_config_default() {
let cfg = ServerConfig::default();
assert_eq!(cfg.port, 6800);
assert_eq!(cfg.addr(), "127.0.0.1:6800");
}
#[test]
fn test_server_config_builder() {
let cfg = ServerConfig::default()
.with_port(8080)
.with_host("0.0.0.0")
.with_auth(AuthConfig::default().with_token("tok"));
assert_eq!(cfg.port, 8080);
assert!(cfg.auth.has_token());
}
#[test]
fn test_auth_valid_token_passes() {
let middleware = RpcAuthMiddleware::new("my-secret-token");
assert!(middleware.validate(Some("my-secret-token")).is_ok());
}
#[test]
fn test_auth_wrong_token_rejected() {
let middleware = RpcAuthMiddleware::new("my-secret-token");
let result = middleware.validate(Some("wrong-token"));
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.code(), -32001);
assert!(err.to_string().contains("Invalid token"));
}
#[test]
fn test_auth_no_secret_configured_accepts_all() {
let middleware = RpcAuthMiddleware::new(""); assert!(middleware.validate(None).is_ok());
assert!(middleware.validate(Some("anything")).is_ok());
assert!(middleware.validate(Some("")).is_ok());
assert!(
!middleware.is_auth_enabled(),
"Auth should be disabled with empty secret"
);
}
#[test]
fn test_auth_token_required_when_secret_set() {
let middleware = RpcAuthMiddleware::new("secret123");
let result = middleware.validate(None);
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.code(), -32001);
assert!(err.to_string().contains("Token required"));
assert!(
middleware.is_auth_enabled(),
"Auth should be enabled with non-empty secret"
);
}
#[test]
fn test_auth_middleware_default() {
let middleware = RpcAuthMiddleware::default();
assert!(!middleware.is_auth_enabled());
assert!(middleware.validate(None).is_ok());
assert!(middleware.validate(Some("x")).is_ok());
}
#[test]
fn test_auth_middleware_secret_accessor() {
let middleware = RpcAuthMiddleware::new("test-secret");
assert_eq!(middleware.secret(), "test-secret");
}
#[test]
fn test_cors_wildcard_allows_any_origin() {
let cors = CorsConfig::default();
assert!(cors.allows_origin(Some("http://localhost:8080")));
assert!(cors.allows_origin(Some("https://example.com")));
assert!(cors.allows_origin(Some("http://192.168.1.1:3000")));
assert!(cors.allows_origin(None)); }
#[test]
fn test_cors_specific_domain_blocks_others() {
let cors = CorsConfig::from_option_value("http://localhost:8080,https://example.com");
assert!(
cors.allows_origin(Some("http://localhost:8080")),
"Should allow exact match for localhost"
);
assert!(
cors.allows_origin(Some("https://example.com")),
"Should allow exact match for example.com"
);
assert!(
!cors.allows_origin(Some("http://evil.com")),
"Should block non-listed origin"
);
assert!(
!cors.allows_origin(Some("http://localhost:8081")),
"Should block different port"
);
assert!(
!cors.allows_origin(Some("http://localhost:8080/extra")),
"Should block origin with path (strict matching)"
);
assert!(
cors.allows_origin(None),
"No origin header should be allowed"
);
}
#[test]
fn test_cors_preflight_returns_true_for_allowed() {
let cors = CorsConfig::from_option_value("http://localhost:8080");
assert!(cors.handle_preflight(Some("http://localhost:8080")));
assert!(!cors.handle_preflight(Some("http://evil.com")));
assert!(cors.handle_preflight(None));
}
#[test]
fn test_cors_from_option_value_parsing() {
let cors_wildcard = CorsConfig::from_option_value("*");
assert!(cors_wildcard.allows_origin(Some("anything")));
assert_eq!(cors_wildcard.allow_origin, "*");
let cors_empty = CorsConfig::from_option_value("");
assert!(cors_empty.allows_origin(Some("anything")));
let cors_multi =
CorsConfig::from_option_value("http://a.com, https://b.com, http://c.com:9090");
assert!(cors_multi.allows_origin(Some("http://a.com")));
assert!(cors_multi.allows_origin(Some("https://b.com")));
assert!(cors_multi.allows_origin(Some("http://c.com:9090")));
assert!(!cors_multi.allows_origin(Some("http://d.com")));
let cors_spaces = CorsConfig::from_option_value(" http://a.com , https://b.com ");
assert!(cors_spaces.allows_origin(Some("http://a.com")));
assert!(cors_spaces.allows_origin(Some("https://b.com")));
}
#[test]
fn test_cors_headers_for_origin() {
let cors = CorsConfig::from_option_value("http://localhost:8080");
let headers = cors.headers_for_origin(Some("http://localhost:8080"));
assert!(
headers.is_some(),
"Should return headers for allowed origin"
);
let headers = headers.unwrap();
assert!(
headers
.iter()
.any(|(k, _)| *k == "Access-Control-Allow-Origin"),
"Should contain Allow-Origin header"
);
let blocked = cors.headers_for_origin(Some("http://evil.com"));
assert!(blocked.is_none(), "Should return None for blocked origin");
}
#[test]
fn test_cors_with_allowed_origins_constructor() {
let cors = CorsConfig::with_allowed_origins(vec![
"https://api.example.com".to_string(),
"http://localhost:3000".to_string(),
]);
assert!(cors.allows_origin(Some("https://api.example.com")));
assert!(cors.allows_origin(Some("http://localhost:3000")));
assert!(!cors.allows_origin(Some("http://other.com")));
}
#[test]
fn test_tls_config_new() {
let tls = TlsConfig::new("/path/to/cert.pem", "/path/to/key.pem");
assert_eq!(tls.cert_path, "/path/to/cert.pem");
assert_eq!(tls.key_path, "/path/to/key.pem");
}
#[test]
fn test_tls_error_display() {
let err = TlsError::NoCertificates;
assert!(err.to_string().contains("No certificates"));
let err = TlsError::NoPrivateKey;
assert!(err.to_string().contains("No private key"));
}
#[test]
fn test_server_config_with_tls() {
let tls = TlsConfig::new("/cert.pem", "/key.pem");
let config = ServerConfig::default().with_port(8443).with_tls(tls);
assert!(config.is_secure());
assert_eq!(config.scheme(), "https");
assert!(config.tls.is_some());
}
#[test]
fn test_server_config_without_tls() {
let config = ServerConfig::default();
assert!(!config.is_secure());
assert_eq!(config.scheme(), "http");
assert!(config.tls.is_none());
}
#[test]
fn test_rpc_server_new_http() {
let server = RpcServer::new_http("127.0.0.1", 6800);
assert_eq!(server.addr(), "127.0.0.1:6800");
assert_eq!(server.port(), 6800);
assert!(!server.is_secure());
assert_eq!(server.scheme(), "http");
assert_eq!(server.rpc_url(), "http://127.0.0.1:6800/jsonrpc");
}
#[test]
fn test_rpc_server_from_config() {
let config = ServerConfig::default().with_host("0.0.0.0").with_port(8080);
let server = RpcServer::new(config).expect("Failed to create server");
assert_eq!(server.addr(), "0.0.0.0:8080");
assert!(!server.is_secure());
}
#[test]
fn test_rpc_server_debug_format() {
let server = RpcServer::new_http("localhost", 6800);
let debug_str = format!("{:?}", server);
assert!(debug_str.contains("RpcServer"));
assert!(debug_str.contains("localhost:6800"));
assert!(debug_str.contains("secure: false"));
}
#[test]
fn test_rpc_server_config_accessor() {
let config = ServerConfig::default()
.with_host("192.168.1.1")
.with_port(9999);
let server = RpcServer::new(config).expect("Failed to create server");
let cfg = server.config();
assert_eq!(cfg.host, "192.168.1.1");
assert_eq!(cfg.port, 9999);
}
#[test]
fn test_rpc_server_tls_acceptor_none_for_http() {
let server = RpcServer::new_http("127.0.0.1", 6800);
assert!(server.tls_acceptor().is_none());
}
#[test]
fn test_generate_test_cert() {
let (cert, key) = generate_test_cert();
assert!(cert.contains("BEGIN CERTIFICATE"));
assert!(cert.contains("END CERTIFICATE"));
assert!(key.contains("BEGIN PRIVATE KEY"));
assert!(key.contains("END PRIVATE KEY"));
}
}