use thiserror::Error;
#[derive(Error, Debug)]
pub enum ScrapeWorkerError {
#[error("Regex compilation failed: {0}")]
RegexError(String),
#[error("Regex cache lock acquisition failed")]
CacheLockError,
#[error("Selector parse error: {0}")]
SelectorError(String),
#[error("Task processing error: {0}")]
TaskError(String),
}
impl From<String> for ScrapeWorkerError {
fn from(msg: String) -> Self {
ScrapeWorkerError::TaskError(msg)
}
}
impl From<regex::Error> for ScrapeWorkerError {
fn from(e: regex::Error) -> Self {
ScrapeWorkerError::RegexError(e.to_string())
}
}
impl From<url::ParseError> for ScrapeWorkerError {
fn from(e: url::ParseError) -> Self {
ScrapeWorkerError::TaskError(format!("URL parse error: {}", e))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_regex_error_display() {
let err = ScrapeWorkerError::RegexError("invalid pattern".to_string());
let msg = format!("{}", err);
assert!(
msg.contains("Regex compilation failed"),
"Display should contain \"Regex compilation failed\""
);
assert!(
msg.contains("invalid pattern"),
"Display should contain the inner message"
);
}
#[test]
fn test_cache_lock_error_display() {
let err = ScrapeWorkerError::CacheLockError;
let msg = format!("{}", err);
assert!(
msg.contains("Regex cache lock acquisition failed"),
"Display should contain cache lock message"
);
}
#[test]
fn test_selector_error_display() {
let err = ScrapeWorkerError::SelectorError("bad selector".to_string());
let msg = format!("{}", err);
assert!(
msg.contains("Selector parse error"),
"Display should contain \"Selector parse error\""
);
assert!(msg.contains("bad selector"));
}
#[test]
fn test_task_error_display() {
let err = ScrapeWorkerError::TaskError("task failed".to_string());
let msg = format!("{}", err);
assert!(
msg.contains("Task processing error"),
"Display should contain \"Task processing error\""
);
assert!(msg.contains("task failed"));
}
#[test]
fn test_regex_error_debug() {
let err = ScrapeWorkerError::RegexError("dbg".to_string());
let dbg = format!("{:?}", err);
assert!(
dbg.contains("RegexError"),
"Debug should contain variant name"
);
}
#[test]
fn test_cache_lock_error_debug() {
let err = ScrapeWorkerError::CacheLockError;
let dbg = format!("{:?}", err);
assert!(
dbg.contains("CacheLockError"),
"Debug should contain variant name"
);
}
#[test]
fn test_selector_error_debug() {
let err = ScrapeWorkerError::SelectorError("dbg-sel".to_string());
let dbg = format!("{:?}", err);
assert!(
dbg.contains("SelectorError"),
"Debug should contain variant name"
);
}
#[test]
fn test_task_error_debug() {
let err = ScrapeWorkerError::TaskError("dbg-task".to_string());
let dbg = format!("{:?}", err);
assert!(
dbg.contains("TaskError"),
"Debug should contain variant name"
);
}
#[test]
fn test_from_string_creates_task_error() {
let msg = "something went wrong".to_string();
let err: ScrapeWorkerError = msg.into();
match err {
ScrapeWorkerError::TaskError(m) => {
assert_eq!(
m, "something went wrong",
"From<String> should preserve message"
);
}
other => panic!("Expected TaskError, got {:?}", other),
}
}
#[test]
fn test_from_empty_string_creates_task_error() {
let msg = String::new();
let err: ScrapeWorkerError = msg.into();
match err {
ScrapeWorkerError::TaskError(m) => {
assert!(
m.is_empty(),
"empty string should map to TaskError with empty msg"
);
}
other => panic!("Expected TaskError, got {:?}", other),
}
}
#[test]
#[allow(clippy::invalid_regex)]
fn test_from_regex_error_creates_regex_error() {
let regex_err = regex::Regex::new("(unclosed").unwrap_err();
let err: ScrapeWorkerError = regex_err.into();
match err {
ScrapeWorkerError::RegexError(msg) => {
assert!(
!msg.is_empty(),
"From<regex::Error> should produce non-empty msg"
);
}
other => panic!("Expected RegexError, got {:?}", other),
}
}
#[test]
fn test_from_url_parse_error_creates_task_error() {
let url_err = url::Url::parse("not a valid url").unwrap_err();
let err: ScrapeWorkerError = url_err.into();
match err {
ScrapeWorkerError::TaskError(msg) => {
assert!(
msg.contains("URL parse error"),
"From<url::ParseError> should contain \"URL parse error\" prefix"
);
}
other => panic!("Expected TaskError, got {:?}", other),
}
}
#[test]
fn test_regex_error_is_std_error() {
let err = ScrapeWorkerError::RegexError("e".to_string());
assert!(std::error::Error::source(&err).is_none());
}
#[test]
fn test_cache_lock_error_source_is_none() {
let err = ScrapeWorkerError::CacheLockError;
assert!(std::error::Error::source(&err).is_none());
}
}