testty 0.10.5

Rust-native TUI end-to-end testing framework using PTY-driven semantic assertions, native frame rendering, and VHS-driven GIF capture.
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

//! Frame-text proof backend.
//!
//! [`FrameTextBackend`] renders a [`ProofReport`](super::report::ProofReport)
//! as annotated plain text, producing the same output as
//! [`ProofReport::to_annotated_text()`](super::report::ProofReport::to_annotated_text)
//! but routed through the [`ProofBackend`](super::backend::ProofBackend) trait.

use super::backend::{ProofBackend, RenderContext};
use super::report::ProofError;

/// Renders a proof report as annotated plain-text frame dumps.
///
/// This is the simplest backend, writing each captured frame as a
/// bordered text block with step labels, descriptions, and assertion
/// markers. The output is identical to [`ProofReport::to_annotated_text()`].
pub struct FrameTextBackend;

impl ProofBackend for FrameTextBackend {
    /// Write the annotated text proof to the given output path.
    ///
    /// # Errors
    ///
    /// Returns a [`ProofError::Io`] if writing the file fails.
    fn render(&self, context: &RenderContext<'_>) -> Result<(), ProofError> {
        let text = context.report.to_annotated_text();
        std::fs::write(context.output, text)?;

        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::frame::TerminalFrame;
    use crate::proof::report::ProofReport;

    #[test]
    fn frame_text_backend_produces_same_output_as_to_annotated_text() {
        // Arrange
        let frame = TerminalFrame::new(40, 5, b"Hello proof");
        let mut report = ProofReport::new("consistency_check");
        report.add_capture("init", "Initial state", &frame);
        report.add_capture("done", "Final state", &frame);

        let expected = report.to_annotated_text();
        let temp_dir = tempfile::tempdir().expect("failed to create temp dir");
        let output_path = temp_dir.path().join("proof.txt");

        // Act
        let backend = FrameTextBackend;
        backend
            .render(&RenderContext::new(&report, &output_path))
            .expect("render should succeed");

        // Assert
        let written = std::fs::read_to_string(&output_path).expect("failed to read output");
        assert_eq!(written, expected);
    }

    #[test]
    fn frame_text_backend_writes_valid_file() {
        // Arrange
        let frame = TerminalFrame::new(80, 24, b"Test content");
        let mut report = ProofReport::new("file_test");
        report.add_capture("snap", "Snapshot", &frame);
        report.add_assertion("snap", true, "content visible");

        let temp_dir = tempfile::tempdir().expect("failed to create temp dir");
        let output_path = temp_dir.path().join("proof_output.txt");

        // Act
        let backend = FrameTextBackend;
        backend
            .render(&RenderContext::new(&report, &output_path))
            .expect("render should succeed");

        // Assert
        let content = std::fs::read_to_string(&output_path).expect("failed to read");
        assert!(content.contains("Proof Report: file_test"));
        assert!(content.contains("[PASS] content visible"));
        assert!(content.contains("Test content"));
    }

    #[test]
    fn save_dispatches_through_backend_trait() {
        // Arrange
        let frame = TerminalFrame::new(40, 5, b"dispatch test");
        let mut report = ProofReport::new("dispatch");
        report.add_capture("step", "Dispatch step", &frame);

        let temp_dir = tempfile::tempdir().expect("failed to create temp dir");
        let output_path = temp_dir.path().join("dispatched.txt");

        // Act
        let backend = FrameTextBackend;
        report
            .save(&backend, &output_path)
            .expect("save should succeed");

        // Assert
        let content = std::fs::read_to_string(&output_path).expect("failed to read");
        assert!(content.contains("dispatch test"));
    }
}