qq-cli 0.1.0

A modular Rust QQ task interface for coding agents
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

use super::*;
use crate::napcat::runtime::stop::{self, tests::fixture};
use std::time::Duration;
fn end() -> Instant {
    Instant::now() + Duration::from_secs(3)
}

#[test]
fn changed_snapshot_after_completion_never_overwrites_current_registration() {
    for field in 0..15 {
        let (_temp, store, refs, original, _target) = fixture();
        stop::execute(&store, &refs, &original, end()).unwrap();
        let registry = store.read().unwrap();
        let expected = Snapshot::new(&original, &registry.installations[0]);
        let proof = std::fs::read_dir(store.root().join("instance-stops"))
            .unwrap()
            .next()
            .unwrap()
            .unwrap()
            .path();
        let proof_bytes = std::fs::read(&proof).unwrap();
        let mut tx = store.transaction(end()).unwrap();
        tx.registry.instances[0].state = "stopping".into();
        match field {
            0 => tx.registry.instances[0].account = Some("10001".into()),
            1 => tx.registry.instances[0].endpoint = "http://127.0.0.1:19002/".into(),
            2 => tx.registry.instances[0].credential_key = "changed-key".into(),
            3 => tx.registry.instances[0].process_id = Some(123),
            4 => {
                tx.registry.instances[0].process_started =
                    Some("changed-process-observation".into())
            }
            5 => tx.registry.instances[0].run_id = "changed-run".into(),
            6 => tx.registry.instances[0].ws_endpoint = Some("ws://127.0.0.1:19003/event".into()),
            7 => tx.registry.installations[0].version = "changed-version".into(),
            8 => tx.registry.installations[0].directory = store.root().join("changed-installation"),
            9 => tx.registry.installations[0].digest = "b".repeat(64),
            10 => {
                let duplicate = tx.registry.installations[0].clone();
                tx.registry.installations.push(duplicate);
            }
            11 => tx.registry.instances[0].state = "ready".into(),
            12 => tx.registry.instances.clear(),
            13 => tx.registry.instances[0].installation_id = "changed-installation".into(),
            _ => {
                let mut duplicate = tx.registry.installations[0].clone();
                duplicate.digest = "b".repeat(64);
                tx.registry.installations.push(duplicate);
            }
        }
        tx.commit().unwrap();
        let current = std::fs::read(store.root().join("registry.json")).unwrap();
        let error = complete(&store, &expected, end())
            .err()
            .unwrap_or_else(|| panic!("changed field {field} was acknowledged"));
        assert_eq!(error.code, "STOP_OUTCOME_UNKNOWN");
        assert_eq!(
            error.outcome,
            Some(crate::core::contracts::write::Outcome::Unknown)
        );
        assert!(
            serde_json::to_value(error.details.as_ref().unwrap())
                .unwrap()
                .get("state")
                .is_none()
        );
        assert_eq!(
            std::fs::read(store.root().join("registry.json")).unwrap(),
            current
        );
        assert_eq!(std::fs::read(proof).unwrap(), proof_bytes);
    }
}

#[test]
fn unchanged_snapshot_acknowledges_completed_proof_and_keeps_repeat_reusable() {
    let (_temp, store, refs, original, _target) = fixture();
    stop::execute(&store, &refs, &original, end()).unwrap();
    let registry = store.read().unwrap();
    let expected = Snapshot::new(&original, &registry.installations[0]);
    let mut tx = store.transaction(end()).unwrap();
    tx.registry.instances[0].state = "stopping".into();
    tx.commit().unwrap();
    complete(&store, &expected, end()).unwrap();
    let stopped = store.read().unwrap().instances.remove(0);
    assert_eq!(stopped.state, "stopped");
    assert!(
        stop::execute(&store, &refs, &stopped, end())
            .unwrap()
            .reused
    );
}

#[test]
fn acknowledgement_commit_failure_preserves_completion_for_recovery() {
    use std::os::windows::fs::OpenOptionsExt;
    let (_temp, store, refs, original, _target) = fixture();
    stop::execute(&store, &refs, &original, end()).unwrap();
    let registry = store.read().unwrap();
    let expected = Snapshot::new(&original, &registry.installations[0]);
    let mut tx = store.transaction(end()).unwrap();
    tx.registry.instances[0].state = "stopping".into();
    tx.commit().unwrap();
    let path = store.root().join("registry.json");
    let before = std::fs::read(&path).unwrap();
    let held = std::fs::OpenOptions::new()
        .read(true)
        .share_mode(1)
        .open(&path)
        .unwrap();
    let error = complete(&store, &expected, end()).err().unwrap();
    assert_eq!(error.code, "STOP_OUTCOME_UNKNOWN");
    assert_eq!(
        error.outcome,
        Some(crate::core::contracts::write::Outcome::Unknown)
    );
    assert_eq!(std::fs::read(&path).unwrap(), before);
    drop(held);
    complete(&store, &expected, end()).unwrap();
    let stopped = store.read().unwrap().instances.remove(0);
    assert!(
        stop::execute(&store, &refs, &stopped, end())
            .unwrap()
            .reused
    );
}