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

johnandersen777.bsky.social/vuln-notif

0
0
main
515 lines · 15.1 KB Raw History
//! NVD parity tests: fixtures from `tests/fixtures/nvd`, scripted transport,
//! fake clock. No network and no real sleeps.

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

use async_trait::async_trait;
use chrono::{DateTime, Utc};
use serde_json::{Value, json};
use vuln_notif::log::{CaptureSink, Level, Logger};
use vuln_notif::nvd::{FetchResult, NvdClient, NvdResponse, NvdTransport, fetch_nvd};
use vuln_notif::time::Time;

const BASE_URL: &str = "http://nvd.test/rest/json/cves/2.0";
const BACKFILL_PAGE0: &str = include_str!("fixtures/nvd/backfill-page0.json");
const INCREMENTAL_PAGE0: &str = include_str!("fixtures/nvd/incremental-page0.json");
const INCREMENTAL_PAGE1: &str = include_str!("fixtures/nvd/incremental-page1.json");
const MALFORMED: &str = include_str!("fixtures/nvd/malformed.json");

struct FakeTime {
    now: Mutex<f64>,
    sleeps: Mutex<Vec<Duration>>,
}

impl FakeTime {
    fn new() -> Arc<Self> {
        let base = DateTime::parse_from_rfc3339("2026-11-11T12:05:00Z")
            .expect("valid base time")
            .timestamp() as f64;
        Arc::new(Self {
            now: Mutex::new(base),
            sleeps: Mutex::new(Vec::new()),
        })
    }

    fn sleeps_seconds(&self) -> Vec<f64> {
        self.sleeps
            .lock()
            .expect("sleeps")
            .iter()
            .map(Duration::as_secs_f64)
            .collect()
    }
}

#[async_trait]
impl Time for FakeTime {
    fn now_unix(&self) -> f64 {
        *self.now.lock().expect("clock")
    }

    fn now_utc(&self) -> DateTime<Utc> {
        DateTime::from_timestamp_millis((self.now_unix() * 1000.0).round() as i64)
            .expect("valid fake clock")
    }

    async fn sleep(&self, duration: Duration) {
        self.sleeps.lock().expect("sleeps").push(duration);
        *self.now.lock().expect("clock") += duration.as_secs_f64();
    }

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

#[derive(Clone)]
enum Scripted {
    Response { status: u16, body: Value },
    Error(String),
}

fn ok(body: Value) -> Scripted {
    Scripted::Response { status: 200, body }
}

fn status(status: u16, body: Value) -> Scripted {
    Scripted::Response { status, body }
}

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

struct FakeTransport {
    script: Mutex<VecDeque<Scripted>>,
    calls: Mutex<Vec<Call>>,
}

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

    fn calls(&self) -> Vec<Call> {
        self.calls.lock().expect("calls").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().expect("calls").push(Call {
            url: url.to_owned(),
            params: params
                .iter()
                .map(|(key, value)| ((*key).to_owned(), value.clone()))
                .collect(),
            api_key: api_key.map(str::to_owned),
        });
        let next = self
            .script
            .lock()
            .expect("script")
            .pop_front()
            .expect("unscripted NVD request");
        match next {
            Scripted::Response { status, body } => Ok(NvdResponse { status, body }),
            Scripted::Error(message) => Err(anyhow::anyhow!(message)),
        }
    }
}

fn fixture(raw: &str) -> Value {
    serde_json::from_str(raw).expect("valid fixture")
}

fn params(pairs: &[(&str, &str)]) -> Vec<(String, String)> {
    pairs
        .iter()
        .map(|(key, value)| ((*key).to_owned(), (*value).to_owned()))
        .collect()
}

fn make_client(
    time: Arc<FakeTime>,
    transport: Arc<FakeTransport>,
    api_key: Option<&str>,
    page_size: usize,
    logger: Option<Logger>,
) -> NvdClient {
    let client = NvdClient::new(
        api_key.map(str::to_owned),
        page_size,
        BASE_URL.to_owned(),
        time,
    )
    .with_transport(transport);
    match logger {
        Some(logger) => client.with_logger(logger),
        None => client,
    }
}

