Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

12.1 KB
Raw Blame
use super::*;

#[test]
fn disabled_by_default_and_persists() {
    let dir = tempfile::tempdir().unwrap();
    let mut config = Config::default();
    config.workspace_dir = dir.path().to_path_buf();
    assert!(!enabled(&config));
    save(&config, true).unwrap();
    assert!(enabled(&config));
    save(&config, false).unwrap();
    assert!(!enabled(&config));
}

#[test]
fn unreadable_or_corrupt_state_never_enables_desktop() {
    let dir = tempfile::tempdir().unwrap();
    let mut config = Config::default();
    config.workspace_dir = dir.path().to_path_buf();
    let path = state_path(&config);
    std::fs::create_dir_all(path.parent().unwrap()).unwrap();
    std::fs::write(&path, "not json").unwrap();
    assert!(!enabled(&config));
    std::fs::write(&path, r#"{"enabled":"true"}"#).unwrap();
    assert!(!enabled(&config));
    std::fs::remove_file(&path).unwrap();
    std::fs::create_dir(&path).unwrap();
    assert!(!enabled(&config));
    assert!(save(&config, true).is_err());
    assert!(!enabled(&config));
}

#[tokio::test]
async fn disabled_probe_never_calls_the_module() {
    let dir = tempfile::tempdir().unwrap();
    let mut config = Config::default();
    config.workspace_dir = dir.path().to_path_buf();
    let result = probe_with(&config, true, |_| async {
        panic!("disabled probe reached module")
    })
    .await;
    assert!(!result.ok);
    assert_eq!(result.app_count, None);
    assert_eq!(
        result.reason.as_deref(),
        Some("desktop control is unavailable or disabled")
    );
}

#[tokio::test]
async fn disabled_status_reports_local_setting_without_contacting_module() {
    let dir = tempfile::tempdir().unwrap();
    let mut config = Config::default();
    config.workspace_dir = dir.path().to_path_buf();
    let result = status_with(&config, true, || async {
        panic!("disabled status reached module")
    })
    .await;
    assert!(!result.enabled);
    assert!(!result.approvals_enabled);
    assert_eq!(result.accessibility, "unknown");
    assert_eq!(result.screen_recording, "unknown");
    assert_eq!(result.platform, std::env::consts::OS);

    let unsupported = status_with(&config, false, || async {
        panic!("unsupported status reached module")
    })
    .await;
    assert!(!unsupported.supported);
    assert!(unsupported
        .reason
        .as_deref()
        .unwrap()
        .contains("loopback core listener"));
}

// Windows included: its desktop backend has no surfaces yet (#7164).
#[cfg(not(target_os = "macos"))]
#[tokio::test]
async fn enable_request_fails_closed_on_unsupported_platform_without_persisting() {
    let _loopback = test_loopback_guard();
    let dir = tempfile::tempdir().unwrap();
    let mut config = Config::default();
    config.workspace_dir = dir.path().to_path_buf();
    let error = set_enabled(&config, true).await.unwrap_err();
    assert!(error.contains("requires macOS"));
    assert!(!error.contains("Windows"));
    assert!(!enabled(&config));
}

#[tokio::test]
async fn enabled_status_reports_module_permissions_and_errors() {
    use tinycomputer_bus::{DesktopError, DesktopResponse};

    let dir = tempfile::tempdir().unwrap();
    let mut config = Config::default();
    config.workspace_dir = dir.path().to_path_buf();
    save(&config, true).unwrap();

    let permitted = status_with(&config, true, || async {
        Ok(DesktopResponse::ok(
            "permissions",
            serde_json::json!({
                "accessibility":{"state":"granted"},
                "screen_recording":{"state":"not_required"}
            }),
        ))
    })
    .await;
    assert!(permitted.supported && permitted.enabled);
    assert_eq!(permitted.accessibility, "granted");
    assert_eq!(permitted.screen_recording, "not_required");

    let refused = status_with(&config, true, || async {
        Ok(DesktopResponse::err(
            "permissions",
            DesktopError::new("PERM_DENIED", "Grant Accessibility"),
        ))
    })
    .await;
    assert_eq!(refused.reason.as_deref(), Some("Grant Accessibility"));
    assert_eq!(refused.accessibility, "unknown");

    let unavailable = status_with(&config, true, || async {
        Err("module could not start".to_owned())
    })
    .await;
    assert_eq!(
        unavailable.reason.as_deref(),
        Some("module could not start")
    );
}

#[tokio::test]
async fn disabling_desktop_persists_even_if_state_was_enabled() {
    let dir = tempfile::tempdir().unwrap();
    let mut config = Config::default();
    config.workspace_dir = dir.path().to_path_buf();
    save(&config, true).unwrap();
    let result = set_enabled(&config, false).await.unwrap();
    assert!(!result.enabled);
    assert!(!enabled(&config));
}

#[tokio::test]
async fn probe_requires_accessibility_and_snapshot_before_listing_apps() {
    use tinycomputer_bus::{DesktopError, DesktopResponse};

    let dir = tempfile::tempdir().unwrap();
    let mut config = Config::default();
    config.workspace_dir = dir.path().to_path_buf();
    save(&config, true).unwrap();

    let denied = probe_with(&config, true, |member| async move {
        assert_eq!(member, names::methods::PERMISSIONS);
        Ok(DesktopResponse::ok(
            member,
            serde_json::json!({
                "accessibility":{"state":"denied"}
            }),
        ))
    })
    .await;
    assert!(!denied.ok);
    assert_eq!(
        denied.reason.as_deref(),
        Some("Accessibility permission is not granted to the core process")
    );

    let failed = probe_with(&config, true, |member| async move {
        match member {
            names::methods::PERMISSIONS => Ok(DesktopResponse::ok(
                member,
                serde_json::json!({
                    "accessibility":{"state":"granted"}
                }),
            )),
            names::methods::SNAPSHOT => Ok(DesktopResponse::err(
                member,
                DesktopError::new("PERM_DENIED", "Screen Recording required"),
            )),
            _ => panic!("failed snapshot must prevent app listing"),
        }
    })
    .await;
    assert!(!failed.ok);
    assert_eq!(failed.reason.as_deref(), Some("Screen Recording required"));

    let success = probe_with(&config, true, |member| async move {
        Ok(DesktopResponse::ok(
            member,
            match member {
                names::methods::PERMISSIONS => {
                    serde_json::json!({"accessibility":{"state":"granted"}})
                }
                names::methods::SNAPSHOT => serde_json::json!({"elements":[]}),
                names::methods::LIST_APPS => {
                    serde_json::json!({"apps":[{"name":"TextEdit"},{"name":"Finder"}]})
                }
                _ => panic!("unexpected member"),
            },
        ))
    })
    .await;
    assert!(success.ok);
    assert_eq!(success.app_count, Some(2));
    assert!(success.reason.is_none());

    let transport_error = probe_with(&config, true, |member| async move {
        match member {
            names::methods::PERMISSIONS => Ok(DesktopResponse::ok(
                member,
                serde_json::json!({"accessibility":{"state":"granted"}}),
            )),
            names::methods::SNAPSHOT => Ok(DesktopResponse::ok(
                member,
                serde_json::json!({"elements":[]}),
            )),
            names::methods::LIST_APPS => Err("app list bus disconnected".to_owned()),
            _ => panic!("unexpected member"),
        }
    })
    .await;
    assert!(!transport_error.ok);
    assert_eq!(transport_error.app_count, None);
    assert_eq!(
        transport_error.reason.as_deref(),
        Some("app list bus disconnected")
    );

    let module_error = probe_with(&config, true, |member| async move {
        match member {
            names::methods::PERMISSIONS => Ok(DesktopResponse::ok(
                member,
                serde_json::json!({"accessibility":{"state":"granted"}}),
            )),
            names::methods::SNAPSHOT => Ok(DesktopResponse::ok(
                member,
                serde_json::json!({"elements":[]}),
            )),
            names::methods::LIST_APPS => Ok(DesktopResponse::err(
                member,
                DesktopError::new("PERM_DENIED", "App listing denied"),
            )),
            _ => panic!("unexpected member"),
        }
    })
    .await;
    assert!(!module_error.ok);
    assert_eq!(module_error.app_count, None);
    assert_eq!(module_error.reason.as_deref(), Some("App listing denied"));
}

#[tokio::test]
async fn probe_passes_when_accessibility_is_not_required() {
    use tinycomputer_bus::DesktopResponse;

    let dir = tempfile::tempdir().unwrap();
    let mut config = Config::default();
    config.workspace_dir = dir.path().to_path_buf();
    save(&config, true).unwrap();

    // Simulates the Windows adapter returning "unknown" for accessibility,
    // which the host normalizes to "not_required" on the windows platform.
    // Since this test binary runs on the build host (not necessarily windows),
    // we pass "not_required" directly to prove the probe accepts it.
    let result = probe_with(&config, true, |member| async move {
        Ok(DesktopResponse::ok(
            member,
            match member {
                names::methods::PERMISSIONS => serde_json::json!({
                    "accessibility":{"state":"not_required"},
                    "screen_recording":{"state":"not_required"}
                }),
                names::methods::SNAPSHOT => serde_json::json!({"elements":[]}),
                names::methods::LIST_APPS => {
                    serde_json::json!({"apps":[{"name":"Explorer"}]})
                }
                _ => panic!("unexpected member"),
            },
        ))
    })
    .await;
    assert!(
        result.ok,
        "probe should pass when accessibility is not_required"
    );
    assert_eq!(result.app_count, Some(1));
    assert!(result.reason.is_none());
}

#[test]
fn permission_states_are_normalized() {
    let data = serde_json::json!({"accessibility":{"state":"granted"},
            "screen_recording":{"state":"weird"}});
    assert_eq!(permission(&data, "accessibility"), "granted");
    assert_eq!(permission(&data, "screen_recording"), "unknown");
    // "unknown" is a recognized pass-through state (distinct from a missing field).
    let unknown = serde_json::json!({"accessibility":{"state":"unknown"}});
    assert_eq!(permission(&unknown, "accessibility"), "unknown");
}

#[test]
fn windows_unknown_permissions_normalize_to_not_required() {
    assert_eq!(
        normalize_permission_for_platform("unknown", "windows"),
        "not_required"
    );
    assert_eq!(
        normalize_permission_for_platform("unknown", "macos"),
        "unknown"
    );
    assert_eq!(
        normalize_permission_for_platform("granted", "windows"),
        "granted"
    );
    assert_eq!(
        normalize_permission_for_platform("denied", "windows"),
        "denied"
    );
    assert_eq!(
        normalize_permission_for_platform("not_required", "windows"),
        "not_required"
    );
}

#[test]
fn approval_bypass_requires_a_registered_desktop_tool_and_disabled_setting() {
    use super::super::tools::{DesktopTool, DesktopToolKind};
    let mut config = Config::default();
    let goal = DesktopTool::new(std::sync::Arc::new(config.clone()), DesktopToolKind::Goal);
    let raw_action = DesktopTool::new(std::sync::Arc::new(config.clone()), DesktopToolKind::Act);
    assert!(approval_bypass_decision(&config, &goal));
    assert!(!approval_bypass_decision(&config, &raw_action));
    config.desktop.approvals_enabled = true;
    assert!(!approval_bypass_decision(&config, &goal));
}

#[test]
fn component_off_overrides_local_consent() {
    let dir = tempfile::tempdir().unwrap();
    let mut config = Config::default();
    config.workspace_dir = dir.path().to_path_buf();
    save(&config, true).unwrap();
    assert!(enabled(&config));
    config.components.computer = false;
    assert!(
        !enabled(&config),
        "component off must disable despite consent"
    );
}

#[test]
fn component_on_without_local_consent_stays_disabled() {
    let dir = tempfile::tempdir().unwrap();
    let mut config = Config::default();
    config.workspace_dir = dir.path().to_path_buf();
    assert!(config.components.computer);
    assert!(!enabled(&config));
}