~ knotless Search/
↑↓ move↵ open⇧↵ all results

johnandersen777.bsky.social/vuln-notif

0
0
main
398 lines · 11.8 KB Raw History
//! Runtime reactor tests: cursor/backfill behavior, lifecycle events, and
//! terminal event payloads. No network is used; the NVD transport is scripted.

use std::collections::VecDeque;
use std::path::PathBuf;
use std::sync::{Arc, Mutex};
use std::time::Duration;

use async_trait::async_trait;
use chrono::{DateTime, Utc};
use serde_json::{Value, json};
use tokio::sync::mpsc;

use vuln_notif::config::{Order, ReleaseMode, RunConfig};
use vuln_notif::db::DbHandle;
use vuln_notif::links::LinkRepairCounters;
use vuln_notif::log::{CaptureSink, Level, Logger};
use vuln_notif::metrics::CycleStats;
use vuln_notif::nvd::{NvdClient, NvdResponse, NvdTransport};
use vuln_notif::publish::PublishStats;
use vuln_notif::runtime::MirrorRuntime;
use vuln_notif::runtime::actions::Action;
use vuln_notif::runtime::events::RuntimeEvent;
use vuln_notif::software::SoftwareCounters;
use vuln_notif::time::Time;

const BASE_URL: &str = "http://nvd.test/rest/json/cves/2.0";

struct FakeTime;

#[async_trait]
impl Time for FakeTime {
    fn now_unix(&self) -> f64 {
        1_800_000_000.0
    }

    fn now_utc(&self) -> DateTime<Utc> {
        DateTime::from_timestamp(1_800_000_000, 0).expect("timestamp")
    }

    async fn sleep(&self, _duration: Duration) {}

    fn jitter(&self, _scale: f64) -> f64 {
        0.0
    }
}

#[derive(Debug, Clone)]
struct Call {
    params: Vec<(String, String)>,
}

struct FakeTransport {
    script: Mutex<VecDeque<(u16, Value)>>,
    calls: Mutex<Vec<Call>>,
}

impl FakeTransport {
    fn new(script: Vec<(u16, Value)>) -> Arc<Self> {
        Arc::new(Self {
            script: Mutex::new(script.into()),
            calls: Mutex::new(Vec::new()),
        })
    }

    fn calls(&self) -> Vec<Call> {
        self.calls.lock().unwrap().clone()
    }
}

#[async_trait]
impl NvdTransport for FakeTransport {
    async fn get(
        &self,
        _url: &str,
        params: &[(&str, String)],
        _api_key: Option<&str>,
    ) -> anyhow::Result<NvdResponse> {
        self.calls.lock().unwrap().push(Call {
            params: params
                .iter()
                .map(|(key, value)| ((*key).to_owned(), value.clone()))
                .collect(),
        });
        let (status, body) = self
            .script
            .lock()
            .unwrap()
            .pop_front()
            .expect("unscripted NVD request");
        Ok(NvdResponse { status, body })
    }
}

fn config(cache_db: PathBuf, backfill: bool) -> RunConfig {
    RunConfig {
        once: false,
        dry_run: true,
        limit: 0,
        backfill,
        initial_lookback_days: 7,
        order: Order::Cache,
        publish_atproto: false,
        software_limit: 0,
        publish_releases: false,
        release_mode: ReleaseMode::Latest,
        release_limit: 0,
        release_recheck_seconds: 0.0,
        release_ecosystems: Vec::new(),
        release_sources: Vec::new(),
        release_history_limit: 0,
        release_concurrency: 1,
        release_source_url: None,
        artifact_max_bytes: 0,
        artifact_s3: None,
        github_token: None,
        gitlab_token: None,
        gitee_token: None,
        osv_online: false,
        osv_bulk_dir: None,
        purldb: PathBuf::new(),
        cache_db,
        poll_interval: 1.0,
        page_size: 8,
        concurrency: 2,
        pds_timeout: 1.0,
        nvd_api_key: None,
        require_nvd_key: false,
        pds_hourly_points: 5_000.0,
        pds_daily_points: 35_000.0,
        pds_requests_per_5min: 3_000.0,
        pds_url: None,
        handle: None,
        app_password: None,
        collection: "com.nahdig.cve.nvdV2".to_owned(),
        s3: None,
        debug: false,
        nvd_url: BASE_URL.to_owned(),
        plc_url: "http://plc.test".to_owned(),
    }
}

