uselesskey-core-seed 0.7.0

Seed parsing and redaction primitives for uselesskey.
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
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158

//! Error path and boundary condition tests for uselesskey-core-seed.

use uselesskey_core_seed::Seed;

// =========================================================================
// Invalid hex strings
// =========================================================================

#[test]
fn from_env_value_rejects_invalid_hex_char_in_64_char_string() {
    // 64 chars but contains 'g' which is not hex
    let mut hex = "0".repeat(64);
    hex.replace_range(0..1, "g");

    let result = Seed::from_env_value(&hex);
    assert!(result.is_err());
    let err = result.unwrap_err();
    assert!(
        err.contains("invalid hex char"),
        "error should describe the invalid char, got: {err}"
    );
}

#[test]
fn from_env_value_rejects_hex_prefix_with_invalid_chars() {
    let hex = format!("0x{}", "g".repeat(64));
    let result = Seed::from_env_value(&hex);
    // After stripping 0x, we have 64 'g' chars which aren't valid hex
    assert!(result.is_err());
    let err = result.unwrap_err();
    assert!(
        err.contains("invalid hex char"),
        "expected 'invalid hex char' error, got: {err}"
    );
}

// =========================================================================
// Edge case: empty input is hashed (not rejected)
// =========================================================================

#[test]
fn from_env_value_empty_string_does_not_error() {
    let result = Seed::from_env_value("");
    assert!(
        result.is_ok(),
        "empty string should be hashed, not rejected"
    );
}

#[test]
fn from_env_value_whitespace_only_does_not_error() {
    let result = Seed::from_env_value("   ");
    assert!(
        result.is_ok(),
        "whitespace-only should be hashed (after trim to empty)"
    );
}

// =========================================================================
// Boundary: exactly 64 hex chars
// =========================================================================

#[test]
fn from_env_value_63_hex_chars_is_hashed_not_parsed() {
    // 63 chars: not valid as hex seed, so it gets BLAKE3-hashed
    let hex63 = "a".repeat(63);
    let hashed = Seed::from_env_value(&hex63).unwrap();
    let expected = blake3::hash(hex63.as_bytes());
    assert_eq!(hashed.bytes(), expected.as_bytes());
}

#[test]
fn from_env_value_65_hex_chars_is_hashed_not_parsed() {
    // 65 chars: too long for hex parse, so it gets BLAKE3-hashed
    let hex65 = "a".repeat(65);
    let hashed = Seed::from_env_value(&hex65).unwrap();
    let expected = blake3::hash(hex65.as_bytes());
    assert_eq!(hashed.bytes(), expected.as_bytes());
}

#[test]
fn from_env_value_exactly_64_valid_hex_is_parsed() {
    let hex = "ff".repeat(32);
    assert_eq!(hex.len(), 64);
    let seed = Seed::from_env_value(&hex).unwrap();
    assert!(seed.bytes().iter().all(|b| *b == 0xFF));
}

// =========================================================================
// Debug redaction
// =========================================================================

#[test]
fn seed_debug_never_leaks_bytes() {
    let seed = Seed::new([0xDE; 32]);
    let dbg = format!("{:?}", seed);
    assert!(!dbg.contains("DE"), "seed bytes must not appear in Debug");
    assert!(!dbg.contains("222"), "seed byte decimal must not appear");
    assert!(dbg.contains("redacted"), "Debug must say 'redacted'");
}

// =========================================================================
// Equality and hash consistency
// =========================================================================

#[test]
fn seeds_with_same_bytes_are_equal() {
    let a = Seed::new([42u8; 32]);
    let b = Seed::new([42u8; 32]);
    assert_eq!(a, b);
}

#[test]
fn seeds_with_different_bytes_are_not_equal() {
    let a = Seed::new([1u8; 32]);
    let b = Seed::new([2u8; 32]);
    assert_ne!(a, b);
}

// =========================================================================
// from_env_value with 0x prefix
// =========================================================================

#[test]
fn from_env_value_0x_prefix_strips_correctly() {
    let hex = format!("0x{}", "ab".repeat(32));
    let seed = Seed::from_env_value(&hex).unwrap();
    assert!(seed.bytes().iter().all(|b| *b == 0xAB));
}

#[test]
fn from_env_value_0x_with_short_hex_is_hashed() {
    // "0x" + 62 chars = 62 hex chars after stripping, not 64, so hashed
    let hex = format!("0x{}", "a".repeat(62));
    let result = Seed::from_env_value(&hex).unwrap();
    // After trim and strip, hex part is 62 chars (not 64), so the full value is BLAKE3-hashed
    let expected = blake3::hash(hex.trim().as_bytes());
    assert_eq!(result.bytes(), expected.as_bytes());
}

// =========================================================================
// Mixed case hex
// =========================================================================

#[test]
fn from_env_value_mixed_case_hex_parses() {
    let mut hex = String::new();
    for i in 0..32 {
        if i % 2 == 0 {
            hex.push_str("aB");
        } else {
            hex.push_str("Ab");
        }
    }
    assert_eq!(hex.len(), 64);
    let result = Seed::from_env_value(&hex);
    assert!(result.is_ok(), "mixed-case hex should parse");
}