fn events(lines: &[String], name: &str) -> Vec<Value> {
    lines
        .iter()
        .filter_map(|line| serde_json::from_str::<Value>(line).ok())
        .filter(|value| value["event"] == name)
        .collect()
}

async fn backfill(
    time: Arc<FakeTime>,
    transport: Arc<FakeTransport>,
    api_key: Option<&str>,
    page_size: usize,
    logger: Option<Logger>,
) -> anyhow::Result<FetchResult> {
    let client = make_client(time, transport, api_key, page_size, logger);
    fetch_nvd(&client, None).await
}

#[tokio::test]
async fn unwrap_dedupes_and_skips_malformed() {
    let time = FakeTime::new();
    let sink = Arc::new(CaptureSink::default());
    let logger = Logger::new(sink.clone(), Level::Debug).with_target("nvd");
    let transport = FakeTransport::new(vec![
        ok(json!({ "totalResults": 8 })),
        ok(fixture(MALFORMED)),
    ]);

    let result = backfill(time, transport, None, 8, Some(logger))
        .await
        .expect("fetch succeeds");

    assert_eq!(result.cves.len(), 1);
    assert_eq!(result.cves[0]["id"], "CVE-2024-3094");
    assert_eq!(
        result.cves[0]["descriptions"][0]["value"],
        "Valid record retained by _unwrap."
    );

    let skipped = events(&sink.lines(), "nvd_entry_skipped");
    assert_eq!(skipped.len(), 6, "one warning per malformed entry");
    for event in skipped {
        let entry = event["entry"].as_str().expect("entry field");
        assert!(entry.chars().count() <= 200, "entry must be truncated");
    }
}

#[tokio::test]
async fn backfill_probe_and_page_zero() {
    let time = FakeTime::new();
    let transport = FakeTransport::new(vec![
        ok(json!({ "totalResults": 4 })),
        ok(fixture(BACKFILL_PAGE0)),
    ]);

    let result = backfill(time.clone(), transport.clone(), None, 4, None)
        .await
        .expect("fetch succeeds");

    assert_eq!(result.cves.len(), 4);
    assert_eq!(result.requests, 2);
    assert_eq!(result.cursor, "2026-11-11T12:05:00.000");

    let calls = transport.calls();
    assert_eq!(calls.len(), 2);
    assert_eq!(calls[0].url, BASE_URL);
    assert_eq!(
        calls[0].params,
        params(&[("startIndex", "0"), ("resultsPerPage", "1")])
    );
    assert!(
        !calls[0]
            .params
            .iter()
            .any(|(key, _)| key.starts_with("lastMod"))
    );
    assert_eq!(
        calls[1].params,
        params(&[("startIndex", "0"), ("resultsPerPage", "4")])
    );
    assert!(
        !calls[1]
            .params
            .iter()
            .any(|(key, _)| key.starts_with("lastMod"))
    );
}

fn incremental_transport() -> Arc<FakeTransport> {
    FakeTransport::new(vec![
        ok(json!({ "totalResults": 5 })),
        ok(fixture(INCREMENTAL_PAGE0)),
        ok(fixture(INCREMENTAL_PAGE1)),
    ])
}

#[tokio::test]
async fn incremental_page0_has_date_params_and_pages_continue() {
    let time = FakeTime::new();
    let transport = incremental_transport();
    let client = make_client(time, transport.clone(), None, 3, None);

    let result = fetch_nvd(&client, Some("2026-11-11T12:00:00.000"))
        .await
        .expect("fetch succeeds");

    assert_eq!(result.requests, 3);
    assert_eq!(result.cves.len(), 5);

    let calls = transport.calls();
    assert_eq!(calls.len(), 3);
    assert_eq!(
        calls[0].params,
        params(&[("startIndex", "0"), ("resultsPerPage", "1")])
    );
    assert_eq!(
        calls[1].params,
        params(&[
            ("startIndex", "0"),
            ("resultsPerPage", "3"),
            ("lastModStartDate", "2026-11-11T11:58:00.000"),
            ("lastModEndDate", "2026-11-11T12:05:00.000"),
        ])
    );
    assert_eq!(
        calls[2].params,
        params(&[
            ("startIndex", "3"),
            ("resultsPerPage", "3"),
            ("lastModStartDate", "2026-11-11T11:58:00.000"),
            ("lastModEndDate", "2026-11-11T12:05:00.000"),
        ])
    );
}

