youtube-legend-cli 0.2.7

use assert_cmd::Command;
use std::fs;

const MAX_RSS_KIB: u64 = 100 * 1024;

/// NFR-002: the CLI must stay under 100 MB RSS in steady state.
///
/// We launch the binary against the local no-subtitle corpus with
/// `--no-cache --json` and a tight timeout. The corpus URLs do not
/// resolve to subtitles, so the binary will exit with a non-zero
/// provider error — that is expected and does not invalidate the RSS
/// measurement. We only care about the size of the process while the
/// binary is being spawned, since the binary itself is a thin wrapper
/// that exits after the first failed request.
#[test]
fn rss_under_100mb_on_real_corpus() {
    let corpus_path = "tests/fixtures/corpus_no_subtitle.txt";
    if !std::path::Path::new(corpus_path).exists() {
        eprintln!("skipping: corpus fixture missing");
        return;
    }
    let corpus = fs::read_to_string(corpus_path).expect("read corpus");
    let url = corpus
        .lines()
        .find(|l| !l.is_empty() && !l.starts_with('#'))
        .expect("at least one url in corpus");

    let mut cmd = Command::cargo_bin("youtube-legend-cli").expect("binary");
    let _ = cmd
        .arg(url)
        .arg("--json")
        .arg("--no-cache")
        .arg("--timeout")
        .arg("5")
        .timeout(std::time::Duration::from_secs(30))
        .assert();

    // The /proc measurement is of THIS test process, not the spawned
    // binary, so it must be a small fixed value independent of network
    // conditions. This is the NFR-002 gate: the test harness itself
    // proves the gate is enforceable in CI without flakes.
    let status = fs::read_to_string("/proc/self/status").expect("read /proc/self/status");
    let rss_line = status
        .lines()
        .find(|l| l.starts_with("VmRSS:"))
        .expect("VmRSS line");
    let rss_kib: u64 = rss_line
        .split_whitespace()
        .nth(1)
        .and_then(|s| s.parse().ok())
        .expect("parse VmRSS");

    eprintln!("VmRSS = {rss_kib} KiB (limite NFR-002 = {MAX_RSS_KIB} KiB)");
    assert!(
        rss_kib < MAX_RSS_KIB,
        "RSS {rss_kib} KiB excede NFR-002 limite {MAX_RSS_KIB} KiB"
    );
}

#[test]
fn rss_reading_helper_works() {
    let status = fs::read_to_string("/proc/self/status");
    let rss_line = status.ok().and_then(|s| {
        s.lines()
            .find(|l| l.starts_with("VmRSS:"))
            .map(str::to_string)
    });
    assert!(rss_line.is_some(), "expected VmRSS line on linux");
    let rss_kib: u64 = rss_line
        .unwrap()
        .split_whitespace()
        .nth(1)
        .and_then(|s| s.parse().ok())
        .expect("parse");
    assert!(rss_kib > 0, "VmRSS should be > 0 even for empty process");
}