denet 0.7.0

a simple process monitor
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

//! Tests for core library functionality in the denet crate

use denet::{DenetConfig, MonitorConfig, OutputConfig, Result};

/// Test that the re-exports from the lib module work correctly
#[test]
fn test_reexports() {
    // Test the config re-exports
    let monitor_config = MonitorConfig::builder()
        .base_interval_ms(200)
        .max_interval_ms(2000)
        .build()
        .unwrap();

    let output_config = OutputConfig::builder()
        .store_in_memory(true)
        .quiet(false)
        .build();

    let config = DenetConfig {
        monitor: monitor_config,
        output: output_config,
    };

    assert_eq!(
        config.monitor.base_interval,
        std::time::Duration::from_millis(200)
    );
    assert_eq!(
        config.monitor.max_interval,
        std::time::Duration::from_millis(2000)
    );
    assert!(config.output.store_in_memory);
    assert!(!config.output.quiet);

    // Test Result type re-export
    let _result: Result<()> = Ok(());
}

/// Test the run_monitor function for non-Python builds
#[cfg(not(feature = "python"))]
#[test]
fn test_run_monitor_basic() {
    use denet::run_monitor;

    // This command should fail quickly and return an error
    let result = run_monitor(vec!["non_existent_command".to_string()], 100, 1000, false);

    assert!(result.is_err());

    // This command should run but exit immediately
    // Using `true` command which exists on most Unix systems
    #[cfg(target_family = "unix")]
    {
        let result = run_monitor(vec!["true".to_string()], 100, 1000, false);

        // The command should succeed
        assert!(result.is_ok());
    }
}

/// Test ProcessMonitor re-export
#[test]
fn test_process_monitor_reexport() {
    use denet::ProcessMonitor;
    use std::time::Duration;

    // Current process id
    let pid = std::process::id() as usize;

    // Test the constructor without running
    let monitor_result = ProcessMonitor::from_pid_with_options(
        pid,
        Duration::from_millis(100),
        Duration::from_millis(1000),
        false,
    );

    // The current process should exist
    assert!(monitor_result.is_ok());

    // Get the process monitor
    let mut monitor = monitor_result.unwrap();

    // Test basic API
    assert_eq!(monitor.get_pid(), pid);
    assert!(monitor.is_running());
}

/// Test legacy ProcessMonitor re-export
#[test]
fn test_process_monitor_legacy_reexport() {
    use denet::ProcessMonitor;
    use std::time::Duration;

    // Create a basic process monitor for the current process
    let pid = std::process::id() as usize;
    // Use the legacy from_pid constructor with the correct parameters
    let monitor_result =
        ProcessMonitor::from_pid(pid, Duration::from_millis(100), Duration::from_millis(1000));

    // The monitor should be created successfully
    assert!(monitor_result.is_ok());

    // Get the process monitor
    let mut monitor = monitor_result.unwrap();

    // The process should be running
    assert!(monitor.is_running());

    // Test pid accessor
    assert_eq!(monitor.get_pid(), pid);
}