Create separate search_result_parser

src/models/aggregation_models.rs

@@ -85,12 +85,14 @@ impl EngineErrorInfo {
     pub fn new(error: &EngineError, engine: &str) -> Self {
         Self {
             error: match error {
+                EngineError::EngineNotFound => "EngineNotFound".to_owned(),
                 EngineError::RequestError => "RequestError".to_owned(),
                 EngineError::EmptyResultSet => "EmptyResultSet".to_owned(),
                 EngineError::UnexpectedError => "UnexpectedError".to_owned(),
             },
             engine: engine.to_owned(),
             severity_color: match error {
+                EngineError::EngineNotFound => "red".to_owned(),
                 EngineError::RequestError => "green".to_owned(),
                 EngineError::EmptyResultSet => "blue".to_owned(),
                 EngineError::UnexpectedError => "red".to_owned(),

src/models/engine_models.rs

@@ -2,12 +2,14 @@
 //! the upstream search engines with the search query provided by the user.
 
 use super::aggregation_models::SearchResult;
-use error_stack::{Result, ResultExt};
+use error_stack::{Report, Result, ResultExt};
 use std::{collections::HashMap, fmt, time::Duration};
 
 /// A custom error type used for handle engine associated errors.
 #[derive(Debug)]
 pub enum EngineError {
+    // No matching engine found
+    EngineNotFound,
     /// This variant handles all request related errors like forbidden, not found,
     /// etc.
     EmptyResultSet,
@@ -24,6 +26,9 @@ pub enum EngineError {
 impl fmt::Display for EngineError {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
+            EngineError::EngineNotFound => {
+                write!(f, "Search engine not found")
+            }
             EngineError::EmptyResultSet => {
                 write!(f, "The upstream search engine returned an empty result set")
             }
@@ -134,18 +139,21 @@ impl EngineHandler {
     /// # Returns
     ///
     /// It returns an option either containing the value or a none if the engine is unknown
-    pub fn new(engine_name: &str) -> Option<Self> {
+    pub fn new(engine_name: &str) -> Result<Self, EngineError> {
         let engine: (&'static str, Box<dyn SearchEngine>) =
             match engine_name.to_lowercase().as_str() {
-                "duckduckgo" => (
-                    "duckduckgo",
-                    Box::new(crate::engines::duckduckgo::DuckDuckGo),
-                ),
-                "searx" => ("searx", Box::new(crate::engines::searx::Searx)),
-                _ => return None,
+                "duckduckgo" => {
+                    let engine = crate::engines::duckduckgo::DuckDuckGo::new()?;
+                    ("duckduckgo", Box::new(engine))
+                }
+                "searx" => {
+                    let engine = crate::engines::searx::Searx::new()?;
+                    ("searx", Box::new(engine))
+                }
+                _ => return Err(Report::from(EngineError::EngineNotFound)),
             };
 
-        Some(Self {
+        Ok(Self {
             engine: engine.1,
             name: engine.0,
         })