#[cfg(test)]
mod integration_tests {
use crate::api::config::ConfigSearchRequest;
use crate::api::naming::{Instance, InstanceRequest, Service};
use crate::{BatataClientBuilder, ClientConfig, Credentials, TlsConfig};
#[test]
fn test_client_builder_with_auth() {
let config = BatataClientBuilder::new()
.server_addr("localhost:8848")
.username_password("nacos", "nacos")
.namespace("public");
assert!(config.config.credentials.has_basic_auth());
assert!(!config.config.credentials.has_ak_sk_auth());
}
#[test]
fn test_client_builder_with_ak_sk() {
let config = BatataClientBuilder::new()
.server_addr("localhost:8848")
.access_key("ak123", "sk456")
.namespace("public");
assert!(!config.config.credentials.has_basic_auth());
assert!(config.config.credentials.has_ak_sk_auth());
}
#[test]
fn test_client_builder_with_tls() {
let config = BatataClientBuilder::new()
.server_addr("localhost:8848")
.tls(true);
assert!(config.config.tls.enabled);
}
#[test]
fn test_client_builder_with_tls_config() {
let tls_config = TlsConfig::new()
.with_ca_cert("/path/to/ca.pem")
.with_client_cert("/path/to/cert.pem", "/path/to/key.pem")
.with_skip_verify(false);
let config = BatataClientBuilder::new()
.server_addr("localhost:8848")
.tls_config(tls_config);
assert!(config.config.tls.enabled);
assert_eq!(
config.config.tls.ca_cert_path,
Some("/path/to/ca.pem".to_string())
);
assert_eq!(
config.config.tls.client_cert_path,
Some("/path/to/cert.pem".to_string())
);
assert_eq!(
config.config.tls.client_key_path,
Some("/path/to/key.pem".to_string())
);
}
#[test]
fn test_client_builder_with_cache_dir() {
let config = BatataClientBuilder::new()
.server_addr("localhost:8848")
.cache_dir("/tmp/nacos-cache");
assert_eq!(
config.config.cache.cache_dir,
Some("/tmp/nacos-cache".to_string())
);
}
#[test]
fn test_config_search_request() {
let request = ConfigSearchRequest::new("public")
.with_data_id("test*")
.with_group("DEFAULT_GROUP")
.with_page(1, 10)
.with_search_type("blur");
assert_eq!(request.config_request.tenant, "public");
assert_eq!(request.config_request.data_id, "test*");
assert_eq!(request.config_request.group, "DEFAULT_GROUP");
assert_eq!(request.page_no, 1);
assert_eq!(request.page_size, 10);
assert_eq!(request.search, "blur");
}
#[test]
fn test_instance_update_request() {
let instance = Instance::new("127.0.0.1", 8080)
.with_weight(2.0)
.with_enabled(false)
.with_metadata("key", "value");
let request = InstanceRequest::update("public", "test-service", "DEFAULT_GROUP", instance);
assert_eq!(request.r#type, "updateInstance");
assert_eq!(request.naming_request.namespace, "public");
assert_eq!(request.naming_request.service_name, "test-service");
assert_eq!(request.instance.weight, 2.0);
assert!(!request.instance.enabled);
}
#[test]
fn test_instance_with_all_options() {
let instance = Instance::new("192.168.1.100", 9090)
.with_weight(1.5)
.with_cluster("cluster1")
.with_metadata("version", "1.0.0")
.with_metadata("region", "us-west")
.with_ephemeral(false)
.with_enabled(true);
assert_eq!(instance.ip, "192.168.1.100");
assert_eq!(instance.port, 9090);
assert_eq!(instance.weight, 1.5);
assert_eq!(instance.cluster_name, "cluster1");
assert!(!instance.ephemeral);
assert!(instance.enabled);
assert_eq!(instance.metadata.get("version"), Some(&"1.0.0".to_string()));
assert_eq!(instance.metadata.get("region"), Some(&"us-west".to_string()));
}
#[test]
fn test_service_healthy_instances() {
let mut service = Service::new("test-service", "DEFAULT_GROUP");
let healthy_instance = Instance::new("127.0.0.1", 8080);
let mut unhealthy_instance = Instance::new("127.0.0.2", 8080);
unhealthy_instance.healthy = false;
let mut disabled_instance = Instance::new("127.0.0.3", 8080);
disabled_instance.enabled = false;
service.hosts = vec![healthy_instance, unhealthy_instance, disabled_instance];
let healthy = service.healthy_instances();
assert_eq!(healthy.len(), 1);
assert_eq!(healthy[0].ip, "127.0.0.1");
}
#[test]
fn test_credentials_empty() {
let creds = Credentials::new();
assert!(!creds.is_configured());
assert!(!creds.has_basic_auth());
assert!(!creds.has_ak_sk_auth());
}
#[test]
fn test_tls_config_defaults() {
let tls = TlsConfig::default();
assert!(!tls.enabled);
assert!(tls.ca_cert_path.is_none());
assert!(tls.client_cert_path.is_none());
assert!(tls.client_key_path.is_none());
assert!(!tls.skip_verify);
}
#[test]
fn test_client_config_defaults() {
let config = ClientConfig::default();
assert_eq!(config.server_addrs, vec!["localhost:8848".to_string()]);
assert_eq!(config.namespace, "public");
assert_eq!(config.timeout_ms, 3000);
assert_eq!(config.retry_times, 3);
assert!(!config.credentials.is_configured());
assert!(!config.tls.enabled);
assert!(config.cache.cache_dir.is_none());
}
}