s3rm-rs 1.3.2

Fast Amazon S3 object deletion tool.
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

use byte_unit::Byte;
use std::str::FromStr;

pub fn check_human_bytes(value: &str) -> Result<String, String> {
    let result = Byte::from_str(value).map_err(|e| e.to_string())?;
    TryInto::<u64>::try_into(result.as_u128()).map_err(|e| e.to_string())?;

    Ok(value.to_string())
}

pub fn parse_human_bytes(value: &str) -> Result<u64, String> {
    check_human_bytes(value)?;

    let result = Byte::from_str(value).map_err(|e| e.to_string())?;
    Ok(result
        .as_u128()
        .try_into()
        .expect("check_human_bytes already validated u64 range"))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn check_valid_value() {
        check_human_bytes("0").unwrap();
        check_human_bytes("1KiB").unwrap();
        check_human_bytes("1KB").unwrap();
        check_human_bytes("1024").unwrap();
        check_human_bytes("5MiB").unwrap();
        check_human_bytes("5242880").unwrap();
        check_human_bytes("5GiB").unwrap();
        check_human_bytes("8MiB").unwrap();
        check_human_bytes("10GiB").unwrap();
        check_human_bytes("1TiB").unwrap();
        check_human_bytes("50TiB").unwrap();
    }

    #[test]
    fn check_invalid_value() {
        assert!(check_human_bytes("524287a").is_err());
        assert!(check_human_bytes("5Zib").is_err());
    }

    #[test]
    fn parse_valid_value() {
        assert_eq!(8 * 1024 * 1024, parse_human_bytes("8MiB").unwrap());
        assert_eq!(5 * 1024 * 1024, parse_human_bytes("5242880").unwrap());
        assert_eq!(10 * 1024 * 1024 * 1024, parse_human_bytes("10GiB").unwrap());
    }

    #[test]
    fn parse_invalid_value() {
        assert!(parse_human_bytes("524287a").is_err());
        assert!(parse_human_bytes("5Zib").is_err());
    }

    #[test]
    fn parse_zero() {
        assert_eq!(0, parse_human_bytes("0").unwrap());
    }

    #[test]
    fn parse_one_byte() {
        assert_eq!(1, parse_human_bytes("1").unwrap());
    }

    #[test]
    fn parse_max_u64_rejects_overflow() {
        // Values exceeding u64::MAX should be rejected by check_human_bytes
        assert!(parse_human_bytes("18446744073709551616").is_err());
    }

    #[test]
    fn check_rejects_overflow() {
        // u64::MAX + 1 = 18446744073709551616
        assert!(check_human_bytes("18446744073709551616").is_err());
    }

    #[test]
    fn check_accepts_large_valid_value() {
        // 50 TiB is within u64 range
        assert!(check_human_bytes("50TiB").is_ok());
    }
}