galaxy/crates/local_control/src/protocol_tests.rs

use super::*;

#[test]
fn request_envelope_serializes_stable_action_names() {
    let request = RequestEnvelope::new(Action::new(ActionKind::WindowFocus));
    let value = serde_json::to_value(&request).expect("request serializes");
    assert_eq!(value["protocol_version"], PROTOCOL_VERSION);
    assert_eq!(value["action"]["kind"], "window.focus");
}

#[test]
fn strict_params_serialize_without_synthetic_discriminators() {
    let action = Action::with_params(
        ActionKind::SettingList,
        SettingListParams {
            namespace: Some("editor".to_owned()),
        },
    )
    .expect("setting.list params serialize");
    assert_eq!(action.params, serde_json::json!({ "namespace": "editor" }));
    let params = action
        .params_as::<SettingListParams>()
        .expect("setting.list params decode");
    assert_eq!(params.namespace.as_deref(), Some("editor"));

    let action = Action::with_params(
        ActionKind::TabCreate,
        TabCreateParams {
            tab_type: Some(TabType::Agent),
            shell: Some("zsh".to_owned()),
        },
    )
    .expect("tab.create params serialize");
    assert_eq!(
        action.params,
        serde_json::json!({ "tab_type": "agent", "shell": "zsh" })
    );
    assert!(action.params.get("type").is_none());
}

#[test]
fn strict_params_deny_unknown_fields() {
    let action = Action {
        kind: ActionKind::InputInsert,
        params: serde_json::json!({ "text": "hello", "submit": true }),
    };
    let error = action
        .params_as::<TextParams>()
        .expect_err("unknown params are rejected");
    assert_eq!(error.code, ErrorCode::InvalidParams);

    let action = Action {
        kind: ActionKind::WindowFocus,
        params: serde_json::json!({ "unexpected": true }),
    };
    assert!(action.params_as::<EmptyParams>().is_err());

    let action = Action {
        kind: ActionKind::TerminalInterrupt,
        params: serde_json::json!({ "block_id": "block_1", "force": true }),
    };
    assert!(action.params_as::<TerminalInterruptParams>().is_err());
}

#[test]
fn target_selector_roundtrips_exact_session_id() {
    let target = TargetSelector {
        session: Some(SessionTarget::Id {
            id: SessionSelector("session_1".to_owned()),
        }),
        ..TargetSelector::default()
    };
    let value = serde_json::to_value(&target).expect("target serializes");
    assert_eq!(
        value["session"],
        serde_json::json!({ "type": "id", "id": "session_1" })
    );
    assert_eq!(
        serde_json::from_value::<TargetSelector>(value).expect("target decodes"),
        target
    );
}

#[test]
fn response_error_serializes_machine_code() {
    let response = ResponseEnvelope::error(
        Uuid::nil(),
        ControlError::new(ErrorCode::InsufficientPermissions, "wrong action"),
    );
    let value = serde_json::to_value(&response).expect("response serializes");
    assert_eq!(value["response"]["status"], "error");
    assert_eq!(
        value["response"]["error"]["code"],
        "insufficient_permissions"
    );
}

#[test]
fn surface_list_result_serializes_stable_availability_shape() {
    let result = SurfaceListResult {
        surfaces: vec![
            SurfaceSummary {
                name: "theme_picker".to_owned(),
                is_available: true,
                unavailable_reason: None,
            },
            SurfaceSummary {
                name: "vertical_tabs".to_owned(),
                is_available: false,
                unavailable_reason: Some("vertical tabs are disabled".to_owned()),
            },
        ],
    };
    let value = serde_json::to_value(result).expect("surface list result serializes");
    assert_eq!(
        value,
        serde_json::json!({
            "surfaces": [
                {
                    "name": "theme_picker",
                    "is_available": true
                },
                {
                    "name": "vertical_tabs",
                    "is_available": false,
                    "unavailable_reason": "vertical tabs are disabled"
                }
            ]
        })
    );
}

