magi-code 0.77.1

use super::support::*;
use super::*;

#[test]
fn oauth_fallback_is_cleared_only_after_worker_acceptance_and_on_cancel() {
    let temp = tempfile::TempDir::new().unwrap();
    let (sender, _receiver) = bounded::<TuiEvent>(4);
    let mut app = test_app(&temp, sender);
    let worker_with_manual_sender = |manual_sender: mpsc::Sender<String>| WorkerState {
        handle: thread::spawn(|| {}),
        cancel: Arc::new(AtomicBool::new(false)),
        login_manual: Some(manual_sender),
        outcome: Arc::new(WorkerOutcomeState::default()),
        outcome_reconciled: false,
        shutdown_policy: WorkerShutdownPolicy::Cancel,
        steering: crate::agent::steering::AgentSteering::new(),
        accepts_steering: false,
    };

    let (manual_sender, manual_receiver) = mpsc::channel();
    app.worker = Some(worker_with_manual_sender(manual_sender));
    let mut accepted_state = state::MissionControlState::default();
    accepted_state.open_connect_provider(Vec::new(), None);
    accepted_state.start_connect_oauth(crate::providers::OPENAI_CODEX_PROVIDER.to_string());
    assert!(
        accepted_state.insert_modal_field_text("https://localhost/callback?code=accepted-fallback")
    );
    app.submit_connect_provider_fallback(&mut accepted_state);
    assert_eq!(
        manual_receiver
            .recv_timeout(Duration::from_secs(1))
            .unwrap(),
        "https://localhost/callback?code=accepted-fallback"
    );
    assert!(
        accepted_state
            .modals
            .connect_provider
            .as_ref()
            .unwrap()
            .fallback_input
            .is_empty()
    );
    let worker = app.worker.take().unwrap();
    worker.handle.join().unwrap();

    let (manual_sender, manual_receiver) = mpsc::channel();
    drop(manual_receiver);
    app.worker = Some(worker_with_manual_sender(manual_sender));
    let mut rejected_state = state::MissionControlState::default();
    rejected_state.open_connect_provider(Vec::new(), None);
    rejected_state.start_connect_oauth(crate::providers::OPENAI_CODEX_PROVIDER.to_string());
    assert!(rejected_state.insert_modal_field_text("rejected-fallback"));
    app.submit_connect_provider_fallback(&mut rejected_state);
    assert_eq!(
        rejected_state
            .modals
            .connect_provider
            .as_ref()
            .unwrap()
            .fallback_input
            .value(),
        "rejected-fallback"
    );
    assert!(
        rejected_state
            .status
            .contains("no longer accepting fallback input")
    );
    let worker = app.worker.take().unwrap();
    worker.handle.join().unwrap();

    let mut canceled_state = state::MissionControlState::default();
    canceled_state.open_connect_provider(Vec::new(), None);
    canceled_state.start_connect_oauth(crate::providers::OPENAI_CODEX_PROVIDER.to_string());
    assert!(canceled_state.insert_modal_field_text("cancelled-fallback"));
    app.cancel_connect_provider(&mut canceled_state);
    assert!(canceled_state.modals.connect_provider.is_none());
}

#[test]
fn oauth_instructions_debug_redacts_url_and_message_payload() {
    let event = TuiEvent::OAuthInstructions {
        worker_id: 42,
        instructions: crate::login::LoginInstructions {
            url: "https://auth.example/authorize?code=oauth-event-debug-secret".to_string(),
            message: "authorization_code=oauth-event-debug-secret".to_string(),
        },
    };
    let debug = format!("{event:?}");

    assert!(debug.contains("OAuthInstructions"), "{debug}");
    assert!(debug.contains("worker_id"), "{debug}");
    assert!(!debug.contains("oauth-event-debug-secret"), "{debug}");
    assert!(!debug.contains("authorization_code"), "{debug}");
}