#[tokio::test]
async fn pagination_is_contiguous_from_incremental_pages() {
    let time = FakeTime::new();
    let transport = incremental_transport();
    let client = make_client(time, transport.clone(), None, 3, None);

    let result = fetch_nvd(&client, Some("2026-11-11T12:00:00.000"))
        .await
        .expect("fetch succeeds");

    let calls = transport.calls();
    let starts: Vec<&str> = calls
        .iter()
        .map(|call| {
            call.params
                .iter()
                .find(|(key, _)| key == "startIndex")
                .map(|(_, value)| value.as_str())
                .expect("startIndex")
        })
        .collect();
    assert_eq!(starts, ["0", "0", "3"]);

    let ids: Vec<&str> = result
        .cves
        .iter()
        .map(|cve| cve["id"].as_str().expect("cve id"))
        .collect();
    assert_eq!(
        ids,
        [
            "CVE-2024-3400",
            "CVE-2024-21762",
            "CVE-2023-44487",
            "CVE-2024-6387",
            "CVE-2024-1086"
        ]
    );
}

#[tokio::test]
async fn post_success_sleep_is_six_seconds_without_key() {
    let time = FakeTime::new();
    let transport = FakeTransport::new(vec![
        ok(json!({ "totalResults": 4 })),
        ok(fixture(BACKFILL_PAGE0)),
    ]);

    backfill(time.clone(), transport, None, 4, None)
        .await
        .expect("fetch succeeds");

    assert_eq!(time.sleeps_seconds(), vec![6.0]);
}

#[tokio::test]
async fn post_success_sleep_is_one_second_with_key() {
    let time = FakeTime::new();
    let transport = FakeTransport::new(vec![
        ok(json!({ "totalResults": 4 })),
        ok(fixture(BACKFILL_PAGE0)),
    ]);

    backfill(time.clone(), transport.clone(), Some("secret-key"), 4, None)
        .await
        .expect("fetch succeeds");

    assert_eq!(time.sleeps_seconds(), vec![1.0]);
    assert!(
        transport
            .calls()
            .iter()
            .all(|call| call.api_key.as_deref() == Some("secret-key"))
    );
}

#[tokio::test]
async fn page_transport_failures_are_bounded_with_backoff() {
    let time = FakeTime::new();
    let transport = FakeTransport::new(vec![
        ok(json!({ "totalResults": 4 })),
        Scripted::Error("boom".to_owned()),
        Scripted::Error("boom".to_owned()),
        Scripted::Error("boom".to_owned()),
        Scripted::Error("boom".to_owned()),
        Scripted::Error("boom".to_owned()),
    ]);

    let error = backfill(time.clone(), transport.clone(), None, 4, None)
        .await
        .expect_err("page retries are bounded");

    assert!(error.to_string().contains("after 5 attempts"), "{error}");
    assert_eq!(transport.calls().len(), 6, "probe plus five page attempts");
    assert_eq!(time.sleeps_seconds(), vec![30.0, 60.0, 120.0, 300.0]);
}

#[tokio::test]
async fn non_200_pages_are_bounded_with_backoff() {
    let time = FakeTime::new();
    let sink = Arc::new(CaptureSink::default());
    let logger = Logger::new(sink.clone(), Level::Debug).with_target("nvd");
    let transport = FakeTransport::new(vec![
        ok(json!({ "totalResults": 4 })),
        status(500, Value::Null),
        status(500, Value::Null),
        status(500, Value::Null),
        status(500, Value::Null),
        status(500, Value::Null),
    ]);

    let error = backfill(time.clone(), transport.clone(), None, 4, Some(logger))
        .await
        .expect_err("non-200 page retries are bounded");

    assert!(error.to_string().contains("HTTP 500"), "{error}");
    assert!(error.to_string().contains("after 5 attempts"), "{error}");
    assert_eq!(
        transport.calls().len(),
        6,
        "no unbounded page loop and no outer retry for a typed failure"
    );
    assert_eq!(time.sleeps_seconds(), vec![30.0, 60.0, 120.0, 300.0]);
    assert_eq!(events(&sink.lines(), "nvd_page_retry").len(), 4);
}

