use crate::engines::engine_client::{
EngineError, InternalScrapeRequest, InternalScrapeResponse, ScraperEngine,
};
use crate::utils::proxy::redact_proxy_url;
use async_trait::async_trait;
use log::{debug, error, info, warn};
use reqwest::Client;
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::sync::Arc;
use std::time::Duration;
const DEFAULT_FLARESOLVERR_TLS_MRT_SECONDS: u64 = 15;
const DEFAULT_FLARESOLVERR_CDP_MRT_SECONDS: u64 = 30;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum FlareSolverrMode {
#[default]
Full,
Cdp,
Tls,
}
impl FlareSolverrMode {
pub fn engine_name(&self) -> &'static str {
match self {
Self::Full => "flaresolverr",
Self::Cdp => "flaresolverr_cdp",
Self::Tls => "flaresolverr_tls",
}
}
pub fn supports_tls_fingerprint(&self) -> bool {
match self {
Self::Full => false,
Self::Cdp | Self::Tls => true,
}
}
pub fn default_mrt(&self) -> Duration {
match self {
Self::Full | Self::Cdp => Duration::from_secs(DEFAULT_FLARESOLVERR_CDP_MRT_SECONDS),
Self::Tls => Duration::from_secs(DEFAULT_FLARESOLVERR_TLS_MRT_SECONDS),
}
}
}
#[derive(Debug, Clone)]
pub struct FlareSolverrConfig {
pub url: String,
pub timeout_seconds: u64,
pub session_id: Option<String>,
pub mode: FlareSolverrMode,
pub proxy_url: Option<String>,
pub mrt: Option<Duration>,
}
const FALLBACK_URL: &str = "http://localhost:8191";
impl Default for FlareSolverrConfig {
fn default() -> Self {
let url = std::env::var("FLARESOLVERR_URL").unwrap_or_default();
if url.is_empty() {
log::warn!(
"{}",
crate::i18n::tr_log_args(
"flare-url-not-configured",
&[("fallback", FALLBACK_URL.to_string())],
)
);
}
let validated_url = validate_flaresolverr_url(&url).unwrap_or_else(|e| {
log::warn!(
"{}",
crate::i18n::tr_log_args(
"flare-url-validation-failed",
&[
("url", url.as_str().to_string()),
("error", e.as_str().to_string()),
("fallback", FALLBACK_URL.to_string()),
],
)
);
FALLBACK_URL.to_string()
});
Self {
url: validated_url,
timeout_seconds: 60,
session_id: None,
mode: FlareSolverrMode::default(),
proxy_url: None,
mrt: None,
}
}
}
fn validate_flaresolverr_url(url: &str) -> Result<String, String> {
let parsed = url::Url::parse(url).map_err(|_| "Invalid URL format".to_string())?;
match parsed.scheme() {
"http" | "https" => Ok(url.to_string()),
_ => Err(format!(
"Invalid protocol '{}': FLARESOLVERR_URL must use http or https",
parsed.scheme()
)),
}
}
fn log_flaresolverr_validation_fallback(mode: &str, error: &str) {
let key = if mode.is_empty() {
"flare-url-validation-fallback"
} else {
"flare-mode-url-validation-fallback"
};
log::warn!(
"{}",
crate::i18n::tr_log_args(
key,
&[
("mode", mode.to_string()),
("error", error.to_string()),
("fallback", FALLBACK_URL.to_string()),
],
)
);
}
#[derive(Debug, Clone)]
pub struct FlareSolverrEngine {
client: Arc<Client>,
config: FlareSolverrConfig,
session_id: Option<String>,
}
impl FlareSolverrEngine {
pub fn new(client: Arc<Client>) -> Self {
Self::with_config(client, FlareSolverrConfig::default())
}
pub fn with_url(client: Arc<Client>, url: impl Into<String>) -> Self {
let validated = validate_flaresolverr_url(&url.into()).unwrap_or_else(|e| {
log_flaresolverr_validation_fallback("", &e);
FALLBACK_URL.to_string()
});
let config = FlareSolverrConfig {
url: validated,
timeout_seconds: 60,
session_id: None,
mode: FlareSolverrMode::Full,
proxy_url: None,
mrt: None,
};
Self::with_config(client, config)
}
pub fn with_config(client: Arc<Client>, config: FlareSolverrConfig) -> Self {
let session_id = config.session_id.clone();
Self {
client,
config,
session_id,
}
}
pub fn with_cdp_mode(client: Arc<Client>, proxy_url: Option<&str>) -> Self {
Self::with_mode_and_proxy(client, FlareSolverrMode::Cdp, proxy_url)
}
pub fn with_cdp_mode_and_url(
client: Arc<Client>,
base_url: &str,
proxy_url: Option<&str>,
) -> Self {
let validated = validate_flaresolverr_url(base_url).unwrap_or_else(|e| {
log_flaresolverr_validation_fallback("CDP", &e);
FALLBACK_URL.to_string()
});
let config = FlareSolverrConfig {
url: validated,
timeout_seconds: 60,
session_id: None,
mode: FlareSolverrMode::Cdp,
proxy_url: proxy_url.map(|s| s.to_string()),
mrt: None,
};
Self::with_config(client, config)
}
pub fn with_tls_mode(client: Arc<Client>, proxy_url: Option<&str>) -> Self {
Self::with_mode_and_proxy(client, FlareSolverrMode::Tls, proxy_url)
}
pub fn with_tls_mode_and_url(
client: Arc<Client>,
base_url: &str,
proxy_url: Option<&str>,
) -> Self {
let validated = validate_flaresolverr_url(base_url).unwrap_or_else(|e| {
log_flaresolverr_validation_fallback("TLS", &e);
FALLBACK_URL.to_string()
});
let config = FlareSolverrConfig {
url: validated,
timeout_seconds: 60,
session_id: None,
mode: FlareSolverrMode::Tls,
proxy_url: proxy_url.map(|s| s.to_string()),
mrt: None,
};
Self::with_config(client, config)
}
#[must_use]
pub fn with_url_and_mrt(
client: Arc<Client>,
url: impl Into<String>,
mrt: Duration,
timeout_seconds: u64,
) -> Self {
let validated = validate_flaresolverr_url(&url.into()).unwrap_or_else(|e| {
log_flaresolverr_validation_fallback("Full", &e);
FALLBACK_URL.to_string()
});
let config = FlareSolverrConfig {
url: validated,
timeout_seconds,
session_id: None,
mode: FlareSolverrMode::Full,
proxy_url: None,
mrt: Some(mrt),
};
Self::with_config(client, config)
}
#[must_use]
pub fn with_cdp_mode_url_and_mrt(
client: Arc<Client>,
base_url: &str,
proxy_url: Option<&str>,
mrt: Duration,
timeout_seconds: u64,
) -> Self {
let validated = validate_flaresolverr_url(base_url).unwrap_or_else(|e| {
log_flaresolverr_validation_fallback("CDP+MRT", &e);
FALLBACK_URL.to_string()
});
let config = FlareSolverrConfig {
url: validated,
timeout_seconds,
session_id: None,
mode: FlareSolverrMode::Cdp,
proxy_url: proxy_url.map(|s| s.to_string()),
mrt: Some(mrt),
};
Self::with_config(client, config)
}
#[must_use]
pub fn with_tls_mode_url_and_mrt(
client: Arc<Client>,
base_url: &str,
proxy_url: Option<&str>,
mrt: Duration,
timeout_seconds: u64,
) -> Self {
let validated = validate_flaresolverr_url(base_url).unwrap_or_else(|e| {
log_flaresolverr_validation_fallback("TLS+MRT", &e);
FALLBACK_URL.to_string()
});
let config = FlareSolverrConfig {
url: validated,
timeout_seconds,
session_id: None,
mode: FlareSolverrMode::Tls,
proxy_url: proxy_url.map(|s| s.to_string()),
mrt: Some(mrt),
};
Self::with_config(client, config)
}
fn with_mode_and_proxy(
client: Arc<Client>,
mode: FlareSolverrMode,
proxy_url: Option<&str>,
) -> Self {
let raw_url = std::env::var("FLARESOLVERR_URL").unwrap_or_default();
if raw_url.is_empty() {
log::warn!(
"{}",
crate::i18n::tr_log_args(
"flare-url-not-configured-fallback",
&[("fallback", FALLBACK_URL.to_string())],
)
);
}
let validated = validate_flaresolverr_url(&raw_url).unwrap_or_else(|e| {
log_flaresolverr_validation_fallback("", &e);
FALLBACK_URL.to_string()
});
let config = FlareSolverrConfig {
url: validated,
timeout_seconds: 60,
session_id: None,
mode,
proxy_url: proxy_url.map(|s| s.to_string()),
mrt: None,
};
Self::with_config(client, config)
}
pub fn builder() -> FlareSolverrEngineBuilder {
FlareSolverrEngineBuilder::default()
}
pub fn session_id(&self) -> Option<&str> {
self.session_id.as_deref()
}
pub fn mode(&self) -> FlareSolverrMode {
self.config.mode
}
#[must_use]
pub fn mrt(&self) -> Duration {
self.config
.mrt
.unwrap_or_else(|| self.config.mode.default_mrt())
}
fn api_url(&self) -> String {
let base_url = self.config.url.trim_end_matches('/');
if base_url.ends_with("/v1") {
base_url.to_string()
} else {
format!("{}/v1", base_url)
}
}
pub async fn create_session(&mut self) -> Result<String, EngineError> {
#[derive(Serialize)]
struct CreateSessionRequest {
cmd: String,
#[serde(skip_serializing_if = "Option::is_none")]
session: Option<String>,
}
let request = CreateSessionRequest {
cmd: "sessions.create".to_string(),
session: None,
};
let response: SessionResponse = self
.client
.post(self.api_url())
.json(&request)
.send()
.await
.map_err(|e| EngineError::Other(format!("Failed to create session: {}", e)))?
.json()
.await
.map_err(|e| EngineError::Other(format!("Failed to parse session response: {}", e)))?;
if response.status == "ok" {
if let Some(session_id) = response.session {
self.session_id = Some(session_id.clone());
info!("Created FlareSolverr session: {}", session_id);
Ok(session_id)
} else {
Err(EngineError::Other("No session ID in response".to_string()))
}
} else {
Err(EngineError::Other(format!(
"Failed to create session: {}",
response.message
)))
}
}
pub async fn destroy_session(&mut self, session_id: &str) -> Result<(), EngineError> {
#[derive(Serialize)]
struct DestroySessionRequest {
cmd: String,
session: String,
}
let request = DestroySessionRequest {
cmd: "sessions.destroy".to_string(),
session: session_id.to_string(),
};
let response: GenericResponse = self
.client
.post(self.api_url())
.json(&request)
.send()
.await
.map_err(|e| EngineError::Other(format!("Failed to destroy session: {}", e)))?
.json()
.await
.map_err(|e| EngineError::Other(format!("Failed to parse response: {}", e)))?;
if response.status == "ok" {
self.session_id = None;
debug!("Destroyed FlareSolverr session: {}", session_id);
Ok(())
} else {
Err(EngineError::Other(format!(
"Failed to destroy session: {}",
response.message
)))
}
}
}
#[derive(Debug, Default)]
pub struct FlareSolverrEngineBuilder {
config: FlareSolverrConfig,
}
impl FlareSolverrEngineBuilder {
pub fn with_url(mut self, url: &str) -> Self {
self.config.url = url.to_string();
self
}
pub fn with_timeout(mut self, seconds: u64) -> Self {
self.config.timeout_seconds = seconds;
self
}
pub fn with_session(mut self, session_id: &str) -> Self {
self.config.session_id = Some(session_id.to_string());
self
}
pub fn with_mode(mut self, mode: FlareSolverrMode) -> Self {
self.config.mode = mode;
self
}
pub fn with_proxy(mut self, proxy_url: &str) -> Self {
self.config.proxy_url = Some(proxy_url.to_string());
self
}
pub fn with_mrt(mut self, mrt: Duration) -> Self {
self.config.mrt = Some(mrt);
self
}
pub fn build(self, client: Arc<Client>) -> FlareSolverrEngine {
FlareSolverrEngine::with_config(client, self.config)
}
}
#[derive(Serialize, Deserialize, Debug)]
struct SessionResponse {
status: String,
message: String,
session: Option<String>,
#[serde(flatten)]
_extra: HashMap<String, serde_json::Value>,
}
#[derive(Serialize, Deserialize, Debug)]
struct GenericResponse {
status: String,
message: String,
#[serde(flatten)]
_extra: HashMap<String, serde_json::Value>,
}
#[derive(Serialize, Debug)]
struct FlareSolverrRequest {
cmd: String,
url: String,
#[serde(skip_serializing_if = "Option::is_none")]
session: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
max_timeout: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
return_screenshot: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
wait_in_seconds: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
disable_media: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
cookies: Option<Vec<Cookie>>,
#[serde(skip_serializing_if = "Option::is_none")]
post_data: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
custom_headers: Option<HashMap<String, String>>,
}
#[derive(Serialize, Deserialize, Debug, Clone)]
struct Cookie {
name: String,
value: String,
#[serde(skip_serializing_if = "Option::is_none", default)]
domain: Option<String>,
#[serde(skip_serializing_if = "Option::is_none", default)]
path: Option<String>,
}
#[derive(Serialize, Deserialize, Debug)]
struct FlareSolverrResponse {
status: String,
message: String,
#[serde(skip_serializing_if = "Option::is_none")]
solution: Option<FlareSolverrSolution>,
#[serde(flatten)]
_extra: HashMap<String, serde_json::Value>,
}
#[derive(Serialize, Deserialize, Debug)]
struct FlareSolverrSolution {
url: String,
status: u16,
#[serde(skip_serializing_if = "Option::is_none")]
headers: Option<HashMap<String, String>>,
response: String,
#[serde(skip_serializing_if = "Option::is_none")]
cookies: Option<Vec<Cookie>>,
#[serde(skip_serializing_if = "Option::is_none")]
user_agent: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
screenshot: Option<String>,
#[serde(default)]
start_timestamp: i64,
#[serde(default)]
end_timestamp: i64,
}
fn merge_custom_headers(
mode: FlareSolverrMode,
proxy_url: Option<&String>,
user_headers: &HashMap<String, String>,
) -> HashMap<String, String> {
let mut custom_headers: HashMap<String, String> = HashMap::new();
if let Some(proxy) = proxy_url {
custom_headers.insert("X-Proxy-URL".to_string(), proxy.clone());
debug!(
"{} using proxy: {}",
mode.engine_name(),
redact_proxy_url(proxy)
);
}
for (key, value) in user_headers {
if key != "X-Proxy-URL" {
custom_headers.insert(key.clone(), value.clone());
}
}
if !user_headers.is_empty() {
debug!(
"{} forwarded {} custom headers to FlareSolverr",
mode.engine_name(),
user_headers.len()
);
}
custom_headers
}
fn build_fs_request(
request: &InternalScrapeRequest,
session: Option<String>,
custom_headers: HashMap<String, String>,
) -> FlareSolverrRequest {
FlareSolverrRequest {
cmd: "request.get".to_string(),
url: request.url.clone(),
session,
max_timeout: Some(request.timeout.as_millis() as u64),
return_screenshot: if request.needs_screenshot {
Some(true)
} else {
None
},
wait_in_seconds: if request.sync_wait_ms > 0 {
Some(request.sync_wait_ms as u64 / 1000)
} else {
None
},
disable_media: None,
cookies: None,
post_data: None,
custom_headers: if custom_headers.is_empty() {
None
} else {
Some(custom_headers)
},
}
}
fn build_api_url(config_url: &str) -> String {
let base_url = config_url.trim_end_matches('/');
if base_url.ends_with("/v1") {
base_url.to_string()
} else {
format!("{}/v1", base_url)
}
}
fn parse_fs_response(raw_text: &str) -> Result<FlareSolverrResponse, EngineError> {
serde_json::from_str(raw_text).map_err(|e| {
EngineError::RequestFailed(format!(
"Failed to parse FlareSolverr response: {} (first 200 chars: {:?})",
e,
&raw_text[..raw_text.len().min(200)]
))
})
}
fn extract_solution(response: FlareSolverrResponse) -> Result<FlareSolverrSolution, EngineError> {
if response.status != "ok" {
error!("FlareSolverr error: {}", response.message);
return Err(EngineError::RequestFailed(format!(
"FlareSolverr error: {}",
response.message
)));
}
response.solution.ok_or_else(|| {
EngineError::RequestFailed("No solution in FlareSolverr response".to_string())
})
}
fn is_captcha_page(html_content: &str) -> bool {
html_content.contains("captcha")
|| html_content.contains("CAPTCHA")
|| html_content.contains("unusual traffic")
|| html_content.contains("Our systems have detected")
|| html_content.contains("recaptcha")
|| html_content.contains("verify you are human")
}
fn build_scrape_response(
solution: FlareSolverrSolution,
response_time_ms: u64,
) -> InternalScrapeResponse {
let mut headers = solution.headers.unwrap_or_default();
if !headers.contains_key("content-type") {
headers.insert("content-type".to_string(), "text/html".to_string());
}
InternalScrapeResponse {
js_degraded: false,
status_code: solution.status,
content: solution.response,
content_type: headers
.get("content-type")
.cloned()
.unwrap_or_else(|| "text/html".to_string()),
screenshot: solution.screenshot,
headers,
response_time_ms,
final_url: None,
captured_responses: Vec::new(),
}
}
impl FlareSolverrEngine {
async fn send_request(
&self,
api_url: &str,
fs_request: &FlareSolverrRequest,
) -> Result<FlareSolverrSolution, EngineError> {
let raw_response = self
.client
.post(api_url)
.json(fs_request)
.send()
.await
.map_err(|e| {
EngineError::RequestFailed(format!("FlareSolverr request failed: {}", e))
})?;
let raw_text = raw_response.text().await.map_err(|e| {
EngineError::RequestFailed(format!("Failed to get response text: {}", e))
})?;
debug!("FlareSolverr raw response length: {}", raw_text.len());
extract_solution(parse_fs_response(&raw_text)?)
}
fn reject_captcha_page(solution: &FlareSolverrSolution) -> Result<(), EngineError> {
if is_captcha_page(&solution.response) {
warn!("FlareSolverr returned CAPTCHA/bot detection page");
return Err(EngineError::AntiBotDetected(
"FlareSolverr blocked by CAPTCHA or bot detection".to_string(),
));
}
Ok(())
}
fn full_mode_score(request: &InternalScrapeRequest) -> u8 {
if request.needs_js {
return 100;
}
80
}
fn cdp_mode_score(request: &InternalScrapeRequest) -> u8 {
if request.needs_tls_fingerprint && request.needs_screenshot {
return 100;
}
if request.use_fire_engine {
return 100;
}
if request.needs_screenshot {
return 80;
}
if request.needs_js {
return 90;
}
if !request.actions.is_empty() {
return 90;
}
40
}
fn tls_mode_score(request: &InternalScrapeRequest) -> u8 {
if request.needs_screenshot {
return 0;
}
if request.use_fire_engine {
return 95;
}
if request.needs_tls_fingerprint {
return 90;
}
if request.needs_js {
return 60;
}
if !request.actions.is_empty() {
return 50;
}
70
}
}
#[async_trait]
impl ScraperEngine for FlareSolverrEngine {
async fn scrape(
&self,
request: &InternalScrapeRequest,
) -> Result<InternalScrapeResponse, EngineError> {
if request.method != crate::engines::engine_client::HttpMethod::Get {
return Err(EngineError::Other("Unsupported HTTP method".to_string()));
}
crate::engines::validators::validate_url(&request.url)
.await
.map_err(|e| EngineError::SsrfProtection(format!("SSRF protection: {}", e)))?;
if self.config.mode == FlareSolverrMode::Tls && request.needs_screenshot {
return Err(EngineError::Other(
"FireEngineTls does not support screenshots".to_string(),
));
}
let start_time = std::time::Instant::now();
let proxy_url = request.proxy.as_ref().or(self.config.proxy_url.as_ref());
let custom_headers = merge_custom_headers(self.config.mode, proxy_url, &request.headers);
let fs_request = build_fs_request(request, self.session_id.clone(), custom_headers);
let api_url = build_api_url(&self.config.url);
debug!(
"FlareSolverr request: mode={}, url={}, session={:?}",
self.config.mode.engine_name(),
request.url,
fs_request.session
);
let solution = self.send_request(&api_url, &fs_request).await?;
Self::reject_captcha_page(&solution)?;
let response_time_ms = start_time.elapsed().as_millis() as u64;
let scrape_response = build_scrape_response(solution, response_time_ms);
info!(
"FlareSolverr success: mode={}, status={}, time={}ms, content_length={}",
self.config.mode.engine_name(),
scrape_response.status_code,
response_time_ms,
scrape_response.content.len()
);
Ok(scrape_response)
}
fn support_score(&self, request: &InternalScrapeRequest) -> u8 {
if request.method != crate::engines::engine_client::HttpMethod::Get {
return 0;
}
match self.config.mode {
FlareSolverrMode::Full => Self::full_mode_score(request),
FlareSolverrMode::Cdp => Self::cdp_mode_score(request),
FlareSolverrMode::Tls => Self::tls_mode_score(request),
}
}
fn name(&self) -> &'static str {
self.config.mode.engine_name()
}
fn supports_tls_fingerprint(&self) -> bool {
self.config.mode.supports_tls_fingerprint()
}
fn max_response_time(&self) -> Duration {
self.mrt()
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::engines::engine_client::HttpMethod;
fn mk_req(url: &str) -> InternalScrapeRequest {
InternalScrapeRequest {
url: url.to_string(),
method: HttpMethod::Get,
headers: HashMap::new(),
timeout: Duration::from_secs(30),
needs_js: false,
needs_screenshot: false,
screenshot_config: None,
mobile: false,
proxy: None,
skip_tls_verification: false,
needs_tls_fingerprint: false,
use_fire_engine: false,
actions: Vec::new(),
body: None,
sync_wait_ms: 0,
block_ads: false,
block_media: false,
session_id: None,
wait_for: None,
needs_mllm: false,
}
}
fn engine() -> FlareSolverrEngine {
FlareSolverrEngine::with_url(Arc::new(Client::new()), "http://127.0.0.1:8192")
}
#[test]
fn mode_engine_name_maps_each_variant() {
assert_eq!(FlareSolverrMode::Full.engine_name(), "flaresolverr");
assert_eq!(FlareSolverrMode::Cdp.engine_name(), "flaresolverr_cdp");
assert_eq!(FlareSolverrMode::Tls.engine_name(), "flaresolverr_tls");
assert_eq!(FlareSolverrMode::default(), FlareSolverrMode::Full);
}
#[test]
fn mode_supports_tls_fingerprint() {
assert!(!FlareSolverrMode::Full.supports_tls_fingerprint());
assert!(FlareSolverrMode::Cdp.supports_tls_fingerprint());
assert!(FlareSolverrMode::Tls.supports_tls_fingerprint());
}
#[test]
fn mode_default_mrt_by_variant() {
assert_eq!(
FlareSolverrMode::Full.default_mrt(),
Duration::from_secs(30)
);
assert_eq!(FlareSolverrMode::Cdp.default_mrt(), Duration::from_secs(30));
assert_eq!(FlareSolverrMode::Tls.default_mrt(), Duration::from_secs(15));
}
#[test]
fn validate_flaresolverr_url_accepts_http_https() {
assert_eq!(
validate_flaresolverr_url("http://h:1").unwrap(),
"http://h:1"
);
assert_eq!(validate_flaresolverr_url("https://h").unwrap(), "https://h");
}
#[test]
fn validate_flaresolverr_url_rejects_bad_scheme_and_format() {
assert!(validate_flaresolverr_url("ftp://h").is_err());
assert!(validate_flaresolverr_url("not a url").is_err());
assert!(validate_flaresolverr_url("").is_err());
}
#[test]
fn with_url_valid_keeps_url_and_invalid_falls_back() {
let good = FlareSolverrEngine::with_url(Arc::new(Client::new()), "http://127.0.0.1:8192");
assert_eq!(good.config.url, "http://127.0.0.1:8192");
assert_eq!(good.mode(), FlareSolverrMode::Full);
let bad = FlareSolverrEngine::with_url(Arc::new(Client::new()), "ftp://nope");
assert_eq!(bad.config.url, FALLBACK_URL);
}
#[test]
fn mode_constructors_set_expected_mode() {
let c = FlareSolverrEngine::with_cdp_mode_and_url(
Arc::new(Client::new()),
"http://127.0.0.1:8192",
Some("http://proxy:8080"),
);
assert_eq!(c.mode(), FlareSolverrMode::Cdp);
assert_eq!(c.config.proxy_url.as_deref(), Some("http://proxy:8080"));
assert!(c.supports_tls_fingerprint());
let t = FlareSolverrEngine::with_tls_mode_and_url(
Arc::new(Client::new()),
"http://127.0.0.1:8192",
None,
);
assert_eq!(t.mode(), FlareSolverrMode::Tls);
assert!(t.supports_tls_fingerprint());
}
#[test]
fn constructors_with_explicit_mrt_override_default() {
let full = FlareSolverrEngine::with_url_and_mrt(
Arc::new(Client::new()),
"http://127.0.0.1:8192",
Duration::from_secs(7),
42,
);
assert_eq!(full.mrt(), Duration::from_secs(7));
assert_eq!(full.config.timeout_seconds, 42);
let cdp = FlareSolverrEngine::with_cdp_mode_url_and_mrt(
Arc::new(Client::new()),
"http://127.0.0.1:8192",
None,
Duration::from_secs(9),
30,
);
assert_eq!(cdp.mrt(), Duration::from_secs(9));
let tls = FlareSolverrEngine::with_tls_mode_url_and_mrt(
Arc::new(Client::new()),
"http://127.0.0.1:8192",
None,
Duration::from_secs(5),
20,
);
assert_eq!(tls.mrt(), Duration::from_secs(5));
assert_eq!(tls.mode(), FlareSolverrMode::Tls);
}
#[test]
fn mrt_defaults_per_mode_when_not_injected() {
assert_eq!(
FlareSolverrEngine::with_url(Arc::new(Client::new()), "http://h:1").mrt(),
Duration::from_secs(30)
);
let tls =
FlareSolverrEngine::with_tls_mode_and_url(Arc::new(Client::new()), "http://h:1", None);
assert_eq!(tls.mrt(), Duration::from_secs(15));
}
#[test]
fn builder_fluently_sets_all_fields() {
let e = FlareSolverrEngine::builder()
.with_url("http://127.0.0.1:8192")
.with_timeout(77)
.with_session("sess-1")
.with_mode(FlareSolverrMode::Cdp)
.with_proxy("http://p:1")
.with_mrt(Duration::from_secs(11))
.build(Arc::new(Client::new()));
assert_eq!(e.mode(), FlareSolverrMode::Cdp);
assert_eq!(e.session_id(), Some("sess-1"));
assert_eq!(e.config.timeout_seconds, 77);
assert_eq!(e.config.proxy_url.as_deref(), Some("http://p:1"));
assert_eq!(e.mrt(), Duration::from_secs(11));
}
#[test]
fn session_id_none_when_unset() {
assert_eq!(engine().session_id(), None);
}
#[test]
fn api_url_appends_v1_without_duplication() {
let a = FlareSolverrEngine::with_url(Arc::new(Client::new()), "http://h:1/");
assert_eq!(a.api_url(), "http://h:1/v1");
let b = FlareSolverrEngine::with_config(
Arc::new(Client::new()),
FlareSolverrConfig {
url: "http://h:1/v1".to_string(),
timeout_seconds: 60,
session_id: None,
mode: FlareSolverrMode::Full,
proxy_url: None,
mrt: None,
},
);
assert_eq!(b.api_url(), "http://h:1/v1");
}
#[test]
fn name_and_max_response_time_and_tls_flag() {
assert_eq!(engine().name(), "flaresolverr");
let tls =
FlareSolverrEngine::with_tls_mode_and_url(Arc::new(Client::new()), "http://h:1", None);
assert_eq!(tls.name(), "flaresolverr_tls");
assert_eq!(tls.max_response_time(), Duration::from_secs(15));
}
#[test]
fn support_score_full_mode_branches() {
let e = FlareSolverrEngine::with_url(Arc::new(Client::new()), "http://h:1");
let mut post = mk_req("https://example.com");
post.method = HttpMethod::Post;
assert_eq!(e.support_score(&post), 0);
assert_eq!(e.support_score(&mk_req("https://example.com")), 80);
let mut js = mk_req("https://example.com");
js.needs_js = true;
assert_eq!(e.support_score(&js), 100);
}
#[test]
fn support_score_cdp_mode_branches() {
let e =
FlareSolverrEngine::with_cdp_mode_and_url(Arc::new(Client::new()), "http://h:1", None);
let mut tls_shot = mk_req("https://example.com");
tls_shot.needs_tls_fingerprint = true;
tls_shot.needs_screenshot = true;
assert_eq!(e.support_score(&tls_shot), 100);
let mut fire = mk_req("https://example.com");
fire.use_fire_engine = true;
assert_eq!(e.support_score(&fire), 100);
let mut shot = mk_req("https://example.com");
shot.needs_screenshot = true;
assert_eq!(e.support_score(&shot), 80);
let mut js = mk_req("https://example.com");
js.needs_js = true;
assert_eq!(e.support_score(&js), 90);
assert_eq!(e.support_score(&mk_req("https://example.com")), 40);
}
#[test]
fn support_score_tls_mode_branches() {
let e =
FlareSolverrEngine::with_tls_mode_and_url(Arc::new(Client::new()), "http://h:1", None);
let mut fire = mk_req("https://example.com");
fire.use_fire_engine = true;
assert_eq!(e.support_score(&fire), 95);
let mut tls = mk_req("https://example.com");
tls.needs_tls_fingerprint = true;
assert_eq!(e.support_score(&tls), 90);
let mut js = mk_req("https://example.com");
js.needs_js = true;
assert_eq!(e.support_score(&js), 60);
assert_eq!(e.support_score(&mk_req("https://example.com")), 70);
}
const PUBLIC_TARGET: &str = "http://93.184.216.34";
async fn start_mock(body: String) -> String {
use axum::http::header::CONTENT_TYPE;
use axum::routing::post;
use axum::Router;
use tokio::net::TcpListener;
let app = Router::new().route(
"/v1",
post(move || {
let b = body.clone();
async move { ([(CONTENT_TYPE, "application/json")], b) }
}),
);
let l = TcpListener::bind("127.0.0.1:0").await.expect("bind");
let addr = l.local_addr().expect("addr");
tokio::spawn(async move {
let _ = axum::serve(l, app).await;
});
format!("http://{}", addr)
}
fn solution_json(response_body: &str) -> String {
format!(
r#"{{"status":"ok","message":"","solution":{{"url":"http://x","status":200,"response":"{}","headers":{{"content-type":"text/html"}},"cookies":[],"user_agent":"ua","screenshot":null,"start_timestamp":1,"end_timestamp":2}}}}"#,
response_body
)
}
#[tokio::test]
async fn scrape_rejects_non_get() {
let mut r = mk_req(PUBLIC_TARGET);
r.method = HttpMethod::Post;
let e = engine();
let err = e.scrape(&r).await.expect_err("non-GET must err");
assert!(matches!(err, EngineError::Other(_)));
}
#[tokio::test]
async fn scrape_tls_mode_rejects_screenshot() {
let e = FlareSolverrEngine::with_tls_mode_and_url(
Arc::new(Client::new()),
"http://127.0.0.1:1",
None,
);
let mut r = mk_req(PUBLIC_TARGET);
r.needs_screenshot = true;
let err = e.scrape(&r).await.expect_err("tls+screenshot must err");
assert!(matches!(err, EngineError::Other(_)));
}
#[tokio::test]
async fn scrape_success_path_returns_solution() {
let mock = start_mock(solution_json("<html>hello</html>")).await;
let e = FlareSolverrEngine::with_url(Arc::new(Client::new()), &mock);
let resp = e.scrape(&mk_req(PUBLIC_TARGET)).await.expect("scrape ok");
assert_eq!(resp.status_code, 200);
assert!(resp.content.contains("hello"));
assert_eq!(resp.content_type, "text/html");
}
#[tokio::test]
async fn scrape_error_status_maps_to_request_failed() {
let mock = start_mock(r#"{"status":"error","message":"boom"}"#.to_string()).await;
let e = FlareSolverrEngine::with_url(Arc::new(Client::new()), &mock);
let err = e
.scrape(&mk_req(PUBLIC_TARGET))
.await
.expect_err("error status");
assert!(matches!(err, EngineError::RequestFailed(_)));
}
#[tokio::test]
async fn scrape_captcha_page_maps_to_antibot() {
let mock = start_mock(solution_json(
"this page has a CAPTCHA to verify you are human",
))
.await;
let e = FlareSolverrEngine::with_url(Arc::new(Client::new()), &mock);
let err = e.scrape(&mk_req(PUBLIC_TARGET)).await.expect_err("captcha");
assert!(matches!(err, EngineError::AntiBotDetected(_)));
}
#[tokio::test]
async fn scrape_ok_but_no_solution_is_request_failed() {
let mock = start_mock(r#"{"status":"ok","message":""}"#.to_string()).await;
let e = FlareSolverrEngine::with_url(Arc::new(Client::new()), &mock);
let err = e
.scrape(&mk_req(PUBLIC_TARGET))
.await
.expect_err("no solution");
assert!(matches!(err, EngineError::RequestFailed(_)));
}
#[tokio::test]
async fn scrape_invalid_json_is_request_failed() {
let mock = start_mock("not-json".to_string()).await;
let e = FlareSolverrEngine::with_url(Arc::new(Client::new()), &mock);
let err = e
.scrape(&mk_req(PUBLIC_TARGET))
.await
.expect_err("bad json");
assert!(matches!(err, EngineError::RequestFailed(_)));
}
#[tokio::test]
async fn create_session_ok_sets_id() {
let mock =
start_mock(r#"{"status":"ok","message":"","session":"abc-123"}"#.to_string()).await;
let mut e = FlareSolverrEngine::with_url(Arc::new(Client::new()), &mock);
let sid = e.create_session().await.expect("create session");
assert_eq!(sid, "abc-123");
assert_eq!(e.session_id(), Some("abc-123"));
}
#[tokio::test]
async fn create_session_no_id_is_err() {
let mock = start_mock(r#"{"status":"ok","message":""}"#.to_string()).await;
let mut e = FlareSolverrEngine::with_url(Arc::new(Client::new()), &mock);
assert!(e.create_session().await.is_err());
}
#[tokio::test]
async fn create_session_error_status_is_err() {
let mock = start_mock(r#"{"status":"error","message":"nope"}"#.to_string()).await;
let mut e = FlareSolverrEngine::with_url(Arc::new(Client::new()), &mock);
assert!(e.create_session().await.is_err());
}
#[tokio::test]
async fn destroy_session_ok_clears_id() {
let mock = start_mock(r#"{"status":"ok","message":""}"#.to_string()).await;
let mut e = FlareSolverrEngine::builder()
.with_url(&mock)
.with_session("s1")
.build(Arc::new(Client::new()));
e.destroy_session("s1").await.expect("destroy ok");
assert_eq!(e.session_id(), None);
}
#[tokio::test]
async fn destroy_session_error_status_is_err() {
let mock = start_mock(r#"{"status":"error","message":"x"}"#.to_string()).await;
let mut e = FlareSolverrEngine::with_url(Arc::new(Client::new()), &mock);
assert!(e.destroy_session("s1").await.is_err());
}
}