fn cve_page() -> Value {
    json!({
        "totalResults": 1,
        "vulnerabilities": [{ "cve": { "id": "CVE-2024-0001" } }],
    })
}

async fn seed_cursor(path: &std::path::Path, cursor: &str) {
    let db = DbHandle::open(path).await.expect("open db");
    db.set_cursor(cursor).await.expect("set cursor");
    db.commit().await.expect("commit cursor");
    db.close().await.expect("close db");
}

/// Run exactly one cycle, shutting the reactor down once the cycle ends.
async fn run_one_cycle(config: RunConfig, transport: Arc<FakeTransport>) -> Vec<RuntimeEvent> {
    let (actions_tx, actions_rx) = mpsc::channel(8);
    let (events_tx, mut events_rx) = mpsc::channel(128);
    let logger = Logger::new(Arc::new(CaptureSink::default()), Level::Error);
    let nvd = NvdClient::new(
        None,
        config.page_size,
        BASE_URL.to_owned(),
        Arc::new(FakeTime),
    )
    .with_transport(transport)
    .with_logger(logger.clone());
    let runtime = MirrorRuntime::new(config, actions_rx, events_tx, logger).with_nvd(nvd);

    let handle = tokio::spawn(runtime.run());
    let mut events = Vec::new();
    while let Some(event) = events_rx.recv().await {
        let stop = matches!(event, RuntimeEvent::Done);
        let cycle_done = matches!(
            event,
            RuntimeEvent::CycleCompleted { .. } | RuntimeEvent::CycleFailed { .. }
        );
        events.push(event);
        if cycle_done {
            let _ = actions_tx.send(Action::Shutdown).await;
        }
        if stop {
            break;
        }
    }
    handle.await.expect("runtime task");
    events
}

fn has_param(call: &Call, name: &str) -> bool {
    call.params.iter().any(|(key, _)| key == name)
}

#[tokio::test]
async fn backfill_ignores_an_existing_cursor() {
    let dir = tempfile::tempdir().expect("tempdir");
    let path = dir.path().join("cache.db");
    seed_cursor(&path, "2026-11-11T12:00:00.000").await;

    let transport =
        FakeTransport::new(vec![(200, json!({ "totalResults": 1 })), (200, cve_page())]);
    let events = run_one_cycle(config(path, true), transport.clone()).await;

    let calls = transport.calls();
    assert_eq!(calls.len(), 2, "probe plus one page");
    assert!(
        calls
            .iter()
            .all(|call| !has_param(call, "lastModStartDate")),
        "backfill must not filter by the stored cursor: {calls:?}"
    );

    let started = events
        .iter()
        .find_map(|event| match event {
            RuntimeEvent::CycleStarted { cursor, .. } => Some(cursor.clone()),
            _ => None,
        })
        .expect("cycle started");
    assert_eq!(started, None, "backfill starts from the beginning");

    let completed = events
        .iter()
        .find_map(|event| match event {
            RuntimeEvent::CycleCompleted { stats, .. } => Some(stats.clone()),
            _ => None,
        })
        .expect("cycle completed");
    assert_eq!(completed.cursor_before, None);
    assert_eq!(completed.nvd_cves, 1);
}

#[tokio::test]
async fn stored_cursor_is_used_without_backfill() {
    let dir = tempfile::tempdir().expect("tempdir");
    let path = dir.path().join("cache.db");
    seed_cursor(&path, "2026-11-11T12:00:00.000").await;

    let transport =
        FakeTransport::new(vec![(200, json!({ "totalResults": 1 })), (200, cve_page())]);
    let events = run_one_cycle(config(path, false), transport.clone()).await;

    let calls = transport.calls();
    assert!(
        calls.iter().any(|call| has_param(call, "lastModStartDate")),
        "incremental fetch filters by the stored cursor: {calls:?}"
    );
    let completed = events
        .iter()
        .find_map(|event| match event {
            RuntimeEvent::CycleCompleted { stats, .. } => Some(stats.clone()),
            _ => None,
        })
        .expect("cycle completed");
    assert_eq!(
        completed.cursor_before.as_deref(),
        Some("2026-11-11T12:00:00.000")
    );
}

