Skip to main content

tinyharness_ui/tui/
backend.rs

1// ── Terminal backend abstraction ──────────────────────────────────────────────
2//
3// All terminal writes go through a `Backend` trait so we can swap real
4// terminal I/O for a test double. This makes the entire TUI testable
5// without needing a real terminal.
6
7use std::io::{self, Write};
8
9use super::terminal::Size;
10
11// ── Backend trait ────────────────────────────────────────────────────────────
12
13/// Abstraction over terminal I/O.
14///
15/// The TUI writes all output through a `Backend` implementation. In
16/// production, `StdioBackend` writes to stdout. In tests, `TestBackend`
17/// captures output in memory.
18pub trait Backend: Write {
19    /// Get the current terminal size (columns, rows).
20    fn size(&self) -> Size;
21
22    /// Flush any buffered output.
23    fn flush(&mut self) -> io::Result<()> {
24        Ok(())
25    }
26}
27
28// ── Stdio backend ────────────────────────────────────────────────────────────
29
30/// Production backend that writes to stdout.
31pub struct StdioBackend {
32    stdout: io::Stdout,
33}
34
35impl StdioBackend {
36    /// Create a new stdio backend.
37    pub fn new() -> io::Result<Self> {
38        Ok(Self {
39            stdout: io::stdout(),
40        })
41    }
42}
43
44impl Default for StdioBackend {
45    fn default() -> Self {
46        Self::new().expect("failed to create StdioBackend")
47    }
48}
49
50impl Write for StdioBackend {
51    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
52        self.stdout.write(buf)
53    }
54
55    fn flush(&mut self) -> io::Result<()> {
56        self.stdout.flush()
57    }
58}
59
60impl Backend for StdioBackend {
61    fn size(&self) -> Size {
62        Size::from_terminal()
63            .unwrap_or_else(|_| Size::from_env().unwrap_or_else(Size::default_size))
64    }
65}
66
67// ── Test backend ─────────────────────────────────────────────────────────────
68
69/// In-memory backend for testing. Captures all output in a buffer.
70pub struct TestBackend {
71    buffer: Vec<u8>,
72    size: Size,
73}
74
75impl TestBackend {
76    /// Create a new test backend with the given terminal size.
77    pub fn new(size: Size) -> Self {
78        Self {
79            buffer: Vec::new(),
80            size,
81        }
82    }
83
84    /// Get a reference to the captured output buffer.
85    pub fn buffer(&self) -> &[u8] {
86        &self.buffer
87    }
88
89    /// Take ownership of the captured output buffer, clearing it.
90    pub fn take_buffer(&mut self) -> Vec<u8> {
91        std::mem::take(&mut self.buffer)
92    }
93
94    /// Check if the captured output contains a specific byte sequence.
95    pub fn contains(&self, needle: &[u8]) -> bool {
96        self.buffer.windows(needle.len()).any(|w| w == needle)
97    }
98}
99
100impl Write for TestBackend {
101    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
102        self.buffer.extend_from_slice(buf);
103        Ok(buf.len())
104    }
105
106    fn flush(&mut self) -> io::Result<()> {
107        Ok(())
108    }
109}
110
111impl Backend for TestBackend {
112    fn size(&self) -> Size {
113        self.size
114    }
115}
116
117#[cfg(test)]
118mod tests {
119    use super::*;
120
121    #[test]
122    fn test_test_backend_write() {
123        let mut backend = TestBackend::new(Size::new(80, 24));
124        backend.write_all(b"hello").unwrap();
125        assert!(backend.contains(b"hello"));
126    }
127
128    #[test]
129    fn test_test_backend_take_buffer() {
130        let mut backend = TestBackend::new(Size::new(80, 24));
131        backend.write_all(b"hello").unwrap();
132        let buf = backend.take_buffer();
133        assert_eq!(&buf, b"hello");
134        assert!(backend.buffer().is_empty());
135    }
136
137    #[test]
138    fn test_test_backend_size() {
139        let backend = TestBackend::new(Size::new(120, 40));
140        let size = backend.size();
141        assert_eq!(size.cols, 120);
142        assert_eq!(size.rows, 40);
143    }
144
145    #[test]
146    fn test_test_backend_contains() {
147        let mut backend = TestBackend::new(Size::new(80, 24));
148        backend.write_all(b"\x1b[?1049h\x1b[2J").unwrap();
149        assert!(backend.contains(b"\x1b[?1049h"));
150        assert!(backend.contains(b"\x1b[2J"));
151        assert!(!backend.contains(b"\x1b[?25l"));
152    }
153
154    #[test]
155    fn test_stdio_backend_new() {
156        // Just verify it can be created
157        let backend = StdioBackend::new();
158        assert!(backend.is_ok());
159    }
160
161    #[test]
162    fn test_stdio_backend_size() {
163        let backend = StdioBackend::new().unwrap();
164        let size = backend.size();
165        // Should return something reasonable (at least 1x1)
166        assert!(size.cols > 0);
167        assert!(size.rows > 0);
168    }
169}