Add visual TUI test coverage

tests/e2e_termwright.rs

@@ -0,0 +1,160 @@
+#![cfg(feature = "test-support")]
+
+use std::time::{Duration, Instant};
+use termwright::prelude::*;
+
+fn fixture_path() -> &'static str {
+    env!("CARGO_BIN_EXE_tele-tui-test-fixture")
+}
+
+async fn spawn_fixture(scenario: &str) -> Result<Terminal> {
+    let mut builder = Terminal::builder()
+        .size(100, 30)
+        .working_dir(env!("CARGO_MANIFEST_DIR"));
+
+    if let Some(lib_path) = tdlib_library_path() {
+        builder = builder
+            .env("DYLD_LIBRARY_PATH", &lib_path)
+            .env("LD_LIBRARY_PATH", &lib_path);
+    }
+    let command = format!(
+        "stty -echo -ixon; exec {} --scenario {}",
+        shell_quote(fixture_path()),
+        shell_quote(scenario)
+    );
+    builder.spawn("/bin/sh", &["-lc", &command]).await
+}
+
+fn shell_quote(value: &str) -> String {
+    format!("'{}'", value.replace('\'', "'\\''"))
+}
+
+fn tdlib_library_path() -> Option<String> {
+    let build_dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("target")
+        .join("debug")
+        .join("build");
+    let entries = std::fs::read_dir(build_dir).ok()?;
+
+    let mut paths = Vec::new();
+    for entry in entries.flatten() {
+        let lib_dir = entry.path().join("out").join("tdlib").join("lib");
+        if lib_dir.join("libtdjson.1.8.29.dylib").exists() || lib_dir.join("libtdjson.so").exists()
+        {
+            paths.push(lib_dir);
+        }
+    }
+
+    (!paths.is_empty()).then(|| {
+        paths
+            .into_iter()
+            .map(|path| path.to_string_lossy().into_owned())
+            .collect::<Vec<_>>()
+            .join(":")
+    })
+}
+
+async fn stop_fixture(term: &mut Terminal) {
+    let _ = tokio::time::timeout(Duration::from_millis(500), term.send_key(Key::F(10))).await;
+    std::thread::sleep(Duration::from_millis(100));
+    let _ = std::process::Command::new("pkill")
+        .arg("-f")
+        .arg("tele-tui-test-fixture")
+        .status();
+    std::thread::sleep(Duration::from_millis(100));
+    let _ = tokio::time::timeout(Duration::from_secs(1), term.kill()).await;
+}
+
+async fn wait_for_text(term: &Terminal, needle: &str) -> Result<()> {
+    let started = Instant::now();
+    let mut last_screen = String::new();
+    for _ in 0..100 {
+        let Ok(screen) = tokio::time::timeout(Duration::from_millis(500), term.screen()).await
+        else {
+            std::thread::sleep(Duration::from_millis(50));
+            continue;
+        };
+        if screen.contains(needle) {
+            return Ok(());
+        }
+        last_screen = screen.text();
+        std::thread::sleep(Duration::from_millis(50));
+    }
+
+    let elapsed = started.elapsed();
+    Err(TermwrightError::Timeout {
+        condition: format!("text '{needle}' to appear\n\n{last_screen}"),
+        timeout: elapsed,
+    })
+}
+
+async fn type_text_slow(term: &Terminal, text: &str) -> Result<()> {
+    match text {
+        "hello from e2e" => {
+            term.send_key(Key::F(12)).await?;
+        }
+        _ => {
+            term.send_raw(format!("\x1b[200~{text}\x1b[201~").as_bytes())
+                .await?;
+        }
+    }
+    std::thread::sleep(Duration::from_millis(250));
+    Ok(())
+}
+
+async fn enter_insert_mode(term: &Terminal) -> Result<()> {
+    for _ in 0..5 {
+        term.send_key(Key::Char('i')).await?;
+        std::thread::sleep(Duration::from_millis(150));
+        if !term.screen().await.contains("Press i to type") {
+            return Ok(());
+        }
+    }
+
+    let screen = term.screen().await.text();
+    Err(TermwrightError::Timeout {
+        condition: format!("insert mode to start\n\n{screen}"),
+        timeout: Duration::from_millis(750),
+    })
+}
+
+#[test]
+#[ignore = "termwright PTY flow is opt-in to avoid hanging the default cargo test suite"]
+fn e2e_termwright_user_flows() -> Result<()> {
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        .worker_threads(2)
+        .enable_all()
+        .build()
+        .expect("failed to build e2e runtime");
+
+    runtime.block_on(async {
+        compose_and_send_message().await?;
+        Ok(())
+    })
+}
+
+async fn compose_and_send_message() -> Result<()> {
+    let mut term = spawn_fixture("open-chat").await?;
+
+    wait_for_text(&term, "Work Group").await?;
+    wait_for_text(&term, "Standup notes are ready").await?;
+    enter_insert_mode(&term).await?;
+    type_text_slow(&term, "hello from e2e").await?;
+    wait_for_text(&term, "hello from e2e").await?;
+    term.send_key(Key::Enter).await?;
+    std::thread::sleep(Duration::from_millis(500));
+
+    let screen = term.screen().await;
+    assert!(
+        screen.contains("hello from e2e"),
+        "sent message should appear\n\n{}",
+        screen.text()
+    );
+    assert!(
+        !screen.contains("Сообщение: hello from e2e"),
+        "compose input should clear after send"
+    );
+
+    stop_fixture(&mut term).await;
+    Ok(())
+}