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

johnandersen777.bsky.social/vuln-notif

0
0
main
198 lines · 5.3 KB Raw History
use std::collections::VecDeque;
use std::path::Path;
use std::sync::Mutex;
use std::sync::atomic::{AtomicU64, Ordering};

use async_trait::async_trait;
use vuln_notif::config::S3Config;
use vuln_notif::s3::{S3ObjectSink, download_tmp_path, normalize_endpoint, upload_with};

#[derive(Clone)]
enum Step {
    Ok,
    Fail(String),
    Size(Option<u64>),
}

struct FakeSink {
    puts: AtomicU64,
    put_script: Mutex<VecDeque<Step>>,
    size_script: Mutex<VecDeque<Step>>,
}

impl FakeSink {
    fn new(put_script: Vec<Step>, size_script: Vec<Step>) -> Self {
        Self {
            puts: AtomicU64::new(0),
            put_script: Mutex::new(put_script.into()),
            size_script: Mutex::new(size_script.into()),
        }
    }

    fn puts(&self) -> u64 {
        self.puts.load(Ordering::Relaxed)
    }

    fn next(script: &Mutex<VecDeque<Step>>) -> Step {
        script.lock().unwrap().pop_front().unwrap_or(Step::Ok)
    }
}

#[async_trait]
impl S3ObjectSink for FakeSink {
    async fn put(&self, _cfg: &S3Config, _src: &Path) -> anyhow::Result<()> {
        self.puts.fetch_add(1, Ordering::Relaxed);
        match Self::next(&self.put_script) {
            Step::Fail(message) => Err(anyhow::anyhow!(message)),
            _ => Ok(()),
        }
    }

    async fn size(&self, _cfg: &S3Config, _key: &str) -> anyhow::Result<Option<u64>> {
        match Self::next(&self.size_script) {
            Step::Size(size) => Ok(size),
            Step::Fail(message) => Err(anyhow::anyhow!(message)),
            Step::Ok => Ok(None),
        }
    }
}

fn config() -> S3Config {
    S3Config {
        bucket: "test-bucket".to_owned(),
        path: "cache.db".to_owned(),
        ..S3Config::default()
    }
}

fn temp_file(bytes: usize) -> (tempfile::TempDir, std::path::PathBuf) {
    let dir = tempfile::tempdir().expect("tempdir");
    let path = dir.path().join("cache.db");
    std::fs::write(&path, vec![7u8; bytes]).expect("write temp file");
    (dir, path)
}

#[tokio::test]
async fn upload_retries_then_verifies_size() {
    let (_dir, path) = temp_file(128);
    let sink = FakeSink::new(
        vec![
            Step::Fail("transient".to_owned()),
            Step::Fail("transient".to_owned()),
            Step::Ok,
        ],
        vec![Step::Size(Some(128))],
    );
    let size = upload_with(&config(), &path, &sink)
        .await
        .expect("retries recover");
    assert_eq!(size, 128);
    assert_eq!(sink.puts(), 3);
}

#[tokio::test]
async fn upload_failure_is_bounded_and_propagated() {
    let (_dir, path) = temp_file(64);
    let sink = FakeSink::new(
        (0..10).map(|_| Step::Fail("s3 down".to_owned())).collect(),
        Vec::new(),
    );
    let error = upload_with(&config(), &path, &sink)
        .await
        .expect_err("final failure must propagate");
    let chain = format!("{error:#}");
    assert!(chain.contains("s3 down"), "{chain}");
    assert_eq!(sink.puts(), 4, "bounded attempts");
}

#[tokio::test]
async fn upload_retries_on_size_mismatch() {
    let (_dir, path) = temp_file(128);
    let sink = FakeSink::new(
        vec![Step::Ok, Step::Ok],
        vec![Step::Size(Some(1)), Step::Size(Some(128))],
    );
    upload_with(&config(), &path, &sink)
        .await
        .expect("second attempt verifies");
    assert_eq!(sink.puts(), 2);
}

#[tokio::test]
async fn upload_fails_after_persistent_size_mismatch() {
    let (_dir, path) = temp_file(128);
    let sink = FakeSink::new(
        (0..10).map(|_| Step::Ok).collect(),
        (0..10).map(|_| Step::Size(Some(1))).collect(),
    );
    let error = upload_with(&config(), &path, &sink)
        .await
        .expect_err("unverified snapshot must not be reported as uploaded");
    let chain = format!("{error:#}");
    assert!(chain.contains("size mismatch"), "{chain}");
    assert_eq!(sink.puts(), 4);
}

#[test]
fn strips_bucket_prefixed_digitalocean_host() {
    assert_eq!(
        normalize_endpoint("https://mybucket.nyc3.digitaloceanspaces.com", "mybucket"),
        "https://nyc3.digitaloceanspaces.com"
    );
}

#[test]
fn keeps_plain_endpoint_unchanged() {
    assert_eq!(
        normalize_endpoint("https://s3.us-east-1.amazonaws.com", "mybucket"),
        "https://s3.us-east-1.amazonaws.com"
    );
}

#[test]
fn preserves_port_and_path() {
    assert_eq!(
        normalize_endpoint("http://mybucket.127.0.0.1:9000/base/path/", "mybucket"),
        "http://127.0.0.1:9000/base/path/"
    );
}

#[test]
fn preserves_query_and_fragment() {
    assert_eq!(
        normalize_endpoint("https://mybucket.s3.example.com?x=1#frag", "mybucket"),
        "https://s3.example.com?x=1#frag"
    );
}

#[test]
fn keeps_endpoint_when_bucket_prefix_does_not_match() {
    assert_eq!(
        normalize_endpoint("https://other.s3.example.com", "mybucket"),
        "https://other.s3.example.com"
    );
}

#[test]
fn keeps_endpoint_without_scheme() {
    assert_eq!(
        normalize_endpoint("mybucket.s3.example.com", "mybucket"),
        "mybucket.s3.example.com"
    );
}

#[test]
fn download_temp_is_a_sibling_suffix() {
    assert_eq!(
        download_tmp_path(Path::new(".state/cache.db")),
        Path::new(".state/cache.db.download")
    );
    assert_eq!(
        download_tmp_path(Path::new("cache")),
        Path::new("cache.download")
    );
    assert_eq!(
        download_tmp_path(Path::new(".state/cache-v2.db")),
        Path::new(".state/cache-v2.db.download")
    );
}