process_state 1.0.0

A Rust library that lets you track, cache, and manage commands like a process manager
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

use process_state::{ProcessState, ProcessStatus};
use std::process::Command;
use tempfile::TempDir;

/// Test adding and removing a process from the state.
///
/// Spawns a short-lived process, adds it to `ProcessState`,
/// verifies it is tracked, then removes it and verifies removal.
#[test]
fn test_add_and_remove_process() {
    let tmp = TempDir::new().unwrap();
    let ns = tmp.path().file_name().unwrap().to_str().unwrap();
    let mut state = ProcessState::new(ns).unwrap();

    // Spawn a short-lived process
    let child = if cfg!(windows) {
        Command::new("timeout").arg("2").spawn().unwrap()
    } else {
        Command::new("sleep").arg("2").spawn().unwrap()
    };

    // Track the process
    state.add_process(&child, "test", "sleep 2").unwrap();

    // Ensure it's added correctly
    assert_eq!(state.get_all().len(), 1);
    assert_eq!(state.get_running().len(), 1);

    // Remove the process and check removal
    let pid = child.id();
    state.remove_process(pid).unwrap();
    assert_eq!(state.get_all().len(), 0);
}

/// Test that `refresh` updates the status of processes.
///
/// Spawns a process, ensures it's running, waits for it to exit,
/// refreshes the state, and verifies that the status is updated to `Stopped`.
#[test]
fn test_refresh_updates_status() {
    let tmp = TempDir::new().unwrap();
    let ns = tmp.path().file_name().unwrap().to_str().unwrap();
    let mut state = ProcessState::new(ns).unwrap();

    // Spawn a short-lived process
    let mut child = if cfg!(windows) {
        Command::new("timeout").arg("1").spawn().unwrap()
    } else {
        Command::new("sleep").arg("1").spawn().unwrap()
    };

    // Track the process
    state.add_process(&child, "short", "sleep 1").unwrap();

    // Initially, process should be running
    state.refresh().unwrap();
    assert_eq!(state.get_running().len(), 1);

    // Wait for process to exit and refresh
    child.wait().unwrap();
    state.refresh().unwrap();

    // Status should now be updated to stopped
    let all = state.get_all();
    let info = all.first().unwrap();
    assert_eq!(info.status, ProcessStatus::Stopped);
}

/// Test that process state persists across `ProcessState` instances.
///
/// Adds a process, drops the `ProcessState`, reopens it, and verifies that
/// the process is still tracked in the loaded state.
#[test]
fn test_persistence() {
    let tmp = TempDir::new().unwrap();
    let ns = tmp.path().file_name().unwrap().to_str().unwrap();

    {
        let mut state = ProcessState::new(ns).unwrap();

        // Spawn a short-lived process
        let child = if cfg!(windows) {
            Command::new("timeout").arg("1").spawn().unwrap()
        } else {
            Command::new("sleep").arg("1").spawn().unwrap()
        };

        state.add_process(&child, "persist", "sleep 1").unwrap();

        // Check that it's added
        let all = state.get_all();
        let info = all.first().unwrap();
        assert_eq!(info.label, "persist");
    }

    // Reload state from disk
    let state2 = ProcessState::new(ns).unwrap();
    let all = state2.get_all();
    let info = all.first().unwrap();
    assert_eq!(info.label, "persist");
}