whi 0.8.0

Stupid simple PATH management
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

mod support;

use std::fs;

use support::{env_lock, set_env_var};
use tempfile::TempDir;
use whi::session::history::HistoryContext;
use whi::session::store::{
    clear_cursor, clear_session, get_current_snapshot, get_initial_path, get_session_file,
    read_path_snapshots, set_cursor, truncate_snapshots, write_path_snapshot,
};

#[test]
fn history_write_and_read_snapshots() {
    let _lock = env_lock();
    let runtime_dir = TempDir::new().unwrap();
    let _runtime = set_env_var("XDG_RUNTIME_DIR", runtime_dir.path());

    let history = HistoryContext::global(10).unwrap();
    history.write_snapshot("/bin:/usr/bin").unwrap();
    history.write_snapshot("/usr/bin").unwrap();

    let snapshots = history.read_snapshots().unwrap();
    assert_eq!(snapshots, vec!["/bin:/usr/bin", "/usr/bin"]);
}

#[test]
fn history_cursor_operations() {
    let _lock = env_lock();
    let runtime_dir = TempDir::new().unwrap();
    let _runtime = set_env_var("XDG_RUNTIME_DIR", runtime_dir.path());

    let history = HistoryContext::global(11).unwrap();
    history.write_snapshot("/bin").unwrap();
    history.write_snapshot("/usr/bin").unwrap();

    history.set_cursor(0).unwrap();
    assert_eq!(history.get_cursor().unwrap(), Some(0));
    assert_eq!(
        history.current_snapshot().unwrap(),
        Some("/bin".to_string())
    );

    history.clear_cursor().unwrap();
    assert_eq!(history.get_cursor().unwrap(), None);
}

#[test]
fn store_session_file_path_and_directory_permissions() {
    let _lock = env_lock();
    let runtime_dir = TempDir::new().unwrap();
    let _runtime = set_env_var("XDG_RUNTIME_DIR", runtime_dir.path());

    let file_path = get_session_file(12).unwrap();
    assert!(file_path.to_string_lossy().contains("whi-"));
    assert!(file_path.to_string_lossy().contains("session_12.log"));

    write_path_snapshot(12, "/test/path").unwrap();

    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;

        let dir = file_path.parent().unwrap();
        let dir_mode = fs::metadata(dir).unwrap().permissions().mode() & 0o777;
        let file_mode = fs::metadata(&file_path).unwrap().permissions().mode() & 0o777;

        assert_eq!(dir_mode, 0o700);
        assert_eq!(file_mode, 0o600);
    }
}

#[test]
fn store_truncate_and_initial_path() {
    let _lock = env_lock();
    let runtime_dir = TempDir::new().unwrap();
    let _runtime = set_env_var("XDG_RUNTIME_DIR", runtime_dir.path());

    let pid = 13;
    write_path_snapshot(pid, "/initial").unwrap();
    write_path_snapshot(pid, "/snap1").unwrap();
    write_path_snapshot(pid, "/snap2").unwrap();

    assert_eq!(get_initial_path(pid).unwrap(), Some("/initial".to_string()));
    assert_eq!(
        get_current_snapshot(pid).unwrap(),
        Some("/snap2".to_string())
    );

    truncate_snapshots(pid, 2).unwrap();
    assert_eq!(
        read_path_snapshots(pid).unwrap(),
        vec!["/initial", "/snap1"]
    );

    set_cursor(pid, 0).unwrap();
    assert_eq!(
        get_current_snapshot(pid).unwrap(),
        Some("/initial".to_string())
    );
    clear_cursor(pid).unwrap();

    clear_session(pid).unwrap();
}