use std::sync::Arc;
use crate::engines::client::ReqwestEngine;
use crate::engines::engine_client::EngineClient;
use crate::engines::router::{EngineRouter, EngineRouterTrait};
use crate::search::client::SearchClient;
use crate::search::response::ResponseItem;
use crate::search::types::SearchEngineType;
use crate::utils::http_client::create_http_client;
use super::error::AgentLibError;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum SearchProvider {
Bing,
Google,
Baidu,
Sogou,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct SearchResult {
pub title: String,
pub url: String,
pub snippet: String,
}
pub async fn search(
provider: SearchProvider,
query: &str,
limit: usize,
) -> Result<Vec<SearchResult>, AgentLibError> {
static ENGINE_CLIENT: std::sync::LazyLock<Arc<EngineClient>> =
std::sync::LazyLock::new(build_engine_client);
let search_client = SearchClient::new(ENGINE_CLIENT.clone());
search_with_client(&search_client, provider, query, limit).await
}
pub(crate) async fn search_with_client(
client: &SearchClient,
provider: SearchProvider,
query: &str,
limit: usize,
) -> Result<Vec<SearchResult>, AgentLibError> {
let engine = provider_to_engine_type(provider)?;
let request = client
.search(query)
.with_engine(engine.name())
.limit(limit.clamp(0, u32::MAX as usize) as u32);
let response = request
.execute()
.await
.map_err(|e| AgentLibError::Search(format!("{}: {}", engine.name(), e)))?;
Ok(response.items.into_iter().map(map_item).collect())
}
fn provider_to_engine_type(provider: SearchProvider) -> Result<SearchEngineType, AgentLibError> {
match provider {
SearchProvider::Bing => Ok(SearchEngineType::Bing),
SearchProvider::Baidu => Ok(SearchEngineType::Baidu),
SearchProvider::Sogou => Ok(SearchEngineType::Sogou),
SearchProvider::Google => Err(AgentLibError::UnsupportedProvider("Google".to_string())),
}
}
fn map_item(item: ResponseItem) -> SearchResult {
SearchResult {
title: item.title,
url: item.url,
snippet: item.description,
}
}
fn build_engine_client() -> Arc<EngineClient> {
let http_client = create_http_client();
let reqwest_engine = ReqwestEngine::new(http_client);
let router: Arc<dyn EngineRouterTrait> =
Arc::new(EngineRouter::new(vec![Arc::new(reqwest_engine)]));
Arc::new(EngineClient::with_router(router))
}
#[cfg(test)]
mod tests {
use super::*;
use crate::search::engine_trait::{SearchEngine, SearchRequest};
use crate::search::error::SearchError;
use crate::search::response::Response;
use crate::search::types::EngineHealth;
use async_trait::async_trait;
struct MockEngine {
engine_type: SearchEngineType,
items: Vec<ResponseItem>,
}
#[async_trait]
impl SearchEngine for MockEngine {
fn name(&self) -> &'static str {
"MockEngine"
}
fn engine_type(&self) -> SearchEngineType {
self.engine_type
}
fn health(&self) -> EngineHealth {
EngineHealth::Healthy
}
async fn search(
&self,
request: &SearchRequest,
) -> Result<Response<ResponseItem>, SearchError> {
let slice = self
.items
.iter()
.take(request.limit as usize)
.cloned()
.collect::<Vec<_>>();
Ok(Response {
items: slice,
total_results: Some(self.items.len() as u64),
engine: self.engine_type,
})
}
}
fn mock_client(engine_type: SearchEngineType) -> SearchClient {
let engine = MockEngine {
engine_type,
items: vec![
ResponseItem {
title: "Rust Web Scraping".to_string(),
url: "https://example.com/rust".to_string(),
description: "A guide to Rust web scraping".to_string(),
engine: engine_type,
},
ResponseItem {
title: "Async in Rust".to_string(),
url: "https://example.com/async".to_string(),
description: "Understanding async/await".to_string(),
engine: engine_type,
},
],
};
SearchClient::new_with_engines(vec![Arc::new(engine) as Arc<dyn SearchEngine>], engine_type)
}
#[tokio::test]
async fn search_bing_parses_items() {
let client = mock_client(SearchEngineType::Bing);
let results = search_with_client(&client, SearchProvider::Bing, "rust", 2)
.await
.unwrap();
assert_eq!(results.len(), 2);
assert_eq!(results[0].title, "Rust Web Scraping");
assert_eq!(results[0].url, "https://example.com/rust");
assert_eq!(results[0].snippet, "A guide to Rust web scraping");
}
#[tokio::test]
async fn search_baidu_parses_items() {
let client = mock_client(SearchEngineType::Baidu);
let results = search_with_client(&client, SearchProvider::Baidu, "rust", 1)
.await
.unwrap();
assert_eq!(results.len(), 1);
assert_eq!(results[0].title, "Rust Web Scraping");
}
#[tokio::test]
async fn search_sogou_parses_items() {
let client = mock_client(SearchEngineType::Sogou);
let results = search_with_client(&client, SearchProvider::Sogou, "rust", 2)
.await
.unwrap();
assert_eq!(results.len(), 2);
assert_eq!(results[1].url, "https://example.com/async");
}
#[tokio::test]
async fn search_limit_zero_returns_empty() {
let client = mock_client(SearchEngineType::Bing);
let results = search_with_client(&client, SearchProvider::Bing, "rust", 0)
.await
.unwrap();
assert!(results.is_empty());
}
#[tokio::test]
async fn search_google_unsupported_provider() {
let client = mock_client(SearchEngineType::Bing);
let err = search_with_client(&client, SearchProvider::Google, "rust", 2)
.await
.unwrap_err();
assert!(matches!(err, AgentLibError::UnsupportedProvider(_)));
}
#[tokio::test]
async fn search_no_engine_for_provider_errors() {
let client = mock_client(SearchEngineType::Sogou);
let err = search_with_client(&client, SearchProvider::Baidu, "rust", 2)
.await
.unwrap_err();
assert!(matches!(err, AgentLibError::Search(_)));
}
}