#[tokio::test]
async fn outer_retry_delays_and_counts() {
    let time = FakeTime::new();
    let sink = Arc::new(CaptureSink::default());
    let logger = Logger::new(sink.clone(), Level::Debug).with_target("nvd");
    let transport = FakeTransport::new(vec![
        Scripted::Error("connection reset".to_owned()),
        Scripted::Error("connection reset".to_owned()),
        ok(json!({ "totalResults": 0 })),
    ]);

    let result = backfill(time.clone(), transport, None, 4, Some(logger))
        .await
        .expect("fetch succeeds after retries");

    assert_eq!(result.retries, 2);
    assert_eq!(result.requests, 1, "counts reset per attempt");
    assert!(result.cves.is_empty());
    assert_eq!(time.sleeps_seconds(), vec![30.0, 60.0]);

    let retries = events(&sink.lines(), "nvd_retry");
    assert_eq!(retries.len(), 2);
    assert_eq!(retries[0]["attempt"], 1);
    assert_eq!(retries[1]["attempt"], 2);
    assert_eq!(retries[0]["error"], "ClientError");
    assert_eq!(retries[0]["sleep_seconds"], 30.0);
    assert_eq!(retries[1]["sleep_seconds"], 60.0);
}

#[tokio::test]
async fn probe_403_is_rate_limited_and_retried_five_times() {
    let time = FakeTime::new();
    let sink = Arc::new(CaptureSink::default());
    let logger = Logger::new(sink.clone(), Level::Debug).with_target("nvd");
    let transport = FakeTransport::new(vec![
        status(403, json!({ "error": "rate limited" })),
        status(403, json!({ "error": "rate limited" })),
        status(403, json!({ "error": "rate limited" })),
        status(403, json!({ "error": "rate limited" })),
        status(403, json!({ "error": "rate limited" })),
    ]);

    let error = backfill(time.clone(), transport.clone(), None, 4, Some(logger))
        .await
        .expect_err("403 is fatal after five attempts");

    assert!(error.to_string().contains("403"), "{error}");
    assert_eq!(transport.calls().len(), 5);
    assert_eq!(time.sleeps_seconds(), vec![30.0, 60.0, 120.0, 300.0]);
    let retries = events(&sink.lines(), "nvd_retry");
    assert_eq!(retries.len(), 4);
    assert!(
        retries.iter().all(|event| event["error"] == "NVDRateLimit"),
        "{retries:?}"
    );
}

#[tokio::test]
async fn api_key_never_appears_in_logs_and_error_body_drops_it() {
    const SECRET: &str = "nvd-secret-key-123";
    let time = FakeTime::new();
    let sink = Arc::new(CaptureSink::default());
    let logger = Logger::new(sink.clone(), Level::Debug).with_target("nvd");
    let transport = FakeTransport::new(vec![
        ok(json!({ "error": "invalid api key" })),
        ok(json!({ "totalResults": 0 })),
    ]);

    let result = backfill(time, transport.clone(), Some(SECRET), 4, Some(logger))
        .await
        .expect("retries the probe without the key");

    assert!(result.cves.is_empty());
    let calls = transport.calls();
    assert_eq!(calls.len(), 2);
    assert_eq!(calls[0].api_key.as_deref(), Some(SECRET));
    assert_eq!(calls[1].api_key, None, "probe retried without apiKey");

    let lines = sink.lines();
    assert!(
        !lines.iter().any(|line| line.contains(SECRET)),
        "secret leaked into logs"
    );
    let configured = events(&lines, "nvd_api_key_configured");
    assert_eq!(configured.len(), 1);
    assert_eq!(configured[0]["configured"], true);
}