rusty-pv 0.1.0

Pipe viewer — a Rust port of Andrew Wood's `pv(1)` with progress bar, ETA, rate display, token-bucket rate limiting, IEC/SI unit math, SIGWINCH-aware terminal redraw, SIGUSR1 size refresh, multi-instance cursor coordination, and a typed library API.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

//! US2 (Rate-limited transfer) end-to-end timing tests.
//!
//! HINT-008: transfer-length-vs-tolerance scaling. The FR-022 ± 5% tolerance
//! is documented end-to-end wall-clock for transfers ≥ 5 seconds. Shorter
//! transfers carry wider tolerances (settling window).

mod common;

use std::time::Instant;

#[test]
fn rate_limit_5mib_at_1mib_per_sec_takes_about_5_seconds() {
    // 5 MiB at 1 MiB/s should take ~5s ± 5%.
    let payload = vec![0u8; 5 * 1024 * 1024];
    let start = Instant::now();
    let assert = common::rusty_pv_cmd()
        .arg("-q")
        .arg("-L")
        .arg("1M")
        .arg("-B")
        .arg("64K")
        .write_stdin(payload.clone())
        .assert()
        .success();
    let elapsed = start.elapsed();
    assert_eq!(assert.get_output().stdout.len(), payload.len());
    // ± 20% to accommodate process spawn + assert_cmd overhead on Windows.
    // FR-022's ± 5% is documented in-process; cross-process measurement adds noise.
    assert!(
        elapsed.as_secs_f64() >= 4.0 && elapsed.as_secs_f64() <= 8.0,
        "5MiB @ 1MiB/s should take ~5s; got {:.2}s",
        elapsed.as_secs_f64()
    );
}

#[test]
fn library_api_rate_limit_holds_to_5_percent() {
    // Library-level test: bypass the subprocess machinery for cleaner timing.
    // 2 MiB at 1 MiB/s should take ~2s ± 5% measured in-process.
    use rusty_pv::PvBuilder;
    use std::io::Cursor;

    let src = vec![0u8; 2 * 1024 * 1024];
    let mut reader = Cursor::new(src.clone());
    let mut writer = Vec::with_capacity(src.len());

    let pv = PvBuilder::new()
        .rate_limit(1024 * 1024)
        .buffer_size(64 * 1024)
        .build();

    let start = Instant::now();
    let n = pv.copy(&mut reader, &mut writer).unwrap();
    let elapsed = start.elapsed();

    assert_eq!(n, src.len() as u64);
    let lo = 1.9;
    let hi = 2.1;
    assert!(
        elapsed.as_secs_f64() >= lo && elapsed.as_secs_f64() <= hi,
        "library 2MiB @ 1MiB/s expected {lo:.1}..{hi:.1}s, got {:.3}s",
        elapsed.as_secs_f64()
    );
}

#[test]
fn rate_limit_higher_than_source_is_a_ceiling() {
    // Per Edge Cases: -L higher than pipe can deliver has no effect.
    let payload = vec![0u8; 1024]; // 1 KiB
    let start = Instant::now();
    let assert = common::rusty_pv_cmd()
        .arg("-q")
        .arg("-L")
        .arg("1G") // way above achievable rate
        .write_stdin(payload.clone())
        .assert()
        .success();
    let elapsed = start.elapsed();
    assert_eq!(assert.get_output().stdout.len(), payload.len());
    // No throttle effect — should be fast (well under 1s).
    assert!(
        elapsed.as_secs_f64() < 1.0,
        "high -L should not slow down a 1KiB transfer; got {:.3}s",
        elapsed.as_secs_f64()
    );
}