tij 0.11.0

Text-mode interface for Jujutsu - a TUI for jj version control
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

//! Undo/Redo integration tests.
//!
//! Tests for undo, redo, operation log, and operation restore.

#[path = "common/mod.rs"]
mod common;

use common::TestRepo;
use tij::jj::JjExecutor;

#[test]
fn test_undo_reverts_last_operation() {
    skip_if_no_jj!();
    let repo = TestRepo::new();
    repo.write_file("test.txt", "original");
    repo.jj(&["describe", "-m", "original"]);

    let executor = JjExecutor::with_repo_path(repo.path());
    executor
        .describe("@", "changed")
        .expect("describe should succeed");

    assert_eq!(repo.get_description("@"), "changed");

    executor.undo().expect("undo should succeed");

    assert_eq!(repo.get_description("@"), "original");
}

#[test]
fn test_redo_after_undo() {
    skip_if_no_jj!();
    let repo = TestRepo::new();
    repo.write_file("test.txt", "content");
    repo.jj(&["describe", "-m", "original"]);

    let executor = JjExecutor::with_repo_path(repo.path());
    executor
        .describe("@", "changed")
        .expect("describe should succeed");
    executor.undo().expect("undo should succeed");

    // Get redo target
    let redo_target = executor
        .get_redo_target()
        .expect("get_redo_target should succeed");
    assert!(redo_target.is_some(), "Should have a redo target");

    executor
        .redo(&redo_target.unwrap())
        .expect("redo should succeed");

    assert_eq!(repo.get_description("@"), "changed");
}

#[test]
fn test_op_log_returns_operations() {
    skip_if_no_jj!();
    let repo = TestRepo::new();
    repo.jj(&["new", "-m", "first"]);
    repo.jj(&["new", "-m", "second"]);

    let executor = JjExecutor::with_repo_path(repo.path());
    let ops = executor.op_log(Some(5)).expect("op_log should succeed");

    assert!(!ops.is_empty(), "Should have operations");
    // Most recent operation is first
    assert!(
        ops[0].description.contains("new") || ops[0].description.contains("snapshot"),
        "Latest op should be new or snapshot"
    );
}

#[test]
fn test_op_restore_reverts_to_previous_state() {
    skip_if_no_jj!();
    let repo = TestRepo::new();
    repo.jj(&["new", "-m", "before"]);

    let executor = JjExecutor::with_repo_path(repo.path());
    let ops_before = executor.op_log(Some(1)).expect("op_log should succeed");
    let op_id = &ops_before[0].id;

    repo.jj(&["describe", "-m", "after"]);
    assert_eq!(repo.get_description("@"), "after");

    executor
        .op_restore(op_id)
        .expect("op_restore should succeed");

    assert_eq!(repo.get_description("@"), "before");
}

// =============================================================================
// Phase 48-M4: create_target is cleared after undo/redo
// =============================================================================

/// After a successful undo ('u' key), create_target must be cleared so that
/// a change-id captured before the undo cannot survive as a stale bookmark/tag
/// creation target after the op-log has advanced.
#[test]
fn test_undo_key_clears_create_target() {
    skip_if_no_jj!();
    let repo = TestRepo::new();
    repo.jj(&["describe", "-m", "original"]);
    repo.jj(&["describe", "-m", "changed"]);

    // Use new_for_test() to avoid a spurious jj subprocess against the CWD.
    let mut app = tij::app::App::new_for_test();
    app.jj = JjExecutor::with_repo_path(repo.path());

    // Pre-set a captured create_target that would become stale after undo.
    app.create_target = Some("stale-change-id".to_string());

    // Trigger undo via the 'u' key (same path used by the real UI).
    use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
    app.on_key_event(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE));

    assert_eq!(
        app.create_target, None,
        "undo ('u') must clear create_target; stale id survived the undo"
    );
}

/// After a successful redo (Ctrl+R), create_target must be cleared for the
/// same reason: the op-log has advanced, old ids may be gone.
#[test]
fn test_redo_key_clears_create_target() {
    skip_if_no_jj!();
    let repo = TestRepo::new();
    repo.jj(&["describe", "-m", "original"]);
    repo.jj(&["describe", "-m", "changed"]);

    // Use new_for_test() to avoid a spurious jj subprocess against the CWD.
    let mut app = tij::app::App::new_for_test();
    app.jj = JjExecutor::with_repo_path(repo.path());

    // Perform an undo first (via key) so that a redo target exists.
    use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
    app.on_key_event(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::NONE));

    // Pre-set a stale target.
    app.create_target = Some("stale-change-id".to_string());

    // Trigger redo via Ctrl+R.
    app.on_key_event(KeyEvent::new(KeyCode::Char('r'), KeyModifiers::CONTROL));

    assert_eq!(
        app.create_target, None,
        "redo (Ctrl+R) must clear create_target; stale id survived the redo"
    );
}