testty 0.7.8

Rust-native TUI end-to-end testing framework using PTY-driven semantic assertions and VHS screenshot 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
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

//! Showcase: Composable journeys and scenario building.
//!
//! Demonstrates how to build reusable [`Journey`] blocks, compose them
//! into [`Scenario`] instances, and build scenarios from raw steps.
//!
//! Run with: `cargo run --example journey_composition -p testty`

#![allow(clippy::print_stdout)]

use testty::journey::Journey;
use testty::scenario::Scenario;
use testty::step::Step;

fn main() {
    println!("=== Testty Journey Composition Showcase ===\n");

    // --- Part 1: Building reusable journeys ---
    println!("--- Part 1: Reusable Journey Building Blocks ---\n");

    let startup = Journey::wait_for_startup(300, 5000);
    println!(
        "  Journey '{}': {} step(s) — {}",
        startup.name,
        startup.steps.len(),
        startup.description.as_deref().unwrap_or("(no description)")
    );

    let navigate_settings = Journey::navigate_with_key("Tab", "Settings", 3000);
    println!(
        "  Journey '{}': {} step(s) — {}",
        navigate_settings.name,
        navigate_settings.steps.len(),
        navigate_settings
            .description
            .as_deref()
            .unwrap_or("(no description)")
    );

    let type_search = Journey::type_and_confirm("hello world");
    println!(
        "  Journey '{}': {} step(s) — {}",
        type_search.name,
        type_search.steps.len(),
        type_search
            .description
            .as_deref()
            .unwrap_or("(no description)")
    );

    let dismiss_dialog = Journey::press_and_wait("Escape", 200);
    println!(
        "  Journey '{}': {} step(s) — {}",
        dismiss_dialog.name,
        dismiss_dialog.steps.len(),
        dismiss_dialog
            .description
            .as_deref()
            .unwrap_or("(no description)")
    );

    let snapshot = Journey::capture_labeled("final_state", "Application final state");
    println!(
        "  Journey '{}': {} step(s) — {}",
        snapshot.name,
        snapshot.steps.len(),
        snapshot
            .description
            .as_deref()
            .unwrap_or("(no description)")
    );

    // --- Part 2: Composing scenarios from journeys ---
    println!("\n--- Part 2: Scenario Composition ---\n");

    let quick_scenario = Scenario::new("smoke_startup")
        .compose(&startup)
        .capture_labeled("launched", "App reached stable state");

    println!(
        "  Scenario '{}': {} steps",
        quick_scenario.name,
        quick_scenario.steps.len(),
    );

    let nav_scenario = Scenario::new("settings_navigation")
        .compose(&startup)
        .compose(&navigate_settings)
        .capture_labeled("settings_visible", "Settings tab is active")
        .compose(&dismiss_dialog);

    println!(
        "  Scenario '{}': {} steps",
        nav_scenario.name,
        nav_scenario.steps.len(),
    );

    let full_scenario = Scenario::new("full_workflow")
        .compose(&startup)
        .compose(&navigate_settings)
        .capture_labeled("settings", "Navigated to settings")
        .compose(&type_search)
        .capture_labeled("searched", "Typed and confirmed search")
        .compose(&dismiss_dialog)
        .compose(&snapshot);

    println!(
        "  Scenario '{}': {} steps",
        full_scenario.name,
        full_scenario.steps.len(),
    );

    // --- Part 3: Build a scenario from raw steps ---
    println!("\n--- Part 3: Raw Step Building ---\n");

    let manual_scenario = Scenario::new("manual_test")
        .step(Step::wait_for_stable_frame(200, 3000))
        .step(Step::write_text("ls -la"))
        .step(Step::press_key("Enter"))
        .step(Step::wait_for_text("total", 5000))
        .step(Step::capture_labeled(
            "listing",
            "Directory listing visible",
        ));

    println!(
        "  Scenario '{}': {} steps (built from raw steps)",
        manual_scenario.name,
        manual_scenario.steps.len(),
    );

    println!("\n=== Journey composition showcase complete! ===");
}