use crate::config::SearchSettings;
use crate::domain::services::searxng::{ReqwestSearxngTransport, SearxngInstanceService};
use crate::engines::engine_client::EngineClient;
use std::sync::Arc;
use std::time::Duration;
use super::{
engine_trait::{SearchEngine, SearchRequest},
error::SearchError,
response::{Response, ResponseItem},
types::SearchEngineType,
};
pub mod baidu;
pub mod bing;
pub mod exa;
pub mod html_parser;
pub mod searxng;
pub mod shared_utils;
pub mod sogou;
pub mod tavily;
pub use baidu::BaiduSearchEngine;
pub use bing::BingSearchEngine;
pub use exa::{ExaConfig, ExaSearchEngine};
pub use searxng::SearxngSearchEngine;
pub use shared_utils::{parse_first_selector, safe_parse_selector};
pub use sogou::SogouSearchEngine;
pub use tavily::{TavilyConfig, TavilySearchEngine};
#[async_trait::async_trait]
pub trait SearchClientTrait: Send + Sync {
async fn search(&self, query: &str) -> SearchCommand;
async fn search_with_engine(
&self,
query: &str,
engine: SearchEngineType,
) -> Result<Response<ResponseItem>, SearchError>;
fn default_engine(&self) -> SearchEngineType;
}
#[derive(Clone)]
struct SearchClientInner {
engines: Vec<Arc<dyn SearchEngine>>,
default_engine: SearchEngineType,
}
fn default_engine_type() -> SearchEngineType {
SearchEngineType::Bing
}
#[derive(Clone)]
pub struct SearchClient {
inner: Arc<SearchClientInner>,
}
impl SearchClient {
pub fn new(engine_client: Arc<EngineClient>) -> Self {
let mut inner = SearchClientInner {
engines: Vec::new(),
default_engine: default_engine_type(),
};
Self::register_default_engines(&mut inner, &engine_client);
SearchClient {
inner: Arc::new(inner),
}
}
fn register_default_engines(inner: &mut SearchClientInner, engine_client: &Arc<EngineClient>) {
inner
.engines
.push(Arc::new(BingSearchEngine::new(engine_client.clone())) as Arc<dyn SearchEngine>);
inner
.engines
.push(Arc::new(BaiduSearchEngine::new(engine_client.clone())) as Arc<dyn SearchEngine>);
inner
.engines
.push(Arc::new(SogouSearchEngine::new(engine_client.clone())) as Arc<dyn SearchEngine>);
}
pub fn with_configured_engines(
engine_client: Arc<EngineClient>,
http_client: Arc<reqwest::Client>,
settings: &SearchSettings,
searxng_instances: Option<Arc<dyn SearxngInstanceService>>,
) -> Self {
let mut inner = SearchClientInner {
engines: Vec::new(),
default_engine: default_engine_type(),
};
Self::register_builtin_engines(&mut inner, &engine_client, &settings.engines);
Self::register_exa_engine(&mut inner, &http_client, settings);
Self::register_tavily_engine(&mut inner, &http_client, settings);
Self::register_searxng_engine(&mut inner, &http_client, settings, searxng_instances);
inner.default_engine =
Self::resolve_default_engine(&inner.engines, settings.default_engine.as_deref());
SearchClient {
inner: Arc::new(inner),
}
}
fn register_exa_engine(
inner: &mut SearchClientInner,
http_client: &Arc<reqwest::Client>,
settings: &SearchSettings,
) {
match settings.exa.api_key().filter(|key| !key.trim().is_empty()) {
Some(api_key) => {
let mut config = ExaConfig {
api_key: api_key.to_string(),
..ExaConfig::default()
};
if let Some(base_url) = settings.exa.base_url().filter(|url| !url.trim().is_empty())
{
config.endpoint = base_url.to_string();
}
inner.engines.push(Arc::new(ExaSearchEngine::new(
http_client.as_ref().clone(),
config,
)) as Arc<dyn SearchEngine>);
log::info!("{}", crate::i18n::tr_log("search-exa-registered"));
}
None => log::info!("{}", crate::i18n::tr_log("search-exa-skipped")),
}
}
fn register_tavily_engine(
inner: &mut SearchClientInner,
http_client: &Arc<reqwest::Client>,
settings: &SearchSettings,
) {
match settings
.tavily
.api_key()
.filter(|key| !key.trim().is_empty())
{
Some(api_key) => {
let mut config = TavilyConfig {
api_key: api_key.to_string(),
..TavilyConfig::default()
};
if let Some(base_url) = settings
.tavily
.base_url()
.filter(|url| !url.trim().is_empty())
{
config.endpoint = base_url.to_string();
}
inner.engines.push(Arc::new(TavilySearchEngine::new(
http_client.as_ref().clone(),
config,
)) as Arc<dyn SearchEngine>);
log::info!("{}", crate::i18n::tr_log("search-tavily-registered"));
}
None => log::info!("{}", crate::i18n::tr_log("search-tavily-skipped")),
}
}
fn register_searxng_engine(
inner: &mut SearchClientInner,
http_client: &Arc<reqwest::Client>,
settings: &SearchSettings,
searxng_instances: Option<Arc<dyn SearxngInstanceService>>,
) {
match (settings.searxng.enabled, searxng_instances) {
(true, Some(service)) => {
let transport: Arc<dyn crate::domain::services::searxng::SearxngTransport> =
Arc::new(ReqwestSearxngTransport::new(
http_client.clone(),
settings.searxng.user_agent.clone(),
));
inner.engines.push(Arc::new(SearxngSearchEngine::new(
service,
transport,
Duration::from_secs(settings.timeout_seconds),
settings.searxng.max_failover_attempts,
)) as Arc<dyn SearchEngine>);
log::info!(
"SearXNG search engine registered (pool_target={})",
settings.searxng.pool_target
);
}
(true, None) => {
log::warn!(
"search.searxng.enabled=true but instance service is absent; \
SearXNG engine not registered"
);
}
(false, _) => {
log::info!("SearXNG search engine skipped (search.searxng.enabled=false)");
}
}
}
fn register_builtin_engines(
inner: &mut SearchClientInner,
engine_client: &Arc<EngineClient>,
switches: &crate::config::SearchEnginesSettings,
) {
type BuiltinEngineFactory = fn(&Arc<EngineClient>) -> Arc<dyn SearchEngine>;
let wanted: &[(&str, bool, BuiltinEngineFactory)] = &[
("bing", switches.bing_enabled, |c| {
Arc::new(BingSearchEngine::new(c.clone())) as Arc<dyn SearchEngine>
}),
("baidu", switches.baidu_enabled, |c| {
Arc::new(BaiduSearchEngine::new(c.clone())) as Arc<dyn SearchEngine>
}),
("sogou", switches.sogou_enabled, |c| {
Arc::new(SogouSearchEngine::new(c.clone())) as Arc<dyn SearchEngine>
}),
];
for (name, enabled, build) in wanted {
if *enabled {
inner.engines.push(build(engine_client));
} else {
log::info!(
"{}",
crate::i18n::tr_log_args(
"search-engine-disabled-by-config",
&[("engine", (*name).to_string())],
)
);
}
}
if inner.engines.is_empty() {
log::warn!(
"{}",
crate::i18n::tr_log("search-all-builtin-engines-disabled")
);
}
}
fn resolve_default_engine(
engines: &[Arc<dyn SearchEngine>],
configured: Option<&str>,
) -> SearchEngineType {
let Some(name) = configured.map(str::trim).filter(|s| !s.is_empty()) else {
return default_engine_type();
};
match SearchEngineType::from_name(name) {
Some(engine_type) if engines.iter().any(|e| e.engine_type() == engine_type) => {
engine_type
}
Some(_) => {
log::warn!(
"{}",
crate::i18n::tr_log_args(
"search-default-engine-not-registered",
&[("engine", name.to_string())],
)
);
default_engine_type()
}
None => {
log::warn!(
"{}",
crate::i18n::tr_log_args(
"search-default-engine-unknown",
&[("engine", name.to_string())],
)
);
default_engine_type()
}
}
}
pub fn register_engine(&mut self, engine: Arc<dyn SearchEngine>) {
Arc::make_mut(&mut self.inner).engines.push(engine);
}
pub fn new_with_engines(
engines: Vec<Arc<dyn SearchEngine>>,
default_engine: SearchEngineType,
) -> Self {
let inner = SearchClientInner {
engines,
default_engine,
};
SearchClient {
inner: Arc::new(inner),
}
}
pub fn search(&self, query: &str) -> SearchCommand {
SearchCommand::new(self.clone(), query)
}
pub async fn search_with_engine(
&self,
query: &str,
engine: SearchEngineType,
) -> Result<Response<ResponseItem>, SearchError> {
let request = SearchRequest::new(query).with_engine(engine);
let eng = self
.inner
.engines
.iter()
.find(|e| e.engine_type() == engine)
.ok_or_else(|| SearchError::NoEngineAvailable)?;
eng.search(&request).await
}
pub fn default_engine(&self) -> SearchEngineType {
self.inner.default_engine
}
}
#[async_trait::async_trait]
impl SearchClientTrait for SearchClient {
async fn search(&self, query: &str) -> SearchCommand {
SearchCommand::new(self.clone(), query)
}
async fn search_with_engine(
&self,
query: &str,
engine: SearchEngineType,
) -> Result<Response<ResponseItem>, SearchError> {
let request = SearchRequest::new(query).with_engine(engine);
let eng = self
.inner
.engines
.iter()
.find(|e| e.engine_type() == engine)
.ok_or_else(|| SearchError::NoEngineAvailable)?;
eng.search(&request).await
}
fn default_engine(&self) -> SearchEngineType {
self.inner.default_engine
}
}
#[must_use]
pub struct SearchCommand {
client: SearchClient,
query: String,
engine: Option<SearchEngineType>,
limit: u32,
offset: u32,
}
impl SearchCommand {
pub fn new(client: SearchClient, query: &str) -> Self {
Self {
client,
query: query.to_string(),
engine: None,
limit: 10,
offset: 0,
}
}
pub fn bing(mut self) -> Self {
self.engine = Some(SearchEngineType::Bing);
self
}
pub fn baidu(mut self) -> Self {
self.engine = Some(SearchEngineType::Baidu);
self
}
pub fn sogou(mut self) -> Self {
self.engine = Some(SearchEngineType::Sogou);
self
}
pub fn with_engine(mut self, engine: &str) -> Self {
self.engine = SearchEngineType::from_name(engine);
self
}
pub fn limit(mut self, n: u32) -> Self {
self.limit = n;
self
}
pub fn offset(mut self, n: u32) -> Self {
self.offset = n;
self
}
pub async fn execute(&self) -> Result<Response<ResponseItem>, SearchError> {
let engine = self.engine.unwrap_or(self.client.default_engine());
let request = SearchRequest {
query: self.query.clone(),
engine: Some(engine),
limit: self.limit,
offset: self.offset,
lang: None,
country: None,
};
let eng = self
.client
.inner
.engines
.iter()
.find(|e| e.engine_type() == engine)
.ok_or_else(|| SearchError::NoEngineAvailable)?;
eng.search(&request).await
}
}
#[cfg(test)]
mod tests {
use super::*;
fn create_test_search_client() -> SearchClient {
use crate::engines::engine_client::EngineClient;
let engine_client = Arc::new(EngineClient::new());
SearchClient::new(engine_client)
}
#[tokio::test]
async fn test_search_command_builder() {
let client = create_test_search_client();
let cmd = client.search("test query").bing().limit(5);
assert_eq!(cmd.query, "test query");
assert_eq!(cmd.engine, Some(SearchEngineType::Bing));
assert_eq!(cmd.limit, 5);
}
#[tokio::test]
async fn test_search_request_builder() {
let req = SearchRequest::new("hello")
.with_engine(SearchEngineType::Bing)
.with_limit(20)
.with_offset(10);
assert_eq!(req.query, "hello");
assert_eq!(req.engine, Some(SearchEngineType::Bing));
assert_eq!(req.limit, 20);
assert_eq!(req.offset, 10);
}
#[tokio::test]
async fn test_all_engines_registered() {
let client = create_test_search_client();
assert_eq!(client.inner.engines.len(), 3);
}
use crate::search::types::EngineHealth;
struct MockClientEngine {
name: &'static str,
engine_type: SearchEngineType,
items: Vec<ResponseItem>,
}
impl MockClientEngine {
fn new(
name: &'static str,
engine_type: SearchEngineType,
items: Vec<ResponseItem>,
) -> Self {
Self {
name,
engine_type,
items,
}
}
}
#[async_trait::async_trait]
impl SearchEngine for MockClientEngine {
fn name(&self) -> &'static str {
self.name
}
fn engine_type(&self) -> SearchEngineType {
self.engine_type
}
fn health(&self) -> EngineHealth {
EngineHealth::Healthy
}
async fn search(
&self,
_request: &SearchRequest,
) -> Result<Response<ResponseItem>, SearchError> {
Ok(Response {
items: self.items.clone(),
total_results: Some(self.items.len() as u64),
engine: self.engine_type,
})
}
}
fn make_mock_items(engine_type: SearchEngineType, count: usize) -> Vec<ResponseItem> {
(0..count)
.map(|i| ResponseItem {
title: format!("Result {}", i + 1),
url: format!("https://example.com/{}", i),
description: format!("Description {}", i + 1),
engine: engine_type,
})
.collect()
}
#[test]
fn test_new_with_engines_creates_client_with_custom_engines() {
let engines: Vec<Arc<dyn SearchEngine>> = vec![
Arc::new(MockClientEngine::new(
"bing",
SearchEngineType::Bing,
make_mock_items(SearchEngineType::Bing, 2),
)),
Arc::new(MockClientEngine::new(
"baidu",
SearchEngineType::Baidu,
make_mock_items(SearchEngineType::Baidu, 1),
)),
];
let client = SearchClient::new_with_engines(engines, SearchEngineType::Bing);
assert_eq!(client.inner.engines.len(), 2);
assert_eq!(client.default_engine(), SearchEngineType::Bing);
}
#[test]
fn test_new_with_engines_empty_engines() {
let client = SearchClient::new_with_engines(vec![], SearchEngineType::Bing);
assert_eq!(client.inner.engines.len(), 0);
assert_eq!(client.default_engine(), SearchEngineType::Bing);
}
#[test]
fn test_register_engine_adds_to_client() {
let engines: Vec<Arc<dyn SearchEngine>> = vec![Arc::new(MockClientEngine::new(
"bing",
SearchEngineType::Bing,
make_mock_items(SearchEngineType::Bing, 1),
))];
let mut client = SearchClient::new_with_engines(engines, SearchEngineType::Bing);
assert_eq!(client.inner.engines.len(), 1);
client.register_engine(Arc::new(MockClientEngine::new(
"bing",
SearchEngineType::Bing,
make_mock_items(SearchEngineType::Bing, 1),
)));
assert_eq!(client.inner.engines.len(), 2);
}
fn build_configured_client(settings: &SearchSettings) -> SearchClient {
build_configured_client_with_searxng(settings, None)
}
fn build_configured_client_with_searxng(
settings: &SearchSettings,
searxng: Option<Arc<dyn SearxngInstanceService>>,
) -> SearchClient {
let engine_client = Arc::new(EngineClient::new());
let http_client = Arc::new(reqwest::Client::new());
SearchClient::with_configured_engines(engine_client, http_client, settings, searxng)
}
fn test_searxng_service() -> Arc<dyn SearxngInstanceService> {
use crate::domain::services::searxng::test_support::{
shared_repo, test_settings, ScriptedTransport,
};
use crate::domain::services::searxng::SearxngInstanceServiceImpl;
Arc::new(SearxngInstanceServiceImpl::new(
shared_repo(),
Arc::new(ScriptedTransport::new(vec![])),
test_settings(),
))
}
fn registered_engine_types(client: &SearchClient) -> Vec<SearchEngineType> {
client
.inner
.engines
.iter()
.map(|e| e.engine_type())
.collect()
}
#[test]
fn test_with_configured_engines_without_api_keys_skips_exa_and_tavily() {
let client = build_configured_client(&SearchSettings::default());
let types = registered_engine_types(&client);
assert_eq!(
client.inner.engines.len(),
3,
"only bing/baidu/sogou should be registered without api keys"
);
assert!(
!types.contains(&SearchEngineType::Exa),
"exa should not be registered without api_key"
);
assert!(
!types.contains(&SearchEngineType::Tavily),
"tavily should not be registered without api_key"
);
}
#[test]
fn test_with_configured_engines_honors_engine_switches() {
let mut settings = SearchSettings::default();
settings.engines.baidu_enabled = false;
settings.engines.sogou_enabled = false;
let client = build_configured_client(&settings);
let types = registered_engine_types(&client);
assert_eq!(
client.inner.engines.len(),
1,
"only bing should be registered when baidu/sogou are disabled"
);
assert_eq!(types, vec![SearchEngineType::Bing]);
}
#[test]
fn test_with_configured_engines_default_engine_from_settings() {
let settings = SearchSettings {
default_engine: Some("baidu".to_string()),
..Default::default()
};
let client = build_configured_client(&settings);
assert_eq!(
client.default_engine(),
SearchEngineType::Baidu,
"configured default_engine must be honored on the single-engine fallback path"
);
}
#[test]
fn test_with_configured_engines_unknown_default_engine_falls_back_to_bing() {
let settings = SearchSettings {
default_engine: Some("definitely-not-an-engine".to_string()),
..Default::default()
};
let client = build_configured_client(&settings);
assert_eq!(client.default_engine(), SearchEngineType::Bing);
}
#[test]
fn test_with_configured_engines_unregistered_default_engine_falls_back_to_bing() {
let settings = SearchSettings {
default_engine: Some("exa".to_string()),
..Default::default()
};
let client = build_configured_client(&settings);
assert_eq!(client.default_engine(), SearchEngineType::Bing);
}
#[test]
fn test_with_configured_engines_with_searxng_enabled_registers_engine() {
let mut settings = SearchSettings::default();
settings.searxng.enabled = true;
let client = build_configured_client_with_searxng(&settings, Some(test_searxng_service()));
let types = registered_engine_types(&client);
assert_eq!(client.inner.engines.len(), 4);
assert!(
types.contains(&SearchEngineType::Searxng),
"searxng should register when enabled and the service exists"
);
assert_eq!(
SearchEngineType::from_name("searxng"),
Some(SearchEngineType::Searxng)
);
assert!(client.inner.engines.iter().any(|e| e.name() == "SearxNG"));
}
#[test]
fn test_with_configured_engines_searxng_disabled_skips_engine() {
let settings = SearchSettings::default(); let client = build_configured_client_with_searxng(&settings, Some(test_searxng_service()));
assert!(!registered_engine_types(&client).contains(&SearchEngineType::Searxng));
}
#[test]
fn test_with_configured_engines_searxng_without_service_skips_engine() {
let mut settings = SearchSettings::default();
settings.searxng.enabled = true;
let client = build_configured_client(&settings);
assert!(
!registered_engine_types(&client).contains(&SearchEngineType::Searxng),
"enabled without an instance service must not register the engine"
);
}
#[tokio::test]
async fn test_searxng_single_engine_path_is_addressable() {
let mut settings = SearchSettings::default();
settings.searxng.enabled = true;
let client = build_configured_client_with_searxng(&settings, Some(test_searxng_service()));
let result = client
.search_with_engine("test", SearchEngineType::Searxng)
.await;
match result {
Err(SearchError::NoEngineAvailable) => {}
other => panic!("expected NoEngineAvailable from an empty pool, got {other:?}"),
}
}
#[test]
fn test_with_configured_engines_with_exa_api_key_registers_exa() {
let mut settings = SearchSettings::default();
settings.exa.api_key = Some("test-exa-key".to_string());
let client = build_configured_client(&settings);
let types = registered_engine_types(&client);
assert_eq!(client.inner.engines.len(), 4);
assert!(
types.contains(&SearchEngineType::Exa),
"exa should be registered when api_key is configured"
);
assert_eq!(
SearchEngineType::from_name("exa"),
Some(SearchEngineType::Exa)
);
}
#[test]
fn test_with_configured_engines_with_tavily_api_key_registers_tavily() {
let mut settings = SearchSettings::default();
settings.tavily.api_key = Some("test-tavily-key".to_string());
let client = build_configured_client(&settings);
let types = registered_engine_types(&client);
assert_eq!(client.inner.engines.len(), 4);
assert!(
types.contains(&SearchEngineType::Tavily),
"tavily should be registered when api_key is configured"
);
assert_eq!(
SearchEngineType::from_name("tavily"),
Some(SearchEngineType::Tavily)
);
}
#[test]
fn test_with_configured_engines_with_both_api_keys_registers_all() {
let mut settings = SearchSettings::default();
settings.exa.api_key = Some("test-exa-key".to_string());
settings.tavily.api_key = Some("test-tavily-key".to_string());
let client = build_configured_client(&settings);
let types = registered_engine_types(&client);
assert_eq!(client.inner.engines.len(), 5);
assert!(types.contains(&SearchEngineType::Exa));
assert!(types.contains(&SearchEngineType::Tavily));
}
#[test]
fn test_with_configured_engines_empty_api_key_string_skips_registration() {
let mut settings = SearchSettings::default();
settings.exa.api_key = Some(String::new());
settings.tavily.api_key = Some(" ".to_string());
let client = build_configured_client(&settings);
assert_eq!(
client.inner.engines.len(),
3,
"blank api_key should be treated as not configured"
);
assert!(!registered_engine_types(&client).contains(&SearchEngineType::Exa));
assert!(!registered_engine_types(&client).contains(&SearchEngineType::Tavily));
}
#[tokio::test]
async fn test_with_engine_exa_unregistered_returns_no_engine_available() {
let client = build_configured_client(&SearchSettings::default());
let result = client.search("test").with_engine("exa").execute().await;
assert!(result.is_err());
match result.unwrap_err() {
SearchError::NoEngineAvailable => {}
other => panic!("Expected NoEngineAvailable, got {:?}", other),
}
}
#[tokio::test]
async fn test_search_with_engine_tavily_unregistered_returns_no_engine_available() {
let client = build_configured_client(&SearchSettings::default());
let result = client
.search_with_engine("test", SearchEngineType::Tavily)
.await;
assert!(result.is_err());
match result.unwrap_err() {
SearchError::NoEngineAvailable => {}
other => panic!("Expected NoEngineAvailable, got {:?}", other),
}
}
#[tokio::test]
async fn test_search_with_engine_success() {
let engines: Vec<Arc<dyn SearchEngine>> = vec![Arc::new(MockClientEngine::new(
"bing",
SearchEngineType::Bing,
make_mock_items(SearchEngineType::Bing, 3),
))];
let client = SearchClient::new_with_engines(engines, SearchEngineType::Bing);
let response = client
.search_with_engine("test", SearchEngineType::Bing)
.await
.expect("search_with_engine should succeed");
assert_eq!(response.items.len(), 3);
assert_eq!(response.engine, SearchEngineType::Bing);
assert_eq!(response.total_results, Some(3));
}
#[tokio::test]
async fn test_search_with_engine_no_match_returns_no_engine_available() {
let engines: Vec<Arc<dyn SearchEngine>> = vec![Arc::new(MockClientEngine::new(
"bing",
SearchEngineType::Bing,
make_mock_items(SearchEngineType::Bing, 1),
))];
let client = SearchClient::new_with_engines(engines, SearchEngineType::Bing);
let result = client
.search_with_engine("test", SearchEngineType::Baidu)
.await;
assert!(result.is_err());
match result.unwrap_err() {
SearchError::NoEngineAvailable => {}
other => panic!("Expected NoEngineAvailable, got {:?}", other),
}
}
#[tokio::test]
async fn test_search_with_engine_empty_client_returns_no_engine_available() {
let client = SearchClient::new_with_engines(vec![], SearchEngineType::Bing);
let result = client
.search_with_engine("test", SearchEngineType::Bing)
.await;
assert!(result.is_err());
match result.unwrap_err() {
SearchError::NoEngineAvailable => {}
other => panic!("Expected NoEngineAvailable, got {:?}", other),
}
}
#[test]
fn test_default_engine_returns_configured_type() {
let client = SearchClient::new_with_engines(vec![], SearchEngineType::Baidu);
assert_eq!(client.default_engine(), SearchEngineType::Baidu);
}
#[test]
fn test_default_engine_from_new_client() {
let client = create_test_search_client();
assert_eq!(client.default_engine(), SearchEngineType::Bing);
}
#[tokio::test]
async fn test_search_command_bing_builder() {
let client = create_test_search_client();
let cmd = client.search("query").bing();
assert_eq!(cmd.engine, Some(SearchEngineType::Bing));
}
#[tokio::test]
async fn test_search_command_baidu_builder() {
let client = create_test_search_client();
let cmd = client.search("query").baidu();
assert_eq!(cmd.engine, Some(SearchEngineType::Baidu));
}
#[tokio::test]
async fn test_search_command_sogou_builder() {
let client = create_test_search_client();
let cmd = client.search("query").sogou();
assert_eq!(cmd.engine, Some(SearchEngineType::Sogou));
}
#[tokio::test]
async fn test_search_command_with_engine_string_valid() {
let client = create_test_search_client();
let cmd = client.search("query").with_engine("bing");
assert_eq!(cmd.engine, Some(SearchEngineType::Bing));
}
#[tokio::test]
async fn test_search_command_with_engine_string_invalid() {
let client = create_test_search_client();
let cmd = client.search("query").with_engine("yahoo");
assert_eq!(cmd.engine, None);
}
#[tokio::test]
async fn test_search_command_offset_builder() {
let client = create_test_search_client();
let cmd = client.search("query").offset(20);
assert_eq!(cmd.offset, 20);
}
#[tokio::test]
async fn test_search_command_chained_builders() {
let client = create_test_search_client();
let cmd = client.search("rust").bing().limit(15).offset(5);
assert_eq!(cmd.query, "rust");
assert_eq!(cmd.engine, Some(SearchEngineType::Bing));
assert_eq!(cmd.limit, 15);
assert_eq!(cmd.offset, 5);
}
#[tokio::test]
async fn test_execute_success_with_matching_engine() {
let engines: Vec<Arc<dyn SearchEngine>> = vec![Arc::new(MockClientEngine::new(
"bing",
SearchEngineType::Bing,
make_mock_items(SearchEngineType::Bing, 2),
))];
let client = SearchClient::new_with_engines(engines, SearchEngineType::Bing);
let response = client
.search("test")
.bing()
.execute()
.await
.expect("execute should succeed with matching engine");
assert_eq!(response.items.len(), 2);
assert_eq!(response.engine, SearchEngineType::Bing);
}
#[tokio::test]
async fn test_execute_no_matching_engine_returns_error() {
let engines: Vec<Arc<dyn SearchEngine>> = vec![Arc::new(MockClientEngine::new(
"bing",
SearchEngineType::Bing,
make_mock_items(SearchEngineType::Bing, 1),
))];
let client = SearchClient::new_with_engines(engines, SearchEngineType::Bing);
let result = client.search("test").baidu().execute().await;
assert!(result.is_err());
match result.unwrap_err() {
SearchError::NoEngineAvailable => {}
other => panic!("Expected NoEngineAvailable, got {:?}", other),
}
}
#[tokio::test]
async fn test_execute_uses_default_engine_when_none_specified() {
let engines: Vec<Arc<dyn SearchEngine>> = vec![Arc::new(MockClientEngine::new(
"bing",
SearchEngineType::Bing,
make_mock_items(SearchEngineType::Bing, 1),
))];
let client = SearchClient::new_with_engines(engines, SearchEngineType::Bing);
let response = client
.search("test")
.execute()
.await
.expect("execute should use default engine");
assert_eq!(response.items.len(), 1);
assert_eq!(response.engine, SearchEngineType::Bing);
}
#[tokio::test]
async fn test_execute_with_empty_client_returns_no_engine_available() {
let client = SearchClient::new_with_engines(vec![], SearchEngineType::Bing);
let result = client.search("test").execute().await;
assert!(result.is_err());
match result.unwrap_err() {
SearchError::NoEngineAvailable => {}
other => panic!("Expected NoEngineAvailable, got {:?}", other),
}
}
#[tokio::test]
async fn test_trait_impl_search_returns_command() {
let client = create_test_search_client();
let cmd = SearchClientTrait::search(&client, "query").await;
assert_eq!(cmd.query, "query");
}
#[tokio::test]
async fn test_trait_impl_search_with_engine_success() {
let engines: Vec<Arc<dyn SearchEngine>> = vec![Arc::new(MockClientEngine::new(
"bing",
SearchEngineType::Bing,
make_mock_items(SearchEngineType::Bing, 1),
))];
let client = SearchClient::new_with_engines(engines, SearchEngineType::Bing);
let response =
SearchClientTrait::search_with_engine(&client, "test", SearchEngineType::Bing)
.await
.expect("trait search_with_engine should succeed");
assert_eq!(response.items.len(), 1);
}
#[tokio::test]
async fn test_trait_impl_search_with_engine_no_match() {
let engines: Vec<Arc<dyn SearchEngine>> = vec![Arc::new(MockClientEngine::new(
"bing",
SearchEngineType::Bing,
make_mock_items(SearchEngineType::Bing, 1),
))];
let client = SearchClient::new_with_engines(engines, SearchEngineType::Bing);
let result =
SearchClientTrait::search_with_engine(&client, "test", SearchEngineType::Baidu).await;
assert!(result.is_err());
}
#[test]
fn test_trait_impl_default_engine() {
let client = SearchClient::new_with_engines(vec![], SearchEngineType::Sogou);
assert_eq!(
SearchClientTrait::default_engine(&client),
SearchEngineType::Sogou
);
}
}
use url::Url;
pub fn encode_search_query(query: &str) -> String {
urlencoding::encode(query).to_string()
}
pub fn build_search_url(
base_url: &str,
query_param: &str,
query: &str,
page: u32,
results_per_page: u32,
) -> String {
let encoded_query = encode_search_query(query);
let offset = (page - 1) * results_per_page;
format!(
"{}?{}={}&start={}",
base_url, query_param, encoded_query, offset
)
}
pub fn validate_result_url(url: &str, allowed_schemes: &[&str]) -> Option<String> {
if url.is_empty() {
return None;
}
if !url.starts_with("http://") && !url.starts_with("https://") {
return None;
}
match Url::parse(url) {
Ok(parsed) => {
if allowed_schemes.contains(&parsed.scheme()) {
Some(url.to_string())
} else {
None
}
}
Err(_) => None,
}
}
#[cfg(test)]
mod shared_tests {
use super::*;
#[test]
fn test_encode_search_query() {
let encoded = encode_search_query("hello world");
assert!(encoded.contains("hello%20world"));
}
#[test]
fn test_build_search_url() {
let url = build_search_url("https://example.com/search", "q", "test", 2, 10);
assert!(url.contains("q=test"));
assert!(url.contains("start=10"));
}
#[test]
fn test_validate_result_url_valid() {
let result = validate_result_url("https://example.com", &["http", "https"]);
assert_eq!(result, Some("https://example.com".to_string()));
}
#[test]
fn test_validate_result_url_invalid_scheme() {
let result = validate_result_url("ftp://example.com", &["http", "https"]);
assert!(result.is_none());
}
#[test]
fn test_validate_result_url_empty_returns_none() {
let result = validate_result_url("", &["http", "https"]);
assert!(result.is_none(), "empty URL should return None");
}
#[test]
fn test_validate_result_url_no_scheme_returns_none() {
let result = validate_result_url("example.com", &["http", "https"]);
assert!(
result.is_none(),
"URL without http/https prefix should return None"
);
}
#[test]
fn test_validate_result_url_plain_string_returns_none() {
let result = validate_result_url("not-a-url", &["http", "https"]);
assert!(result.is_none(), "plain string should return None");
}
#[test]
fn test_validate_result_url_http_with_only_https_allowed() {
let result = validate_result_url("http://example.com", &["https"]);
assert!(
result.is_none(),
"http URL with only https allowed should return None"
);
}
#[test]
fn test_validate_result_url_https_with_only_http_allowed() {
let result = validate_result_url("https://example.com", &["http"]);
assert!(
result.is_none(),
"https URL with only http allowed should return None"
);
}
#[test]
fn test_validate_result_url_with_path() {
let result = validate_result_url("https://example.com/path/to/page", &["http", "https"]);
assert_eq!(result, Some("https://example.com/path/to/page".to_string()));
}
#[test]
fn test_validate_result_url_http_no_host_returns_none() {
let result = validate_result_url("http://", &["http", "https"]);
assert_eq!(result, None);
}
}