infrarust_server_manager 1.6.3

A Minecraft server manager that handles API monitoring and system commands
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

use infrarust_server_manager::{
    ApiProvider, ApiServerStatus, CrashDetector, MockApiProvider, ServerManager, ServerState,
};

use std::time::Duration;
use tokio::time;

fn create_test_manager() -> (ServerManager<MockApiProvider>, MockApiProvider) {
    let mock_api = MockApiProvider::new().with_server(
        "test-server",
        ApiServerStatus {
            id: "test-server".to_string(),
            name: "Test Server".to_string(),
            status: ServerState::Stopped,
            is_running: false,
            is_crashed: false,
            error: None,
        },
    );

    let server_manager =
        ServerManager::new(mock_api.clone()).with_check_interval(Duration::from_millis(100));

    (server_manager, mock_api)
}

#[tokio::test]
async fn test_start_server() {
    let (server_manager, mock_api) = create_test_manager();

    let initial_status = mock_api.get_server_status("test-server").await.unwrap();
    assert!(!initial_status.is_running);
    assert!(initial_status.error.is_none());

    server_manager.start_server("test-server").await.unwrap();

    let status = mock_api.get_server_status("test-server").await.unwrap();
    assert!(status.is_running);
    assert!(status.error.is_none());
    assert_eq!(status.status, ServerState::Running);
    assert!(!status.is_crashed);
}

#[tokio::test]
async fn test_stop_server() {
    let (server_manager, mock_api) = create_test_manager();

    mock_api.set_server_running("test-server");
    let initial_status = mock_api.get_server_status("test-server").await.unwrap();
    assert!(initial_status.is_running);

    server_manager.stop_server("test-server").await.unwrap();

    let status = mock_api.get_server_status("test-server").await.unwrap();
    assert!(!status.is_running);
    assert!(status.error.is_none());
    assert_eq!(status.status, ServerState::Stopped);
    assert!(!status.is_crashed);
}

#[tokio::test]
async fn test_restart_server() {
    let (server_manager, mock_api) = create_test_manager();

    mock_api.set_server_running("test-server");

    server_manager.restart_server("test-server").await.unwrap();

    let status = mock_api.get_server_status("test-server").await.unwrap();
    assert!(status.is_running);
    assert!(status.error.is_none());
    assert_eq!(status.status, ServerState::Running);
    assert!(!status.is_crashed);
}

#[tokio::test]
async fn test_crash_detection() {
    let detector = CrashDetector::new(2, Duration::from_millis(500));

    let mock_api = MockApiProvider::new().with_server(
        "crash-server",
        ApiServerStatus {
            id: "crash-server".to_string(),
            name: "Crash Test Server".to_string(),
            status: ServerState::Running,
            is_running: true,
            is_crashed: false,
            error: None,
        },
    );

    let server_manager = ServerManager::new(mock_api.clone()).with_crash_detector(detector);

    mock_api.set_server_crashed("crash-server");

    time::sleep(Duration::from_millis(100)).await;

    tokio::spawn(async move {
        let _ = server_manager.monitor_server("crash-server").await;
    });

    time::sleep(Duration::from_millis(200)).await;

    let api_status = mock_api.get_server_status("crash-server").await.unwrap();
    assert!(!api_status.is_running);
    assert!(api_status.is_crashed);
    assert_eq!(api_status.status, ServerState::Crashed);
    assert!(api_status.error.is_some());
    let error = api_status.error.unwrap();
    assert!(error.contains("crash"), "Expected crash message in error");
}

#[tokio::test]
async fn test_execute_system_command() {
    let (server_manager, _) = create_test_manager();

    #[cfg(target_os = "windows")]
    let command = "echo Hello, World!";
    #[cfg(target_os = "linux")]
    let command = "echo 'Hello, World!'";

    let result = server_manager.execute_system_command(command);
    assert!(
        result.is_ok(),
        "Command execution failed: {:?}",
        result.err()
    );

    let output = result.unwrap();
    assert!(
        output.contains("Hello, World!"),
        "Command output doesn't contain expected text"
    );
}