#[test]
fn malformed_and_removed_action_names_are_not_deserialized() {
    for action in [
        "tab.create.extra",
        "auth.status",
        "auth.login",
        "block.list",
        "block.inspect",
        "block.output",
        "history.list",
        "file.list",
        "input.get",
        "input.clear",
        "input.mode.set",
        "input.run",
        "drive.list",
        "drive.inspect",
        "drive.open",
        "drive.notebook.open",
        "drive.env_var_collection.open",
        "drive.object.share.open",
        "drive.object.create",
        "drive.object.update",
        "drive.object.delete",
        "drive.object.insert",
        "drive.object.share_to_team",
        "drive.workflow.run",
        "surface.warp_drive.open",
        "surface.warp_drive.toggle",
        "surface.resource_center.toggle",
        "surface.ai_assistant.toggle",
        "surface.conversation_list.open",
        "surface.agent_management.open",
        "surface.left_panel.toggle",
    ] {
        assert!(serde_json::from_value::<ActionKind>(serde_json::json!(action)).is_err());
    }
}

#[test]
fn removed_cloud_agent_tab_type_is_not_deserialized() {
    assert!(serde_json::from_value::<TabType>(serde_json::json!("cloud_agent")).is_err());
}

#[test]
fn catalog_has_exactly_80_retained_actions() {
    assert_eq!(ActionKind::ALL.len(), 80);
}

#[test]
fn terminal_actions_have_race_safe_typed_contracts() {
    let execute = Action::with_params(
        ActionKind::TerminalExecute,
        TerminalExecuteParams {
            command: "cargo test".to_owned(),
        },
    )
    .expect("terminal.execute params serialize");
    assert_eq!(
        execute.params,
        serde_json::json!({ "command": "cargo test" })
    );

    let interrupt = Action::with_params(
        ActionKind::TerminalInterrupt,
        TerminalInterruptParams {
            block_id: "session_1-42".to_owned(),
        },
    )
    .expect("terminal.interrupt params serialize");
    assert_eq!(
        interrupt.params,
        serde_json::json!({ "block_id": "session_1-42" })
    );

    assert_eq!(
        ActionKind::TerminalStatus.metadata().result_spec,
        ActionResultSpec::TerminalStatus
    );
}

#[test]
fn direct_surface_actions_have_stable_names() {
    assert_eq!(ActionKind::SurfaceList.as_str(), "surface.list");
    assert_eq!(
        ActionKind::SurfaceThemePickerOpen.as_str(),
        "surface.theme_picker.open"
    );
    assert_eq!(
        ActionKind::SurfaceKeybindingsOpen.as_str(),
        "surface.keybindings.open"
    );
    assert_eq!(
        ActionKind::SurfaceCodeReviewOpen.as_str(),
        "surface.code_review.open"
    );
    assert_eq!(
        ActionKind::SurfaceProjectExplorerOpen.as_str(),
        "surface.project_explorer.open"
    );
    assert_eq!(
        ActionKind::SurfaceGlobalSearchOpen.as_str(),
        "surface.global_search.open"
    );
    assert_eq!(
        ActionKind::SurfaceVerticalTabsOpen.as_str(),
        "surface.vertical_tabs.open"
    );
}

#[test]
fn catalog_actions_share_uniform_authorization() {
    for kind in ActionKind::ALL {
        let metadata = kind.metadata();
        assert_eq!(
            metadata.implementation_status,
            ActionImplementationStatus::Implemented,
            "{} should be implemented",
            metadata.name,
        );
    }
}

#[test]
fn implemented_catalog_contains_all_retained_actions() {
    let actions = ActionKind::implemented_metadata()
        .into_iter()
        .map(|metadata| metadata.kind)
        .collect::<Vec<_>>();
    assert_eq!(actions, ActionKind::ALL);
}