moadim 3.9.0

Loop engine for AI agents — routines over REST, MCP, and a built-in web UI
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

// Tests for the `global lock` check. Included into `doctor_tests.rs`, so `super::*` and its
// fixtures are in scope.

use crate::global_lock::LockStatus;
use crate::utils::time::format_local;

/// A lock status built from its raw fields, so tests need no filesystem.
fn status(
    shared: bool,
    local: bool,
    shared_since: Option<u64>,
    local_since: Option<u64>,
) -> LockStatus {
    LockStatus {
        shared,
        local,
        locked: shared || local,
        shared_since,
        local_since,
    }
}

#[test]
fn unlocked_lock_check_passes() {
    let check = lock_check(&unlocked());
    assert!(check.passed());
    assert_eq!(check.render(), "ok   global lock");
}

#[test]
fn local_lock_only_names_local_sentinel() {
    let check = lock_check(&status(false, true, None, Some(1_700_000_000)));
    assert_eq!(
        check.render(),
        format!(
            "FAIL global lock — .local.lock since {}; routines are halted, run: moadim unlock",
            format_local(1_700_000_000)
        )
    );
}

#[test]
fn shared_lock_only_names_shared_sentinel() {
    let check = lock_check(&status(true, false, Some(1_700_000_000), None));
    assert_eq!(
        check.render(),
        format!(
            "FAIL global lock — .lock since {}; routines are halted, run: moadim unlock",
            format_local(1_700_000_000)
        )
    );
}

#[test]
fn both_locks_list_both_and_use_earlier_since() {
    let check = lock_check(&status(true, true, Some(1_700_000_200), Some(1_700_000_100)));
    assert_eq!(
        check.render(),
        format!(
            "FAIL global lock — .lock and .local.lock since {}; routines are halted, run: moadim unlock",
            format_local(1_700_000_100)
        )
    );
}

#[test]
fn locked_without_since_time_omits_since() {
    let check = lock_check(&status(true, false, None, None));
    assert_eq!(
        check.render(),
        "FAIL global lock — .lock; routines are halted, run: moadim unlock"
    );
}

#[test]
fn held_lock_makes_exit_code_one() {
    let fixture = Fixture::healthy();
    let checks = run_checks(
        &fixture.path(),
        &fixture.agents(),
        true,
        &status(true, false, Some(1_700_000_000), None),
    );
    assert!(!find(&checks, "global lock").passed());
    assert_eq!(exit_code(&checks), 1);
}

#[test]
fn global_lock_check_sits_after_agents_and_before_daemon() {
    let fixture = Fixture::healthy();
    let checks = run_checks(&fixture.path(), &fixture.agents(), true, &unlocked());
    let labels: Vec<&str> = checks.iter().map(|check| check.label.as_str()).collect();
    assert_eq!(
        labels,
        ["tmux", "python3", "agent claude", "global lock", "daemon"]
    );
}