#[tokio::test]
async fn lifecycle_events_are_emitted_with_stats() {
    let dir = tempfile::tempdir().expect("tempdir");
    let path = dir.path().join("cache.db");
    let transport =
        FakeTransport::new(vec![(200, json!({ "totalResults": 1 })), (200, cve_page())]);
    let events = run_one_cycle(config(path, true), transport).await;

    let nvd_started = events
        .iter()
        .find(|event| matches!(event, RuntimeEvent::NvdPhaseStarted { .. }))
        .expect("nvd_phase_started");
    assert_eq!(nvd_started.payload()["cursor"], Value::Null);

    let nvd_completed = events
        .iter()
        .find(|event| matches!(event, RuntimeEvent::NvdPhaseCompleted { .. }))
        .expect("nvd_phase_completed");
    let payload = nvd_completed.payload();
    assert_eq!(payload["cves"], 1);
    assert_eq!(payload["error"], Value::Null);
    assert!(payload["requests"].as_u64().unwrap_or(0) >= 2);

    let publish_started = events
        .iter()
        .find(|event| matches!(event, RuntimeEvent::PublishPhaseStarted { .. }))
        .expect("publish_phase_started");
    assert_eq!(publish_started.payload()["limit"], 0);
    assert!(
        events
            .iter()
            .any(|event| matches!(event, RuntimeEvent::PublishPhaseCompleted { .. }))
    );

    let repairs = events
        .iter()
        .find(|event| matches!(event, RuntimeEvent::LinkRepairCompleted { .. }))
        .expect("startup link repair drain");
    assert_eq!(repairs.payload()["phase"], "startup");

    let completed = events
        .iter()
        .find(|event| matches!(event, RuntimeEvent::CycleCompleted { .. }))
        .expect("cycle_completed");
    let payload = completed.payload();
    for key in [
        "software_cves",
        "software_created",
        "purl_created",
        "atproto_created",
        "software_failures",
        "publish_retried",
        "publish_retry_failed",
        "link_repair_attempted",
        "link_repair_repaired",
        "link_repair_failed",
        "link_repair_deferred",
    ] {
        assert!(payload.get(key).is_some(), "missing {key} in {payload}");
    }
}

#[test]
fn cycle_completed_payload_carries_full_stats() {
    let stats = CycleStats {
        cycle: 3,
        software_cves: 7,
        release_versions_created: 2,
        artifact_downloads: 9,
        ..CycleStats::default()
    };
    let event = RuntimeEvent::CycleCompleted {
        cycle: 3,
        duration: 1.5,
        stats: Box::new(stats),
    };
    let payload = event.payload();
    assert_eq!(payload["cycle"], 3);
    assert_eq!(payload["duration"], 1.5);
    assert_eq!(payload["software_cves"], 7);
    assert_eq!(payload["release_versions_created"], 2);
    assert_eq!(payload["artifact_downloads"], 9);
}

#[test]
fn cycle_failed_payload_carries_the_error() {
    let event = RuntimeEvent::CycleFailed {
        cycle: 4,
        error: "database closed".to_owned(),
    };
    let payload = event.payload();
    assert_eq!(payload["cycle"], 4);
    assert_eq!(payload["error"], "database closed");
}

#[test]
fn phase_completed_payloads_carry_stats_and_error() {
    let publish = RuntimeEvent::PublishPhaseCompleted {
        stats: PublishStats {
            created: 2,
            retried: 1,
            ..PublishStats::default()
        },
        error: Some("partial".to_owned()),
    };
    let payload = publish.payload();
    assert_eq!(payload["created"], 2);
    assert_eq!(payload["retried"], 1);
    assert_eq!(payload["error"], "partial");
    assert_eq!(publish.name(), "publish_phase_completed");

    let software = RuntimeEvent::SoftwarePhaseCompleted {
        stats: SoftwareCounters {
            cves: 5,
            ..SoftwareCounters::default()
        },
        error: None,
    };
    assert_eq!(software.payload()["cves"], 5);
    assert_eq!(software.payload()["error"], Value::Null);

    let repairs = RuntimeEvent::LinkRepairCompleted {
        phase: "publish",
        counters: LinkRepairCounters {
            attempted: 2,
            repaired: 2,
            ..LinkRepairCounters::default()
        },
        error: None,
    };
    let payload = repairs.payload();
    assert_eq!(payload["phase"], "publish");
    assert_eq!(payload["attempted"], 2);
    assert_eq!(payload["repaired"], 2);
    assert_eq!(payload["error"], Value::Null);
}