23965955605

Committed 03 Apr 2026 11:26PM UTC coverage: 74.122%. First build

Build # 23965955605

Build Type

Pull #1406

github

Committed by

web-flow

Commit Message

Merge 4d2eeb87b into abbfa3d0f

Pull Request Pull Request #1406: Adds tag support to lines through lua.

Coverage Stats

474 of 608 new or added lines in 12 files covered. (77.96%)

10168 of 13718 relevant lines covered (74.12%)

672.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.6

/src/ui/headless_screen.rs

use std::io::Write;

use anyhow::bail;

use super::UserInterface;

pub struct HeadlessScreen {}

impl UserInterface for HeadlessScreen {
    fn setup(&mut self) -> anyhow::Result<()> {
        Ok(())
    }

    fn print_error(&mut self, output: &str) {
        println!("[!!] {output}");
    }

    fn print_info(&mut self, output: &str) {
        println!("[**] {output}");
    }

    fn print_output(&mut self, line: &crate::model::Line) {
        println!("[<<] {line}");
    }

    fn print_prompt(&mut self, prompt: &crate::model::Line) {
        println!("[%%] {prompt}");
    }

    fn print_prompt_input(&mut self, _input: &str, _pos: usize) {}

    fn print_send(&mut self, send: &crate::model::Line) {
        if let Some(print_line) = send.print_line() {
            println!("[>>] {print_line}");
        }
    }

    fn reset(&mut self) -> anyhow::Result<()> {
        Ok(())
    }

    fn reset_scroll(&mut self) -> anyhow::Result<()> {
        Ok(())
    }

    fn clear_output_area(&mut self) -> anyhow::Result<()> {
        // No-op for headless screen
        Ok(())
    }

    fn scroll_down(&mut self) -> anyhow::Result<()> {
        Ok(())
    }

    fn scroll_lock(&mut self, _lock: bool) -> anyhow::Result<()> {
        Ok(())
    }

    fn scroll_to(&mut self, _row: usize) -> anyhow::Result<()> {
        Ok(())
    }

    fn scroll_top(&mut self) -> anyhow::Result<()> {
        Ok(())
    }

    fn scroll_up(&mut self) -> anyhow::Result<()> {
        Ok(())
    }

    fn find_up(&mut self, _pattern: &crate::model::Regex) -> anyhow::Result<()> {
        Ok(())
    }

    fn find_down(&mut self, _pattern: &crate::model::Regex) -> anyhow::Result<()> {
        Ok(())
    }

    fn set_host(&mut self, _host: &str, _port: u16) -> anyhow::Result<()> {
        Ok(())
    }

    fn add_tag(&mut self, _proto: &str) -> anyhow::Result<()> {
        Ok(())
    }

    fn remove_tag(&mut self, _proto: &str) -> anyhow::Result<()> {
        Ok(())
    }

    fn clear_tags(&mut self) -> anyhow::Result<()> {
        Ok(())
    }

    fn set_status_area_height(&mut self, _height: u16) -> anyhow::Result<()> {
        Ok(())
    }

    fn set_show_tags(&mut self, _show: bool) -> anyhow::Result<()> {
        Ok(())
    }

    fn set_tag_mask(&mut self, _mask: crate::model::TagMask) {}

    fn set_status_line(&mut self, _line: usize, _info: String) -> anyhow::Result<()> {
        Ok(())
    }

    fn flush(&mut self) {
        std::io::stdout().flush().ok();
    }

    fn width(&self) -> u16 {
        0
    }

    fn height(&self) -> u16 {
        0
    }

