Dev

Cargo.toml

@@ -22,4 +22,5 @@ strum = "0.26.3"
 strum_macros = "0.26.4"
 
 [dev-dependencies]
+automod = "1.0.14"
 stubr = "0.6.2"

tests/cache_test.rs

@@ -1,12 +1,18 @@
-mod common;
-
-use common::constants::TEST_URL;
-use reqwest::header::{HeaderMap, HeaderValue, CONTENT_LENGTH, USER_AGENT};
+use reqwest::header::{HeaderMap, CONTENT_LENGTH, USER_AGENT};
 use std::time::Duration;
 use strum::IntoEnumIterator;
 
+mod constants {
+    use reqwest::header::HeaderValue;
+
+    pub const TEST_URL: &str = "http://foo.com";
+    pub const USER_AGENT_VALUE: HeaderValue = HeaderValue::from_static("x-api-key");
+    pub const CONTENT_LENGTH_VALUE: HeaderValue = HeaderValue::from_static("10000");
+}
+
 #[cfg(test)]
 mod requesters {
+    use super::constants::{CONTENT_LENGTH_VALUE, TEST_URL, USER_AGENT_VALUE};
     use super::*;
     use subscan::{
         cache, enums::RequesterType, interfaces::requester::RequesterInterface,
@@ -27,8 +33,8 @@ mod requesters {
         let new_config = RequesterConfig {
             timeout: Duration::from_secs(120),
             headers: HeaderMap::from_iter([
-                (USER_AGENT, HeaderValue::from_static("x-api-key")),
-                (CONTENT_LENGTH, HeaderValue::from_static("10000")),
+                (USER_AGENT, USER_AGENT_VALUE),
+                (CONTENT_LENGTH, CONTENT_LENGTH_VALUE),
             ]),
             proxy: Some(TEST_URL.to_string()),
         };

tests/extractors/common.rs

@@ -0,0 +1,20 @@
+pub mod constants {
+    pub const TEST_DOMAIN: &str = "foo.com";
+    pub const TEST_BAR_SUBDOMAIN: &str = "bar.foo.com";
+    pub const TEST_BAZ_SUBDOMAIN: &str = "baz.foo.com";
+    pub const READ_ERROR: &str = "Cannot read file!";
+}
+
+pub mod funcs {
+    use super::constants::READ_ERROR;
+    use std::fs;
+    use std::path::{Path, PathBuf};
+
+    fn testdata_path() -> PathBuf {
+        Path::new(env!("CARGO_MANIFEST_DIR")).join("testing/testdata")
+    }
+
+    pub fn read_testdata(path: &str) -> String {
+        fs::read_to_string(testdata_path().join(path)).expect(READ_ERROR)
+    }
+}

tests/extractors/html_test.rs

@@ -0,0 +1,33 @@
+use crate::common::{
+    constants::{TEST_BAR_SUBDOMAIN, TEST_BAZ_SUBDOMAIN, TEST_DOMAIN},
+    funcs::read_testdata,
+};
+use subscan::extractors::html::HTMLExtractor;
+use subscan::interfaces::extractor::SubdomainExtractorInterface;
+
+#[tokio::test]
+async fn extract_without_removes() {
+    let html = read_testdata("html/subdomains.html");
+
+    let selector = String::from("article > div > a > span:first-child");
+    let extractor = HTMLExtractor::new(selector, vec![]);
+    let result = extractor.extract(html, TEST_DOMAIN.to_string()).await;
+
+    assert_eq!(result, [TEST_BAR_SUBDOMAIN.to_string()].into());
+}
+
+#[tokio::test]
+async fn extract_with_removes() {
+    let html = read_testdata("html/subdomains-with-removes.html");
+
+    let selector = String::from("article > div > a > span");
+    let extractor = HTMLExtractor::new(selector, vec!["<br>".to_string()]);
+    let result = extractor.extract(html, TEST_DOMAIN.to_string()).await;
+
+    let expected = [
+        TEST_BAR_SUBDOMAIN.to_string(),
+        TEST_BAZ_SUBDOMAIN.to_string(),
+    ];
+
+    assert_eq!(result, expected.into());
+}

tests/extractors/main.rs

@@ -0,0 +1 @@
+automod::dir!("tests/extractors");

tests/extractors/regex_test.rs

@@ -0,0 +1,30 @@
+use crate::common::constants::{TEST_BAR_SUBDOMAIN, TEST_BAZ_SUBDOMAIN, TEST_DOMAIN};
+use subscan::extractors::regex::RegexExtractor;
+use subscan::interfaces::extractor::SubdomainExtractorInterface;
+
+#[tokio::test]
+async fn extract_one_test() {
+    let target = String::from(TEST_DOMAIN);
+    let extractor = RegexExtractor::default();
+
+    let matches = String::from(TEST_BAR_SUBDOMAIN);
+    let no_matches = String::from("foobarbaz");
+
+    assert!(extractor.extract_one(matches, target.clone()).is_some());
+    assert!(extractor.extract_one(no_matches, target).is_none());
+}
+
+#[tokio::test]
+async fn extract_test() {
+    let content = String::from("bar.foo.com\nbaz.foo.com");
+
+    let extractor = RegexExtractor::default();
+    let result = extractor.extract(content, TEST_DOMAIN.to_string()).await;
+
+    let expected = [
+        TEST_BAR_SUBDOMAIN.to_string(),
+        TEST_BAZ_SUBDOMAIN.to_string(),
+    ];
+
+    assert_eq!(result, expected.into());
+}

tests/common/mod.rs → tests/modules/common.rs

@@ -1,30 +1,11 @@
 pub mod constants {
-    #![allow(dead_code)]
-    pub const TEST_DOMAIN: &str = "foo.com";
-    pub const TEST_BAR_SUBDOMAIN: &str = "bar.foo.com";
-    pub const TEST_BAZ_SUBDOMAIN: &str = "baz.foo.com";
     pub const TEST_MODULE_NAME: &str = "foo-module";
     pub const TEST_URL: &str = "http://foo.com";
-}
-
-pub mod funcs {
-    #![allow(dead_code)]
-    use std::fs;
-    use std::path::{Path, PathBuf};
-
-    const READ_ERROR: &str = "Cannot read file!";
-
-    fn testdata_path() -> PathBuf {
-        Path::new(env!("CARGO_MANIFEST_DIR")).join("testing/testdata")
-    }
-
-    pub fn read_testdata(path: &str) -> String {
-        fs::read_to_string(testdata_path().join(path)).expect(READ_ERROR)
-    }
+    pub const TEST_DOMAIN: &str = "foo.com";
+    pub const TEST_BAR_SUBDOMAIN: &str = "bar.foo.com";
 }
 
 pub mod mocks {
-    #![allow(dead_code)]
     use super::constants::TEST_MODULE_NAME;
     use reqwest::Url;
     use subscan::{

tests/modules/engines/bing_test.rs

@@ -0,0 +1,16 @@
+use crate::common::constants::{TEST_BAR_SUBDOMAIN, TEST_DOMAIN};
+use reqwest::Url;
+use subscan::{interfaces::module::SubscanModuleInterface, modules::engines::bing};
+
+#[tokio::test]
+#[stubr::mock("module/engines/bing.json")]
+async fn bing_run_test() {
+    let mut bing = bing::Bing::new();
+
+    bing.url = Url::parse(stubr.path("/search").as_str()).unwrap();
+
+    let result = bing.run(TEST_DOMAIN.to_string()).await;
+
+    assert_eq!(bing.name().await, "Bing");
+    assert_eq!(result, [TEST_BAR_SUBDOMAIN.to_string()].into());
+}

tests/modules/engines/duckduckgo_test.rs

@@ -0,0 +1,20 @@
+use crate::common::constants::{TEST_BAR_SUBDOMAIN, TEST_DOMAIN};
+use reqwest::Url;
+use subscan::{
+    cache::requesters, enums::RequesterType, interfaces::module::SubscanModuleInterface,
+    modules::engines::duckduckgo,
+};
+
+#[tokio::test]
+#[stubr::mock("module/engines/duckduckgo.json")]
+async fn duckduckgo_run_test() {
+    let mut duckduckgo = duckduckgo::DuckDuckGo::new();
+
+    duckduckgo.requester = requesters::get_by_type(&RequesterType::HTTPClient);
+    duckduckgo.url = Url::parse(stubr.uri().as_str()).unwrap();
+
+    let result = duckduckgo.run(TEST_DOMAIN.to_string()).await;
+
+    assert_eq!(duckduckgo.name().await, "DuckDuckGo");
+    assert_eq!(result, [TEST_BAR_SUBDOMAIN.to_string()].into());
+}

tests/modules/engines/google_test.rs

@@ -0,0 +1,16 @@
+use crate::common::constants::{TEST_BAR_SUBDOMAIN, TEST_DOMAIN};
+use reqwest::Url;
+use subscan::{interfaces::module::SubscanModuleInterface, modules::engines::google};
+
+#[tokio::test]
+#[stubr::mock("module/engines/google.json")]
+async fn foo_test() {
+    let mut google = google::Google::new();
+
+    google.url = Url::parse(stubr.path("/search").as_str()).unwrap();
+
+    let result = google.run(TEST_DOMAIN.to_string()).await;
+
+    assert_eq!(google.name().await, "Google");
+    assert_eq!(result, [TEST_BAR_SUBDOMAIN.to_string()].into());
+}

tests/modules/engines/mod.rs

@@ -0,0 +1 @@
+automod::dir!("tests/modules/engines");