updated tests

src/scanner/runner.rs

@@ -4,7 +4,6 @@ use std::{
 };
 
 use anyhow::{bail, Context, Result};
-use chrono::Local;
 use crossbeam_skiplist::SkipMap;
 use indicatif::ProgressBar;
 use tokio::time::{Duration, Instant};

src/update.rs

@@ -50,6 +50,19 @@ pub struct UpdateStatus {
     pub check_status: UpdateCheckStatus,
 }
 
+impl Default for UpdateStatus {
+    fn default() -> Self {
+        UpdateStatus {
+            message: None,
+            styled_message: None,
+            is_outdated: false,
+            running_version: cargo_crate_version!().to_string(),
+            latest_version: None,
+            check_status: UpdateCheckStatus::Disabled,
+        }
+    }
+}
+
 fn styled_heading(styles: &Styles, text: &str) -> String {
     styles.style_finding_active_heading.apply_to(text).to_string()
 }

tests/int_allowlist.rs

@@ -24,6 +24,7 @@ use kingfisher::{
     rule_loader::RuleLoader,
     rules_database::RulesDatabase,
     scanner::run_async_scan,
+    update::UpdateStatus,
 };
 use tempfile::TempDir;
 use tokio::runtime::Runtime;
@@ -165,10 +166,17 @@ fn run_skiplist(skip_regex: Vec<String>, skip_skipword: Vec<String>) -> Result<u
     let loaded = RuleLoader::from_rule_specifiers(&scan_args.rules).load(&scan_args)?;
     let resolved = loaded.resolve_enabled_rules()?;
     let rules_db = Arc::new(RulesDatabase::from_rules(resolved.into_iter().cloned().collect())?);
+    let update_status = UpdateStatus::default();
 
     let datastore = Arc::new(Mutex::new(FindingsStore::new(work.path().join("store"))));
 
-    rt.block_on(run_async_scan(&global_args, &scan_args, Arc::clone(&datastore), &rules_db))?;
+    rt.block_on(run_async_scan(
+        &global_args,
+        &scan_args,
+        Arc::clone(&datastore),
+        &rules_db,
+        &update_status,
+    ))?;
 
     let x = Ok(datastore.lock().unwrap().get_matches().len());
     x

tests/int_bitbucket.rs

@@ -23,6 +23,7 @@ use kingfisher::{
     findings_store::FindingsStore,
     git_url::GitUrl,
     scanner::{load_and_record_rules, run_scan},
+    update::UpdateStatus,
 };
 use tempfile::TempDir;
 use tokio::runtime::Runtime;
@@ -165,9 +166,10 @@ fn test_bitbucket_remote_scan() -> Result<()> {
     let datastore = Arc::new(Mutex::new(FindingsStore::new(clone_dir)));
     let runtime = Runtime::new()?;
     let rules_db = Arc::new(load_and_record_rules(&scan_args, &datastore)?);
+    let update_status = UpdateStatus::default();
 
     runtime.block_on(async {
-        run_scan(&global_args, &scan_args, &rules_db, Arc::clone(&datastore)).await
+        run_scan(&global_args, &scan_args, &rules_db, Arc::clone(&datastore), &update_status).await
     })?;
 
     let ds = datastore.lock().unwrap();

tests/int_dedup.rs

@@ -28,6 +28,7 @@ use kingfisher::{
     rule_loader::RuleLoader,
     rules_database::RulesDatabase,
     scanner::run_async_scan,
+    update::UpdateStatus,
 };
 use tempfile::TempDir;
 use tokio::runtime::Runtime;
@@ -186,6 +187,7 @@ rules:
     let loaded = RuleLoader::from_rule_specifiers(&scan_args.rules).load(&scan_args)?;
     let resolved = loaded.resolve_enabled_rules()?;
     let rules_db = Arc::new(RulesDatabase::from_rules(resolved.into_iter().cloned().collect())?);
+    let update_status = UpdateStatus::default();
 
     // Fresh FindingsStore for this run
     let store_path = work.path().join("store");
@@ -198,6 +200,7 @@ rules:
         &scan_args,
         Arc::clone(&datastore),
         &rules_db,
+        &update_status,
     ))?;
 
     let x = Ok(datastore.lock().unwrap().get_matches().len());