    fn destroy(
        self: Box<Self>,
    ) -> anyhow::Result<(Box<dyn std::io::Write>, super::history::History)> {
        bail!("Can't destroy a headless ui")
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::model::{Line, Regex};

    #[test]
    fn test_headless_screen_setup() {
        let mut screen = HeadlessScreen {};
        assert!(screen.setup().is_ok());
    }

    #[test]
    fn test_headless_screen_reset() {
        let mut screen = HeadlessScreen {};
        assert!(screen.reset().is_ok());
    }

    #[test]
    fn test_headless_screen_reset_scroll() {
        let mut screen = HeadlessScreen {};
        assert!(screen.reset_scroll().is_ok());
    }

    #[test]
    fn test_headless_screen_scroll_down() {
        let mut screen = HeadlessScreen {};
        assert!(screen.scroll_down().is_ok());
    }

    #[test]
    fn test_headless_screen_scroll_up() {
        let mut screen = HeadlessScreen {};
        assert!(screen.scroll_up().is_ok());
    }

    #[test]
    fn test_headless_screen_scroll_lock() {
        let mut screen = HeadlessScreen {};
        assert!(screen.scroll_lock(true).is_ok());
        assert!(screen.scroll_lock(false).is_ok());
    }

    #[test]
    fn test_headless_screen_scroll_to() {
        let mut screen = HeadlessScreen {};
        assert!(screen.scroll_to(100).is_ok());
    }

    #[test]
    fn test_headless_screen_scroll_top() {
        let mut screen = HeadlessScreen {};
        assert!(screen.scroll_top().is_ok());
    }

    #[test]
    fn test_headless_screen_find_up() {
        let mut screen = HeadlessScreen {};
        let pattern = Regex::new("test", None).unwrap();
        assert!(screen.find_up(&pattern).is_ok());
    }

    #[test]
    fn test_headless_screen_find_down() {
        let mut screen = HeadlessScreen {};
        let pattern = Regex::new("test", None).unwrap();
        assert!(screen.find_down(&pattern).is_ok());
    }

    #[test]
    fn test_headless_screen_set_host() {
        let mut screen = HeadlessScreen {};
        assert!(screen.set_host("example.com", 4000).is_ok());
    }

    #[test]
    fn test_headless_screen_add_tag() {
        let mut screen = HeadlessScreen {};
        assert!(screen.add_tag("GMCP").is_ok());
    }

    #[test]
    fn test_headless_screen_remove_tag() {
        let mut screen = HeadlessScreen {};
        assert!(screen.remove_tag("GMCP").is_ok());
    }

    #[test]
    fn test_headless_screen_clear_tags() {
        let mut screen = HeadlessScreen {};
        assert!(screen.clear_tags().is_ok());
    }

    #[test]
    fn test_headless_screen_set_status_area_height() {
        let mut screen = HeadlessScreen {};
        assert!(screen.set_status_area_height(5).is_ok());
    }

    #[test]
    fn test_headless_screen_set_status_line() {
        let mut screen = HeadlessScreen {};
        assert!(screen.set_status_line(0, "Status".to_string()).is_ok());
    }

    #[test]
    fn test_headless_screen_width() {
        let screen = HeadlessScreen {};
        assert_eq!(screen.width(), 0);
    }

    #[test]
    fn test_headless_screen_height() {
        let screen = HeadlessScreen {};
        assert_eq!(screen.height(), 0);
    }

    #[test]
    fn test_headless_screen_destroy_fails() {
        let screen = Box::new(HeadlessScreen {});
        let result = screen.destroy();
        assert!(result.is_err());
        if let Err(e) = result {
            assert!(e.to_string().contains("Can't destroy"));
        }
    }

    #[test]
    fn test_headless_screen_print_and_flush_methods() {
        // Consolidate all void-returning print/flush methods into one test
        // These methods just write to stdout and don't return values to assert on
        let mut screen = HeadlessScreen {};
        let line = Line::from("test content");

        // Test all print methods complete without panic
        screen.print_error("test error");
        screen.print_info("test info");
        screen.print_output(&line);
        screen.print_prompt(&line);
        screen.print_send(&line);
        screen.print_prompt_input("test input", 5);
        screen.flush();

        // If we got here, all methods executed successfully
        assert!(true);
    }
}

1	use std::io::Write;
2
3	use anyhow::bail;
4
5	use super::UserInterface;
6
7	pub struct HeadlessScreen {}
8
9	impl UserInterface for HeadlessScreen {
10	fn setup(&mut self) -> anyhow::Result<()> {	137✔
11	Ok(())	137✔
12	}	137✔
13
14	fn print_error(&mut self, output: &str) {	49✔
15	println!("[!!] {output}");	49✔
16	}	49✔
17
18	fn print_info(&mut self, output: &str) {	497✔
19	println!("[**] {output}");	497✔
20	}	497✔
21
22	fn print_output(&mut self, line: &crate::model::Line) {	233✔
23	println!("[<<] {line}");	233✔
24	}	233✔
25
26	fn print_prompt(&mut self, prompt: &crate::model::Line) {	153✔
27	println!("[%%] {prompt}");	153✔
28	}	153✔
29
30	fn print_prompt_input(&mut self, _input: &str, _pos: usize) {}	1✔
31
32	fn print_send(&mut self, send: &crate::model::Line) {	65✔
33	if let Some(print_line) = send.print_line() {	65✔
34	println!("[>>] {print_line}");	65✔
35	}	65✔
36	}	65✔
37
38	fn reset(&mut self) -> anyhow::Result<()> {	137✔
39	Ok(())	137✔
40	}	137✔
41
42	fn reset_scroll(&mut self) -> anyhow::Result<()> {	1✔
43	Ok(())	1✔
44	}	1✔
45
46	fn clear_output_area(&mut self) -> anyhow::Result<()> {	×
47	// No-op for headless screen
48	Ok(())	×
49	}	×
50
51	fn scroll_down(&mut self) -> anyhow::Result<()> {	1✔
52	Ok(())	1✔
53	}	1✔
54
55	fn scroll_lock(&mut self, _lock: bool) -> anyhow::Result<()> {	2✔
56	Ok(())	2✔
57	}	2✔
58
59	fn scroll_to(&mut self, _row: usize) -> anyhow::Result<()> {	1✔
60	Ok(())	1✔
61	}	1✔
62
63	fn scroll_top(&mut self) -> anyhow::Result<()> {	1✔
64	Ok(())	1✔
65	}	1✔
66
67	fn scroll_up(&mut self) -> anyhow::Result<()> {	1✔
68	Ok(())	1✔
69	}	1✔
70
71	fn find_up(&mut self, _pattern: &crate::model::Regex) -> anyhow::Result<()> {	1✔
72	Ok(())	1✔
73	}	1✔
74
75	fn find_down(&mut self, _pattern: &crate::model::Regex) -> anyhow::Result<()> {	1✔
76	Ok(())	1✔
77	}	1✔
78
79	fn set_host(&mut self, _host: &str, _port: u16) -> anyhow::Result<()> {	193✔
80	Ok(())	193✔
81	}	193✔
82
83	fn add_tag(&mut self, _proto: &str) -> anyhow::Result<()> {	33✔
84	Ok(())	33✔
85	}	33✔
86
87	fn remove_tag(&mut self, _proto: &str) -> anyhow::Result<()> {	1✔
88	Ok(())	1✔
89	}	1✔
90
91	fn clear_tags(&mut self) -> anyhow::Result<()> {	97✔
92	Ok(())	97✔
93	}	97✔
94
95	fn set_status_area_height(&mut self, _height: u16) -> anyhow::Result<()> {	1✔
96	Ok(())	1✔
97	}	1✔
98
NEW 99	fn set_show_tags(&mut self, _show: bool) -> anyhow::Result<()> {	×
NEW 100	Ok(())	×
NEW 101	}	×
102
NEW 103	fn set_tag_mask(&mut self, _mask: crate::model::TagMask) {}	×
104
105	fn set_status_line(&mut self, _line: usize, _info: String) -> anyhow::Result<()> {	1✔
106	Ok(())	1✔
107	}	1✔
108
109	fn flush(&mut self) {	3,137✔
110	std::io::stdout().flush().ok();	3,137✔
111	}	3,137✔
112
113	fn width(&self) -> u16 {	33✔
114	0	33✔
115	}	33✔
116
117	fn height(&self) -> u16 {	33✔
118	0	33✔
119	}	33✔
120
121	fn destroy(	1✔
122	self: Box<Self>,	1✔
123	) -> anyhow::Result<(Box<dyn std::io::Write>, super::history::History)> {	1✔
124	bail!("Can't destroy a headless ui")	1✔
125	}	1✔
126	}
127
128	#[cfg(test)]
129	mod tests {
130	use super::*;
131	use crate::model::{Line, Regex};
132
133	#[test]
134	fn test_headless_screen_setup() {	1✔
135	let mut screen = HeadlessScreen {};	1✔
136	assert!(screen.setup().is_ok());	1✔
137	}	1✔
138
139	#[test]
140	fn test_headless_screen_reset() {	1✔
141	let mut screen = HeadlessScreen {};	1✔
142	assert!(screen.reset().is_ok());	1✔
143	}	1✔
144
145	#[test]
146	fn test_headless_screen_reset_scroll() {	1✔
147	let mut screen = HeadlessScreen {};	1✔
148	assert!(screen.reset_scroll().is_ok());	1✔
149	}	1✔
150
151	#[test]
152	fn test_headless_screen_scroll_down() {	1✔
153	let mut screen = HeadlessScreen {};	1✔
154	assert!(screen.scroll_down().is_ok());	1✔
155	}	1✔
156
157	#[test]
158	fn test_headless_screen_scroll_up() {	1✔
159	let mut screen = HeadlessScreen {};	1✔
160	assert!(screen.scroll_up().is_ok());	1✔
161	}	1✔
162
163	#[test]
164	fn test_headless_screen_scroll_lock() {	1✔
165	let mut screen = HeadlessScreen {};	1✔
166	assert!(screen.scroll_lock(true).is_ok());	1✔
167	assert!(screen.scroll_lock(false).is_ok());	1✔
168	}	1✔
169
170	#[test]
171	fn test_headless_screen_scroll_to() {	1✔
172	let mut screen = HeadlessScreen {};	1✔
173	assert!(screen.scroll_to(100).is_ok());	1✔
174	}	1✔
175
176	#[test]
177	fn test_headless_screen_scroll_top() {	1✔
178	let mut screen = HeadlessScreen {};	1✔
179	assert!(screen.scroll_top().is_ok());	1✔
180	}	1✔
181
182	#[test]
183	fn test_headless_screen_find_up() {	1✔
184	let mut screen = HeadlessScreen {};	1✔
185	let pattern = Regex::new("test", None).unwrap();	1✔
186	assert!(screen.find_up(&pattern).is_ok());	1✔
187	}	1✔
188
189	#[test]
190	fn test_headless_screen_find_down() {	1✔
191	let mut screen = HeadlessScreen {};	1✔
192	let pattern = Regex::new("test", None).unwrap();	1✔
193	assert!(screen.find_down(&pattern).is_ok());	1✔
194	}	1✔
195
196	#[test]
197	fn test_headless_screen_set_host() {	1✔
198	let mut screen = HeadlessScreen {};	1✔
199	assert!(screen.set_host("example.com", 4000).is_ok());	1✔
200	}	1✔
201
202	#[test]
203	fn test_headless_screen_add_tag() {	1✔
204	let mut screen = HeadlessScreen {};	1✔
205	assert!(screen.add_tag("GMCP").is_ok());	1✔
206	}	1✔
207
208	#[test]
209	fn test_headless_screen_remove_tag() {	1✔
210	let mut screen = HeadlessScreen {};	1✔
211	assert!(screen.remove_tag("GMCP").is_ok());	1✔
212	}	1✔
213
214	#[test]
215	fn test_headless_screen_clear_tags() {	1✔
216	let mut screen = HeadlessScreen {};	1✔
217	assert!(screen.clear_tags().is_ok());	1✔
218	}	1✔
219
220	#[test]
221	fn test_headless_screen_set_status_area_height() {	1✔
222	let mut screen = HeadlessScreen {};	1✔
223	assert!(screen.set_status_area_height(5).is_ok());	1✔
224	}	1✔
225
226	#[test]
227	fn test_headless_screen_set_status_line() {	1✔
228	let mut screen = HeadlessScreen {};	1✔
229	assert!(screen.set_status_line(0, "Status".to_string()).is_ok());	1✔
230	}	1✔
231
232	#[test]
233	fn test_headless_screen_width() {	1✔
234	let screen = HeadlessScreen {};	1✔
235	assert_eq!(screen.width(), 0);	1✔
236	}	1✔
237
238	#[test]
239	fn test_headless_screen_height() {	1✔
240	let screen = HeadlessScreen {};	1✔
241	assert_eq!(screen.height(), 0);	1✔
242	}	1✔
243
244	#[test]
245	fn test_headless_screen_destroy_fails() {	1✔
246	let screen = Box::new(HeadlessScreen {});	1✔
247	let result = screen.destroy();	1✔
248	assert!(result.is_err());	1✔
249	if let Err(e) = result {	1✔
250	assert!(e.to_string().contains("Can't destroy"));	1✔
251	}	×
252	}	1✔
253
254	#[test]
255	fn test_headless_screen_print_and_flush_methods() {	1✔
256	// Consolidate all void-returning print/flush methods into one test
257	// These methods just write to stdout and don't return values to assert on
258	let mut screen = HeadlessScreen {};	1✔
259	let line = Line::from("test content");	1✔
260
261	// Test all print methods complete without panic
262	screen.print_error("test error");	1✔
263	screen.print_info("test info");	1✔
264	screen.print_output(&line);	1✔
265	screen.print_prompt(&line);	1✔
266	screen.print_send(&line);	1✔
267	screen.print_prompt_input("test input", 5);	1✔
268	screen.flush();	1✔
269
270	// If we got here, all methods executed successfully
271	assert!(true);	1✔
272	}	1✔
273	}

Blightmud / Blightmud / 23965955605

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous