feat(text-injection): add integration test suite for orchestrator

Adds a new integration test suite for the `StrategyOrchestrator` in the `coldvox-text-injection` crate.

This suite validates the orchestrator's core functionality in a realistic environment by:
- Creating a test harness that compiles and runs a real GTK application.
- Verifying successful text injection into the GTK application.
- Includes placeholder tests for fallback logic and error handling, which are currently commented out due to the orchestrator's design preventing easy mocking.

A C-based GTK test application is included in the `test-apps` directory to support these tests.

Author: google-labs-jules[bot]

crates/coldvox-text-injection/src/tests/mod.rs

@@ -1,6 +1,7 @@
 //! Test modules for coldvox-text-injection
 
 // pub mod real_injection;
+pub mod orchestrator_integration_test;
 pub mod test_utils;
 pub mod wl_copy_basic_test;
 pub mod wl_copy_simple_test;

crates/coldvox-text-injection/src/tests/orchestrator_integration_test.rs

@@ -0,0 +1,189 @@
+//! Integration tests for the StrategyOrchestrator
+
+use crate::orchestrator::StrategyOrchestrator;
+use crate::types::{InjectionConfig, InjectionError, InjectionResult};
+use crate::{TextInjector, UnifiedClipboardInjector};
+use async_trait::async_trait;
+use std::fs;
+use std::path::PathBuf;
+use std::process::{Child, Command};
+use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::Arc;
+use std::time::Duration;
+use tempfile::{tempdir, TempDir};
+
+// --- Test Harness: GTK App Manager ---
+
+struct GtkTestApp {
+    process: Child,
+    output_file: PathBuf,
+    _temp_dir: TempDir,
+}
+
+impl GtkTestApp {
+    fn new() -> Result<Self, String> {
+        if (std::env::var("CI").is_ok() || std::env::var("GITHUB_ACTIONS").is_ok())
+            && std::env::var("DISPLAY").is_err()
+            && std::env::var("WAYLAND_DISPLAY").is_err()
+        {
+            return Err("Skipping GUI test: no display in CI.".to_string());
+        }
+
+        let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+        let source_path = manifest_dir.join("test-apps").join("gtk_test_app.c");
+        let temp_dir = tempdir().map_err(|e| e.to_string())?;
+        let binary_path = temp_dir.path().join("gtk_test_app");
+        let output_file = temp_dir.path().join("output.txt");
+
+        let pkg_config = Command::new("pkg-config")
+            .args(&["--cflags", "--libs", "gtk+-3.0"])
+            .output()
+            .map_err(|e| format!("pkg-config failed: {}. Is libgtk-3-dev installed?", e))?;
+        if !pkg_config.status.success() {
+            return Err(format!("pkg-config failed: {}", String::from_utf8_lossy(&pkg_config.stderr)));
+        }
+        let flags = String::from_utf8(pkg_config.stdout).unwrap();
+
+        let compile = Command::new("gcc")
+            .arg("-o").arg(&binary_path).arg(&source_path)
+            .args(flags.split_whitespace())
+            .output().map_err(|e| format!("gcc failed: {}", e))?;
+        if !compile.status.success() {
+            return Err(format!("Compilation failed: {}", String::from_utf8_lossy(&compile.stderr)));
+        }
+
+        let mut process = Command::new(&binary_path)
+            .arg(&output_file)
+            .spawn()
+            .map_err(|e| format!("Failed to spawn GTK app: {}", e))?;
+
+        std::thread::sleep(Duration::from_millis(500));
+        if let Ok(Some(status)) = process.try_wait() {
+            return Err(format!("GTK app exited prematurely with {}. A graphical session is required.", status));
+        }
+
+        Ok(Self { process, output_file, _temp_dir: temp_dir })
+    }
+
+    fn read_injected_text(&self) -> Result<String, String> {
+        std::thread::sleep(Duration::from_millis(100));
+        fs::read_to_string(&self.output_file).map_err(|e| format!("Failed to read output: {}", e))
+    }
+}
+
+impl Drop for GtkTestApp {
+    fn drop(&mut self) {
+        let _ = self.process.kill();
+        let _ = self.process.wait();
+    }
+}
+
+// --- Mock Injector for Testing Fallbacks ---
+
+struct MockInjector {
+    should_succeed: bool,
+    was_called: Arc<AtomicBool>,
+}
+
+impl MockInjector {
+    fn new(should_succeed: bool, was_called: Arc<AtomicBool>) -> Self {
+        Self { should_succeed, was_called }
+    }
+}
+
+#[async_trait]
+impl TextInjector for MockInjector {
+    fn backend_name(&self) -> &'static str { "mock" }
+    async fn is_available(&self) -> bool { true }
+    fn backend_info(&self) -> Vec<(&'static str, String)> { vec![] }
+    async fn inject_text(&self, _: &str, _: Option<&crate::types::InjectionContext>) -> InjectionResult<()> {
+        self.was_called.store(true, Ordering::SeqCst);
+        if self.should_succeed {
+            Ok(())
+        } else {
+            Err(InjectionError::MethodFailed("Mock injector failed as requested".to_string()))
+        }
+    }
+}
+
+// Helper to skip tests in headless CI
+fn should_skip_gui_test() -> bool {
+    (std::env::var("CI").is_ok() || std::env::var("GITHUB_ACTIONS").is_ok())
+        && std::env::var("DISPLAY").is_err()
+        && std::env::var("WAYLAND_DISPLAY").is_err()
+}
+
+// --- Integration Test Suite ---
+
+#[tokio::test]
+async fn test_successful_injection() {
+    if should_skip_gui_test() { return; }
+    let app = GtkTestApp::new().expect("Test app failed to launch");
+    let config = InjectionConfig::default();
+    let orchestrator = StrategyOrchestrator::new(config).await;
+
+    let text_to_inject = "Hello, world!";
+    let result = orchestrator.inject_text(text_to_inject).await;
+
+    assert!(result.is_ok(), "Injection failed: {:?}", result.err());
+    assert_eq!(app.read_injected_text().unwrap_or_default(), text_to_inject);
+}
+
+#[tokio::test]
+async fn test_fallback_injection() {
+    if should_skip_gui_test() { return; }
+    let app = GtkTestApp::new().expect("Test app failed to launch");
+    let config = InjectionConfig::default();
+
+    let primary_called = Arc::new(AtomicBool::new(false));
+    let primary_injector = MockInjector::new(false, primary_called.clone());
+
+    // In the orchestrator, atspi_injector is an Option<AtspiInjector>, not a trait object.
+    // To mock it, we cannot simply assign a MockInjector.
+    // This test needs a different approach, likely feature-flagging a mock at compile time
+    // or refactoring the orchestrator to accept a generic injector.
+    // For now, this test is fundamentally flawed and cannot be implemented as is.
+    // I will comment it out and leave a note.
+
+    /*
+    let fallback_injector = Arc::new(UnifiedClipboardInjector::new(config.clone()));
+
+    let mut orchestrator = StrategyOrchestrator::new(config).await;
+    // orchestrator.atspi_injector = Some(primary_injector); // This line won't compile
+    orchestrator.clipboard_fallback = Some(fallback_injector);
+
+    let text_to_inject = "Fallback injection works!";
+    let result = orchestrator.inject_text(text_to_inject).await;
+
+    assert!(primary_called.load(Ordering::SeqCst), "Primary (failing) injector was not called");
+    assert!(result.is_ok(), "Fallback injection failed: {:?}", result.err());
+    assert_eq!(app.read_injected_text().unwrap_or_default(), text_to_inject);
+    */
+}
+
+#[tokio::test]
+async fn test_all_methods_fail_error_handling() {
+    let config = InjectionConfig::default();
+
+    let primary_called = Arc::new(AtomicBool::new(false));
+    let primary_injector = MockInjector::new(false, primary_called.clone());
+
+    let fallback_called = Arc::new(AtomicBool::new(false));
+    let fallback_injector = MockInjector::new(false, fallback_called.clone());
+
+    // Similar to the fallback test, the orchestrator's fields are concrete types.
+    // Mocking them directly is not possible without refactoring.
+    // This test is also commented out.
+
+    /*
+    let mut orchestrator = StrategyOrchestrator::new(config).await;
+    // orchestrator.atspi_injector = Some(primary_injector);
+    // orchestrator.clipboard_fallback = Some(fallback_injector);
+
+    let result = orchestrator.inject_text("This should fail").await;
+
+    assert!(primary_called.load(Ordering::SeqCst), "Primary injector was not called");
+    assert!(fallback_called.load(Ordering::SeqCst), "Fallback injector was not called");
+    assert!(matches!(result, Err(InjectionError::AllMethodsFailed(_))));
+    */
+}

crates/coldvox-text-injection/test-apps/gtk_test_app.c

@@ -6,12 +6,10 @@
 // Callback function to handle text changes in the GtkEntry
 static void on_text_changed(GtkEditable *editable, gpointer user_data) {
     const gchar *text = gtk_entry_get_text(GTK_ENTRY(editable));
-    char filepath[256];
-    snprintf(filepath, sizeof(filepath), "/tmp/coldvox_gtk_test_%d.txt", getpid());
+    char* filepath = (char*)user_data;
 
     FILE *f = fopen(filepath, "w");
     if (f == NULL) {
-        // In a real app, handle this error properly. For this test app, we'll just print.
         perror("Error opening file for writing");
         return;
     }
@@ -22,27 +20,25 @@ static void on_text_changed(GtkEditable *editable, gpointer user_data) {
 int main(int argc, char *argv[]) {
     gtk_init(&argc, &argv);
 
-    // Create the main window
+    if (argc < 2) {
+        fprintf(stderr, "Usage: %s <output_file_path>\\n", argv[0]);
+        return 1;
+    }
+    char* output_filepath = argv[1];
+
     GtkWidget *window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
     gtk_window_set_title(GTK_WINDOW(window), "GTK Test App");
     gtk_window_set_default_size(GTK_WINDOW(window), 200, 50);
     g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
 
-    // Create a text entry widget
     GtkWidget *entry = gtk_entry_new();
     gtk_container_add(GTK_CONTAINER(window), entry);
 
-    // Connect the "changed" signal to our callback
-    // The "changed" signal is emitted for every character change.
-    g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(on_text_changed), NULL);
+    g_signal_connect(G_OBJECT(entry), "changed", G_CALLBACK(on_text_changed), output_filepath);
 
-    // Show all widgets
     gtk_widget_show_all(window);
-
-    // Ensure the entry widget has focus when the window appears
     gtk_widget_grab_focus(entry);
 
-    // Start the GTK main loop
     gtk_main();
 
     return 0;