storageshower 0.28.8

Cyberpunk disk usage TUI
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

use crossterm::event::{KeyCode, KeyEvent, KeyEventKind, KeyEventState, KeyModifiers};
use std::sync::{Arc, Mutex};
use sysinfo::DiskKind;

use crate::app::App;
use crate::prefs::Prefs;
use crate::types::{DiskEntry, SysStats};

pub fn make_key(code: KeyCode) -> KeyEvent {
    KeyEvent {
        code,
        modifiers: KeyModifiers::NONE,
        kind: KeyEventKind::Press,
        state: KeyEventState::NONE,
    }
}

pub fn make_ctrl_key(code: KeyCode) -> KeyEvent {
    KeyEvent {
        code,
        modifiers: KeyModifiers::CONTROL,
        kind: KeyEventKind::Press,
        state: KeyEventState::NONE,
    }
}

pub fn test_disks() -> Vec<DiskEntry> {
    vec![
        DiskEntry {
            mount: "/".into(),
            used: 50_000_000_000,
            total: 100_000_000_000,
            pct: 50.0,
            kind: DiskKind::SSD,
            fs: "apfs".into(),
            latency_ms: None,
            io_read_rate: None,
            io_write_rate: None,
            smart_status: None,
        },
        DiskEntry {
            mount: "/home".into(),
            used: 80_000_000_000,
            total: 200_000_000_000,
            pct: 40.0,
            kind: DiskKind::SSD,
            fs: "ext4".into(),
            latency_ms: None,
            io_read_rate: None,
            io_write_rate: None,
            smart_status: None,
        },
        DiskEntry {
            mount: "/data".into(),
            used: 900_000_000_000,
            total: 1_000_000_000_000,
            pct: 90.0,
            kind: DiskKind::HDD,
            fs: "xfs".into(),
            latency_ms: None,
            io_read_rate: None,
            io_write_rate: None,
            smart_status: None,
        },
        DiskEntry {
            mount: "/tmp".into(),
            used: 100_000,
            total: 500_000_000,
            pct: 0.02,
            kind: DiskKind::Unknown(-1),
            fs: "tmpfs".into(),
            latency_ms: None,
            io_read_rate: None,
            io_write_rate: None,
            smart_status: None,
        },
    ]
}

pub fn test_app() -> App {
    let stats = SysStats::default();
    let disks = test_disks();
    let shared = Arc::new(Mutex::new((stats.clone(), disks.clone())));
    let mut app = App::new_default(shared);
    app.disks = disks;
    app.stats = stats;
    app.prefs = Prefs::default();
    app.test_mode = true;
    app.update_sorted();
    app
}

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

    #[test]
    fn test_disks_count_and_ordering() {
        let d = test_disks();
        assert_eq!(d.len(), 4);
        assert_eq!(d[0].mount, "/");
        assert_eq!(d[1].mount, "/home");
        assert_eq!(d[2].mount, "/data");
        assert_eq!(d[3].mount, "/tmp");
    }

    #[test]
    fn test_disks_percentages_and_fs() {
        let d = test_disks();
        assert!((d[0].pct - 50.0).abs() < f64::EPSILON);
        assert_eq!(d[0].fs, "apfs");
        assert!((d[2].pct - 90.0).abs() < f64::EPSILON);
        assert_eq!(d[2].fs, "xfs");
    }

    #[test]
    fn test_app_test_mode_and_sorted() {
        let app = test_app();
        assert!(app.test_mode);
        assert!(!app.disks.is_empty());
    }

    #[test]
    fn make_key_codes() {
        assert_eq!(make_key(KeyCode::Char('q')).code, KeyCode::Char('q'));
        assert_eq!(make_key(KeyCode::Esc).code, KeyCode::Esc);
    }

    #[test]
    fn make_ctrl_key_has_control_modifier() {
        let e = make_ctrl_key(KeyCode::Char('c'));
        assert_eq!(e.code, KeyCode::Char('c'));
        assert!(e.modifiers.contains(KeyModifiers::CONTROL));
    }
}