Feat: Implement Rust Testing Framework for Desktop

apps/desktop/package.json

@@ -7,7 +7,8 @@
 		"preparescript": "node scripts/prepare.js",
 		"localdev": "dotenv -e ../../.env -- vinxi dev --port 3001",
 		"build": "vinxi build",
-		"tauri": "tauri"
+		"tauri": "tauri",
+		"test:desktop": "cd src-tauri && cargo test"
 	},
 	"dependencies": {
 		"@aerofoil/rive-solid-canvas": "^2.1.4",

apps/desktop/src-tauri/Cargo.toml

@@ -45,6 +45,18 @@ tauri-plugin-deep-link = "2.2.0"
 tauri-plugin-clipboard-manager = "2.2.1"
 tauri-plugin-opener = "2.2.6"
 
+[[test]]
+name = "tests"
+path = "tests/main.rs"
+
+[dev-dependencies]
+tauri = { workspace = true, features = ["testing"] }
+serde_json = "1.0.111"
+
+[features]
+# DO NOT REMOVE!
+custom-protocol = ["tauri/custom-protocol"]
+
 scap = { workspace = true }
 serde = { workspace = true }
 serde_json = "1.0.111"

apps/desktop/src-tauri/tests/common.rs

@@ -0,0 +1,28 @@
+use std::time::Duration;
+use tauri::App;
+
+pub fn setup_test_app() -> App {
+    let app = tauri::test::mock_app();
+    // Any additional setup for the app can go here
+    app
+}
+
+pub async fn wait_for_event<F, Fut>(app: &App, event_name: &str, trigger: F)
+where
+    F: FnOnce() -> Fut,
+    Fut: std::future::Future<Output = ()>,
+{
+    let mut rx = app.listen_global(event_name, |event| {
+        println!("Received event: {:?}", event);
+    });
+
+    trigger().await;
+
+    let handle = tokio::spawn(async move {
+        tokio::time::timeout(Duration::from_secs(5), rx.recv())
+            .await
+            .expect("event was not received")
+    });
+
+    handle.await.unwrap();
+}

apps/desktop/src-tauri/tests/main.rs

@@ -0,0 +1 @@
+mod recording;

apps/desktop/src-tauri/tests/recording.rs

@@ -0,0 +1,39 @@
+use cap_desktop_lib::{
+    recording::{start_recording, stop_recording, StartRecordingInputs},
+    RecordingMode,
+};
+use common::setup_test_app;
+use scap_targets::available_displays;
+use tauri::Manager;
+
+mod common;
+
+#[tokio::test]
+async fn test_start_and_stop_recording() {
+    let app = setup_test_app();
+    let window = app.get_window("main").unwrap();
+
+    let displays = available_displays().unwrap();
+    let first_display = displays.first().expect("No display found");
+
+    let inputs = StartRecordingInputs {
+        mode: RecordingMode::Instant,
+        target: cap_recording::sources::ScreenCaptureTarget::Display {
+            id: first_display.id(),
+        },
+        ..Default::default()
+    };
+
+    let app_handle = app.handle().clone();
+    let state = app.state::<tauri::async_runtime::Mutex<cap_desktop_lib::App>>();
+
+    start_recording(app_handle.clone(), state.clone(), inputs)
+        .await
+        .expect("Failed to start recording");
+
+    let result = stop_recording(app_handle, state)
+        .await
+        .expect("Failed to stop recording");
+
+    assert!(result.is_some(), "Stopping the recording did not return a completed recording");
+}