//! UDP channel bind integration coverage.

#[path = "../support/mod.rs"]
mod support;

mod helpers;

use crate::support::stun_builders::{
    build_allocate_request, build_channel_bind_request, extract_error_code, parse,
};
use helpers::*;
use niom_turn::alloc::AllocationManager;
use niom_turn::auth;
use support::{default_test_credentials, init_tracing, test_auth_manager};
use tokio::net::UdpSocket;

#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn channel_bind_without_allocation_returns_mismatch() {
    init_tracing();
    let (username, password) = default_test_credentials();
    let auth_manager = test_auth_manager(username, password);
    let allocs = AllocationManager::new();
    let server_addr = spawn_udp_server(auth_manager.clone(), allocs.clone()).await;

    let client = UdpSocket::bind("127.0.0.1:0").await.expect("client bind");
    let mut buf = [0u8; 1500];

    // Challenge to obtain nonce (no allocation performed yet)
    let challenge = build_allocate_request(None, None, None, None, None);
    client
        .send_to(&challenge, server_addr)
        .await
        .expect("send challenge");
    let (len, _) = client.recv_from(&mut buf).await.expect("recv nonce");
    let resp = parse(&buf[..len]);
    let nonce = extract_nonce(&resp).expect("nonce attr");

    let key = auth::compute_a1_md5(username, auth_manager.realm(), password);
    let channel_req = build_channel_bind_request(
        username,
        auth_manager.realm(),
        &nonce,
        &key,
        sample_channel_number(),
        &sample_peer(),
    );
    client
        .send_to(&channel_req, server_addr)
        .await
        .expect("send channel bind");
    let (len, _) = client.recv_from(&mut buf).await.expect("recv error");
    let resp = parse(&buf[..len]);
    let code = extract_error_code(&resp).expect("error attr");
    assert_eq!(code, 437);
}