lernie 0.1.82

lernie: the operator seat — the window and wire client for a yog server
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

//! The switcher: Ctrl+X opens it, the roster stands in it, walking keeps it,
//! choosing closes it.

use super::{HEADING, WORD};
use crate::paint_probe::frame::{Window, press};
use crate::test_support::window::{click, escape, painted, seated};
use crate::ui::Model;

/// **The one chord, as the platform delivers it**: egui-winit turns Ctrl+X
/// into `Event::Cut` and sends no key at all (bl-8c49), so a beat that
/// pressed `Key::X` with the command modifier proved a chord no window sees.
fn ctrl_x(window: &Window, model: &mut Model) {
    window.frame(vec![egui::Event::Cut], |ctx| crate::ui::render(ctx, model));
}

/// **Ctrl+X toggles it, from the box too**, and `/conversations` opens it.
#[test]
fn ctrl_x_toggles_it_and_the_word_opens_it() {
    let mut model = seated();
    let window = Window::new();
    ctrl_x(&window, &mut model);
    assert!(model.switching);
    window.focus(egui::Id::new(crate::ui::keys::BOX_ID));
    ctrl_x(&window, &mut model);
    assert!(!model.switching);
    assert!(crate::ui::slash::fire(&mut model, WORD, ""));
    assert!(model.switching);
}

/// **The chord is the switcher's, not the box's**: with the caret in a draft
/// whose words are all selected, Ctrl+X opens the switcher and cuts nothing.
#[test]
fn ctrl_x_in_the_box_cuts_nothing() {
    let mut model = seated();
    "keep every word".clone_into(&mut model.draft);
    let window = Window::new();
    let id = egui::Id::new(crate::ui::keys::BOX_ID);
    window.focus(id);
    window.frame(Vec::new(), |ctx| {
        crate::ui::render(ctx, &mut model);
        let mut state = egui::text_edit::TextEditState::load(ctx, id).unwrap_or_default();
        state
            .cursor
            .set_char_range(Some(egui::text::CCursorRange::two(
                egui::text::CCursor::new(0),
                egui::text::CCursor::new(model.draft.len()),
            )));
        state.store(ctx, id);
    });
    ctrl_x(&window, &mut model);
    window.frame(Vec::new(), |ctx| crate::ui::render(ctx, &mut model));
    assert!(model.switching);
    assert_eq!(model.draft, "keep every word");
}

/// **The roster stands in it, under its name, and the prompt stands down.**
#[test]
fn the_roster_stands_in_it() {
    let mut model = seated();
    model.switching = true;
    let text = painted(&mut model);
    for word in [HEADING, "home", "port the paint probe"] {
        assert!(text.contains(word), "{word:?}:\n{text}");
    }
    assert!(!text.contains(crate::ui::composer::HINT), "{text}");
}

/// **Walking keeps it open; a click on a conversation, Enter on the
/// selection and Esc close it.**
#[test]
fn walking_keeps_it_open_and_choosing_closes_it() {
    let mut model = seated();
    model.switching = true;
    let window = Window::new();
    window.frame(vec![press(egui::Key::ArrowDown)], |ctx| {
        crate::ui::render(ctx, &mut model);
    });
    assert!(model.switching, "the walk keeps it");
    window.frame(vec![press(egui::Key::Enter)], |ctx| {
        crate::ui::render(ctx, &mut model);
    });
    assert!(!model.switching, "Enter on the selection chooses");

    let mut model = seated();
    model.switching = true;
    let label = crate::ui::convs::headline(&model.convs[0]);
    click(&window, &label, |ctx| crate::ui::render(ctx, &mut model));
    assert!(!model.switching, "a click chooses");
    assert_eq!(model.conversation.as_deref(), Some("20260830T051200Z-a1b2"));

    let mut model = seated();
    model.switching = true;
    escape(&window, |ctx| crate::ui::render(ctx, &mut model));
    assert!(!model.switching, "Esc leaves");
}

/// **`+ new` chooses too**: it begins a conversation, which is what the
/// switcher was opened for.
#[test]
fn the_plus_closes_it_on_the_way_to_the_box() {
    let mut model = seated();
    model.switching = true;
    let window = Window::new();
    click(&window, crate::ui::roster::wall::NEW, |ctx| {
        crate::ui::render(ctx, &mut model);
    });
    assert!(!model.switching);
    assert_eq!(model.conversation, None);
}

/// **A keyboard walk onto an engine's row brings it into view** in the
/// switcher, as it did in the column: the row the cursor stands on is
/// scrolled to when the walk says the list owes it a place.
#[test]
fn the_walk_brings_the_standing_engine_into_view() {
    let mut model = seated();
    model.switching = true;
    model.standing = Some("(this box's own engine)".to_owned());
    model.reveal = true;
    let text = painted(&mut model);
    assert!(text.contains("(this box's own engine)"), "{text}");
}