increased test coverage for main

.github/workflows/coverage.yml

@@ -3,7 +3,7 @@ on: [push]
 name: Code Coverage Pipeline
 
 jobs:
-  lint:
+  upload-coverage:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v1

src/main.rs

@@ -1,6 +1,6 @@
 use feroxbuster::config::{CONFIGURATION, PROGRESS_PRINTER};
 use feroxbuster::scanner::scan_url;
-use feroxbuster::utils::{get_current_depth, module_colorizer, status_colorizer};
+use feroxbuster::utils::{ferox_print, get_current_depth, module_colorizer, status_colorizer};
 use feroxbuster::{banner, heuristics, logger, FeroxResult};
 use futures::StreamExt;
 use std::collections::HashSet;
@@ -36,20 +36,14 @@ fn get_unique_words_from_wordlist(path: &str) -> FeroxResult<Arc<HashSet<String>
     let mut words = HashSet::new();
 
     for line in reader.lines() {
-        match line {
-            Ok(word) => {
-                words.insert(word);
-            }
-            Err(e) => {
-                log::warn!("Could not parse current line from wordlist : {}", e);
-            }
-        }
+        words.insert(line?);
     }
 
     log::trace!(
         "exit: get_unique_words_from_wordlist -> Arc<wordlist[{} words...]>",
         words.len()
     );
+
     Ok(Arc::new(words))
 }
 
@@ -93,7 +87,7 @@ async fn scan(targets: Vec<String>) -> FeroxResult<()> {
     Ok(())
 }
 
-async fn get_targets() -> Vec<String> {
+async fn get_targets() -> FeroxResult<Vec<String>> {
     log::trace!("enter: get_targets");
 
     let mut targets = vec![];
@@ -105,14 +99,7 @@ async fn get_targets() -> Vec<String> {
         let mut reader = FramedRead::new(stdin, LinesCodec::new());
 
         while let Some(line) = reader.next().await {
-            match line {
-                Ok(target) => {
-                    targets.push(target);
-                }
-                Err(e) => {
-                    log::error!("{}", e);
-                }
-            }
+            targets.push(line?);
         }
     } else {
         targets.push(CONFIGURATION.target_url.clone());
@@ -120,7 +107,7 @@ async fn get_targets() -> Vec<String> {
 
     log::trace!("exit: get_targets -> {:?}", targets);
 
-    targets
+    Ok(targets)
 }
 
 #[tokio::main]
@@ -131,7 +118,23 @@ async fn main() {
     log::debug!("{:#?}", *CONFIGURATION);
 
     // get targets from command line or stdin
-    let targets = get_targets().await;
+    let targets = match get_targets().await {
+        Ok(t) => t,
+        Err(e) => {
+            // should only happen in the event that there was an error reading from stdin
+            log::error!("{}", e);
+            ferox_print(
+                &format!(
+                    "{} {} {}",
+                    status_colorizer("ERROR"),
+                    module_colorizer("main::get_targets"),
+                    e
+                ),
+                &PROGRESS_PRINTER,
+            );
+            process::exit(1);
+        }
+    };
 
     if !CONFIGURATION.quiet {
         // only print banner if -q isn't used

tests/test_main.rs

@@ -1,8 +1,9 @@
-pub mod utils;
+mod utils;
 use assert_cmd::Command;
 use httpmock::Method::GET;
 use httpmock::{Mock, MockServer};
 use predicates::prelude::*;
+use utils::{setup_tmp_directory, teardown_tmp_directory};
 
 #[test]
 /// send the function a file to which we dont have permission in order to execute error branch
@@ -33,3 +34,65 @@ fn main_use_root_owned_file_as_wordlist() -> Result<(), Box<dyn std::error::Erro
     assert_eq!(mock.times_called(), 1);
     Ok(())
 }
+
+#[test]
+/// send the function an empty file
+fn main_use_empty_wordlist() -> Result<(), Box<dyn std::error::Error>> {
+    let srv = MockServer::start();
+    let (tmp_dir, file) = setup_tmp_directory(&[])?;
+
+    let mock = Mock::new()
+        .expect_method(GET)
+        .expect_path("/")
+        .return_status(200)
+        .return_body("this is a test")
+        .create_on(&srv);
+
+    Command::cargo_bin("feroxbuster")
+        .unwrap()
+        .arg("--url")
+        .arg(srv.url("/"))
+        .arg("--wordlist")
+        .arg(file.as_os_str())
+        .arg("-vvvv")
+        .assert()
+        .failure()
+        .stderr(predicate::str::contains(
+            "ERROR main::scan Did not find any words in",
+        ));
+
+    assert_eq!(mock.times_called(), 1);
+
+    teardown_tmp_directory(tmp_dir);
+    Ok(())
+}
+
+#[test]
+/// send nothing over stdin, expect heuristics to be upset during connectivity test
+fn main_use_empty_stdin_targets() -> Result<(), Box<dyn std::error::Error>> {
+    let (tmp_dir, file) = setup_tmp_directory(&[])?;
+
+    // get_targets is called before scan, so the empty wordlist shouldn't trigger
+    // the 'Did not find any words' error
+    Command::cargo_bin("feroxbuster")
+        .unwrap()
+        .arg("--stdin")
+        .arg("--wordlist")
+        .arg(file.as_os_str())
+        .arg("-vvv")
+        .pipe_stdin(file)
+        .unwrap()
+        .assert()
+        .failure()
+        .stderr(
+            predicate::str::contains("Could not connect to any target provided")
+                .and(predicate::str::contains("ERROR"))
+                .and(predicate::str::contains("heuristics::connectivity_test"))
+                .and(predicate::str::contains("Target Url"))
+                .not(), // no target url found
+        );
+
+    teardown_tmp_directory(tmp_dir);
+
+    Ok(())
+}