jjj 0.4.1

Distributed project management and code review for Jujutsu
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
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163

mod test_helpers;

use test_helpers::{jj_available, run_jjj_success, setup_test_repo};

/// Extract the problem UUID from `jjj problem new` output.
/// Output format: "Created problem <uuid> (<title>)"
fn extract_problem_id(output: &str) -> String {
    // Find the line containing "Created problem"
    for line in output.lines() {
        if let Some(rest) = line.strip_prefix("Created problem ") {
            // The UUID is the next token (up to the space before the parenthesized title)
            if let Some(id) = rest.split_whitespace().next() {
                return id.to_string();
            }
        }
    }
    panic!("Could not extract problem ID from output: {}", output);
}

/// Extract the solution UUID from `jjj solution new` output.
/// Output format: "Created solution <uuid> (<title>)"
fn extract_solution_id(output: &str) -> String {
    for line in output.lines() {
        if let Some(rest) = line.strip_prefix("Created solution ") {
            if let Some(id) = rest.split_whitespace().next() {
                return id.to_string();
            }
        }
    }
    panic!("Could not extract solution ID from output: {}", output);
}

#[test]
fn test_timeline_shows_creation_event() {
    if !jj_available() {
        return;
    }
    let dir = setup_test_repo();

    let create_output = run_jjj_success(&dir, &["problem", "new", "Timeline Test Problem"]);
    let problem_id = extract_problem_id(&create_output);

    let stdout = run_jjj_success(&dir, &["timeline", &problem_id]);
    assert!(
        stdout.contains("Timeline Test Problem"),
        "Expected problem title in timeline output: {}",
        stdout
    );
    assert!(
        stdout.contains("problem created"),
        "Expected 'problem created' event in timeline: {}",
        stdout
    );
}

#[test]
fn test_timeline_with_solutions() {
    if !jj_available() {
        return;
    }
    let dir = setup_test_repo();

    let create_output = run_jjj_success(&dir, &["problem", "new", "Problem With Solutions"]);
    let problem_id = extract_problem_id(&create_output);

    // Create a solution attached to the problem
    let sol_output = run_jjj_success(
        &dir,
        &[
            "solution",
            "new",
            "First Solution",
            "--problem",
            "Problem With Solutions",
        ],
    );
    let solution_id = extract_solution_id(&sol_output);

    let stdout = run_jjj_success(&dir, &["timeline", &problem_id]);
    assert!(
        stdout.contains("Problem With Solutions"),
        "Expected problem title in timeline output: {}",
        stdout
    );
    assert!(
        stdout.contains("problem created"),
        "Expected 'problem created' event: {}",
        stdout
    );
    // The solution event should reference the solution's entity ID
    assert!(
        stdout.contains("proposed") || stdout.contains(&solution_id[..6.min(solution_id.len())]),
        "Expected solution proposed event in timeline: {}",
        stdout
    );
}

#[test]
fn test_timeline_json_output() {
    if !jj_available() {
        return;
    }
    let dir = setup_test_repo();

    let create_output = run_jjj_success(&dir, &["problem", "new", "JSON Timeline Problem"]);
    let problem_id = extract_problem_id(&create_output);

    // Create a solution so there are multiple events
    run_jjj_success(
        &dir,
        &[
            "solution",
            "new",
            "JSON Timeline Solution",
            "--problem",
            "JSON Timeline Problem",
        ],
    );

    let stdout = run_jjj_success(&dir, &["timeline", &problem_id, "--json"]);
    let json: serde_json::Value =
        serde_json::from_str(&stdout).expect("Failed to parse timeline JSON output");
    assert!(json.is_array(), "Expected JSON array, got: {}", json);

    let arr = json.as_array().unwrap();
    assert!(
        arr.len() >= 2,
        "Expected at least 2 events (problem_created + solution_created), got {}",
        arr.len()
    );

    // Verify event structure
    for event in arr {
        assert!(
            event.get("when").is_some(),
            "Event missing 'when' field: {}",
            event
        );
        assert!(
            event.get("type").is_some(),
            "Event missing 'type' field: {}",
            event
        );
        assert!(
            event.get("entity").is_some(),
            "Event missing 'entity' field: {}",
            event
        );
        assert!(
            event.get("by").is_some(),
            "Event missing 'by' field: {}",
            event
        );
    }

    // First event should be problem_created
    let first_type = arr[0]["type"].as_str().unwrap_or("");
    assert_eq!(
        first_type, "problem_created",
        "Expected first event to be problem_created, got: {}",
        first_type
    );
}