tests/int_github.rs

@@ -24,6 +24,7 @@ use kingfisher::{
     findings_store::FindingsStore,
     git_url::GitUrl,
     scanner::{load_and_record_rules, run_scan},
+    update::UpdateStatus,
 };
 use tempfile::TempDir;
 use tokio::runtime::Runtime;
@@ -174,9 +175,10 @@ fn test_github_remote_scan() -> Result<()> {
     let runtime = Runtime::new().expect("Failed to create Tokio runtime");
     // Load rules
     let rules_db = Arc::new(load_and_record_rules(&scan_args, &datastore)?);
+    let update_status = UpdateStatus::default();
     // Run the scan using runtime.block_on
     runtime.block_on(async {
-        run_scan(&global_args, &scan_args, &rules_db, Arc::clone(&datastore)).await
+        run_scan(&global_args, &scan_args, &rules_db, Arc::clone(&datastore), &update_status).await
     })?;
     // Get scan results
     let ds = datastore.lock().unwrap();

tests/int_gitlab.rs

@@ -24,6 +24,7 @@ use kingfisher::{
     findings_store::FindingsStore,
     git_url::GitUrl,
     scanner::{load_and_record_rules, run_scan},
+    update::UpdateStatus,
 };
 use tempfile::TempDir;
 use tokio::runtime::Runtime;
@@ -171,9 +172,10 @@ fn test_gitlab_remote_scan() -> Result<()> {
     let rt = Runtime::new()?;
 
     let rules_db = Arc::new(load_and_record_rules(&scan_args, &datastore)?);
+    let update_status = UpdateStatus::default();
 
     rt.block_on(async {
-        run_scan(&global_args, &scan_args, &rules_db, Arc::clone(&datastore)).await
+        run_scan(&global_args, &scan_args, &rules_db, Arc::clone(&datastore), &update_status).await
     })?;
 
     let ds = datastore.lock().unwrap();
@@ -323,9 +325,10 @@ fn test_gitlab_remote_scan_no_history() -> Result<()> {
     let rt = Runtime::new()?;
 
     let rules_db = Arc::new(load_and_record_rules(&scan_args, &datastore)?);
+    let update_status = UpdateStatus::default();
 
     rt.block_on(async {
-        run_scan(&global_args, &scan_args, &rules_db, Arc::clone(&datastore)).await
+        run_scan(&global_args, &scan_args, &rules_db, Arc::clone(&datastore), &update_status).await
     })?;
 
     let ds = datastore.lock().unwrap();

tests/int_redact.rs

@@ -24,6 +24,7 @@ use kingfisher::{
     rule_loader::RuleLoader,
     rules_database::RulesDatabase,
     scanner::run_async_scan,
+    update::UpdateStatus,
 };
 use tempfile::TempDir;
 use url::Url;
@@ -148,9 +149,11 @@ async fn test_redact_hashes_finding_values() -> Result<()> {
     let loaded = RuleLoader::from_rule_specifiers(&scan_args.rules).load(&scan_args)?;
     let resolved = loaded.resolve_enabled_rules()?;
     let rules_db = RulesDatabase::from_rules(resolved.into_iter().cloned().collect())?;
+    let update_status = UpdateStatus::default();
 
     let datastore = Arc::new(Mutex::new(FindingsStore::new(temp_dir.path().to_path_buf())));
-    run_async_scan(&global_args, &scan_args, Arc::clone(&datastore), &rules_db).await?;
+    run_async_scan(&global_args, &scan_args, Arc::clone(&datastore), &rules_db, &update_status)
+        .await?;
 
     let ds = datastore.lock().unwrap();
     let matches = ds.get_matches();

tests/int_slack.rs

@@ -24,6 +24,7 @@ use kingfisher::{
     rule_loader::RuleLoader,
     rules_database::RulesDatabase,
     scanner::run_async_scan,
+    update::UpdateStatus,
 };
 use tempfile::TempDir;
 use url::Url;
@@ -294,8 +295,10 @@ async fn test_scan_slack_messages() -> Result<()> {
     };
 
     let datastore = Arc::new(Mutex::new(FindingsStore::new(clone_dir)));
+    let update_status = UpdateStatus::default();
 
-    run_async_scan(&global_args, &scan_args, Arc::clone(&datastore), &ctx.rules_db).await?;
+    run_async_scan(&global_args, &scan_args, Arc::clone(&datastore), &ctx.rules_db, &update_status)
+        .await?;
 
     let findings = {
         let ds = datastore.lock().unwrap();

tests/int_validation_cache.rs

@@ -28,6 +28,7 @@ use kingfisher::{
     rule_loader::RuleLoader,
     rules_database::RulesDatabase,
     scanner::run_async_scan,
+    update::UpdateStatus,
 };
 use tempfile::TempDir;
 use url::Url;
@@ -242,8 +243,10 @@ async fn test_validation_cache_and_depvars() -> Result<()> {
         ignore_certs: false,
         user_agent_suffix: None,
     };
+    let update_status = UpdateStatus::default();
 
-    run_async_scan(&global_args, &scan_args, Arc::clone(&datastore), &rules_db).await?;
+    run_async_scan(&global_args, &scan_args, Arc::clone(&datastore), &rules_db, &update_status)
+        .await?;
 
     /* --------------------------------------------------------- *
      * 6. Assertions                                             *

tests/int_vulnerable_files.rs

@@ -26,6 +26,7 @@ use kingfisher::{
     rule_loader::RuleLoader,
     rules_database::RulesDatabase,
     scanner::run_async_scan,
+    update::UpdateStatus,
 };
 use tempfile::TempDir;
 use url::Url;
@@ -297,8 +298,16 @@ impl TestContext {
         };
 
         let datastore = Arc::new(Mutex::new(FindingsStore::new(clone_dir)));
+        let update_status = UpdateStatus::default();
 
-        run_async_scan(&global_args, &scan_args, Arc::clone(&datastore), &self.rules_db).await?;
+        run_async_scan(
+            &global_args,
+            &scan_args,
+            Arc::clone(&datastore),
+            &self.rules_db,
+            &update_status,
+        )
+        .await?;
 
         let findings = {
             let ds = datastore.lock().unwrap();

tests/live_db_validation.rs

@@ -17,7 +17,6 @@ const STARTUP_POLL_INTERVAL: Duration = Duration::from_millis(250);
 
 async fn wait_for_port(host: &str, port: u16) -> Result<()> {
     let deadline = Instant::now() + STARTUP_TIMEOUT;
-    let mut last_err = None;
 
     loop {
         match TcpStream::connect((host, port)).await {
@@ -26,10 +25,9 @@ async fn wait_for_port(host: &str, port: u16) -> Result<()> {
                 return Ok(());
             }
             Err(err) => {
-                last_err = Some(err);
                 if Instant::now() >= deadline {
                     return Err(anyhow!(
-                        "timed out after {:?} waiting for {host}:{port}: {last_err:?}",
+                        "timed out after {:?} waiting for {host}:{port}: {err}",
                         STARTUP_TIMEOUT,
                     ));
                 }

tests/smoke_update.rs

@@ -44,5 +44,9 @@ async fn detects_new_release() {
     .expect("blocking task panicked");
 
     assert!(status.is_outdated);
-    assert!(status.message.contains("99.999.0"));
+    assert!(status
+        .message
+        .as_deref()
+        .expect("update check should return a message")
+        .contains("99.999.0"));
 }