bin/bluetooth/bt-snoop/src/tests.rs

use {
    fidl::Error as FidlError,
    fidl_fuchsia_bluetooth_snoop::{SnoopProxy, SnoopRequestStream},
    fuchsia_async::{Channel, Executor},
    fuchsia_zircon as zx,
    std::task::Poll,
};

use super::*;

fn setup() -> (
    Executor,
    ConcurrentSnooperPacketFutures,
    PacketLogs,
    SubscriptionManager,
    ConcurrentClientRequestFutures,
) {
    (
        fasync::Executor::new().unwrap(),
        ConcurrentSnooperPacketFutures::new(),
        PacketLogs::new(10, 10, Duration::new(10, 0)),
        SubscriptionManager::new(),
        ConcurrentClientRequestFutures::new(),
    )
}

#[test]
fn test_id_generator() {
    let mut id_gen = IdGenerator::new();
    assert_eq!(id_gen.next(), ClientId(0));
    assert_eq!(id_gen.next(), ClientId(1));
}

#[test]
fn test_register_new_client() {
    let (_exec, _snoopers, _logs, _subscribers, mut requests) = setup();
    assert_eq!(requests.len(), 0);

    let (_tx, rx) = zx::Channel::create().unwrap();
    let connection = Some(Channel::from_channel(rx).unwrap());
    register_new_client(connection, &mut requests, ClientId(0));
    assert_eq!(requests.len(), 1);

    let connection = None;
    register_new_client(connection, &mut requests, ClientId(0));
    assert_eq!(requests.len(), 1);
}

fn fidl_endpoints() -> (SnoopProxy, SnoopRequestStream) {
    let (proxy, server) = fidl::endpoints::create_proxy::<SnoopMarker>().unwrap();
    let request_stream = server.into_stream().unwrap();
    (proxy, request_stream)
}

fn unwrap_request<T, E>(request: Poll<Option<Result<T, E>>>) -> T {
    if let Poll::Ready(Some(Ok(request))) = request {
        return request;
    }
    panic!("Failed to receive request");
}

fn unwrap_response<T, E>(response: Poll<Result<T, E>>) -> T {
    if let Poll::Ready(Ok(response)) = response {
        return response;
    }
    panic!("Failed to receive response");
}

#[test]
fn test_handle_client_request() {
    let (mut exec, mut _snoopers, mut logs, mut subscribers, mut requests) = setup();

    // unrecognized device returns an error to the client
    let (proxy, mut request_stream) = fidl_endpoints();
    let mut client_fut = proxy.start(true, Some(""));
    exec.run_until_stalled(&mut client_fut);
    let request = unwrap_request(exec.run_until_stalled(&mut request_stream.next()));
    let request = (ClientId(0), (Some(Ok(request)), request_stream));
    handle_client_request(request, &mut requests, &mut subscribers, &mut logs).unwrap();
    let response = unwrap_response(exec.run_until_stalled(&mut client_fut));
    assert!(response.error.is_some());
    assert_eq!(subscribers.number_of_subscribers(), 0);

    // valid device returns no errors to a client subscribed to that device
    let (proxy, mut request_stream) = fidl_endpoints();
    logs.add_device(String::new());
    let mut client_fut = proxy.start(true, Some(""));
    exec.run_until_stalled(&mut client_fut);
    let request = unwrap_request(exec.run_until_stalled(&mut request_stream.next()));
    let request = (ClientId(1), (Some(Ok(request)), request_stream));
    handle_client_request(request, &mut requests, &mut subscribers, &mut logs).unwrap();
    let response = unwrap_response(exec.run_until_stalled(&mut client_fut));
    assert!(response.error.is_none());
    assert_eq!(subscribers.number_of_subscribers(), 1);

    // valid device returns no errors to a client subscribed globally
    let (proxy, mut request_stream) = fidl_endpoints();
    let mut client_fut = proxy.start(true, None);
    exec.run_until_stalled(&mut client_fut);
    let request = unwrap_request(exec.run_until_stalled(&mut request_stream.next()));
    let request = (ClientId(2), (Some(Ok(request)), request_stream));
    handle_client_request(request, &mut requests, &mut subscribers, &mut logs).unwrap();
    let response = unwrap_response(exec.run_until_stalled(&mut client_fut));
    println!("{:?}", response.error);
    assert!(response.error.is_none());
    assert_eq!(subscribers.number_of_subscribers(), 2);

    // second request by the same client returns an error
    let (proxy, mut request_stream) = fidl_endpoints();
    let mut client_fut = proxy.start(true, None);
    exec.run_until_stalled(&mut client_fut);
    let request = unwrap_request(exec.run_until_stalled(&mut request_stream.next()));
    let request = (ClientId(2), (Some(Ok(request)), request_stream));
    handle_client_request(request, &mut requests, &mut subscribers, &mut logs).unwrap();
    let response = unwrap_response(exec.run_until_stalled(&mut client_fut));
    println!("{:?}", response.error);
    assert!(response.error.is_some());
    assert_eq!(subscribers.number_of_subscribers(), 2);

    // valid device returns no errors to a client requesting a dump
    let (proxy, mut request_stream) = fidl_endpoints();
    let mut client_fut = proxy.start(false, None);
    exec.run_until_stalled(&mut client_fut);
    let request = unwrap_request(exec.run_until_stalled(&mut request_stream.next()));
    let request = (ClientId(3), (Some(Ok(request)), request_stream));
    handle_client_request(request, &mut requests, &mut subscribers, &mut logs).unwrap();
    let response = unwrap_response(exec.run_until_stalled(&mut client_fut));
    println!("{:?}", response.error);
    assert!(response.error.is_none());
    assert_eq!(subscribers.number_of_subscribers(), 2);

}

#[test]
fn test_handle_bad_client_request() {
    let (_exec, mut _snoopers, mut logs, mut subscribers, mut requests) = setup();

    let id = ClientId(0);
    let err = Some(Err(FidlError::Invalid));
    let (_proxy, req_stream) = fidl_endpoints();
    let handle = req_stream.control_handle();
    let request = (id, (err, req_stream));
    subscribers.register(id, handle, None).unwrap();
    assert!(subscribers.is_registered(&id));
    handle_client_request(request, &mut requests, &mut subscribers, &mut logs).unwrap();
    assert!(!subscribers.is_registered(&id));

    let id = ClientId(1);
    let err = Some(Err(FidlError::Invalid));
    let (_proxy, req_stream) = fidl_endpoints();
    let handle = req_stream.control_handle();
    let request = (id, (err, req_stream));
    subscribers.register(id, handle, None).unwrap();
    assert!(subscribers.is_registered(&id));
    handle_client_request(request, &mut requests, &mut subscribers, &mut logs).unwrap();
    assert!(!subscribers.is_registered(&id));
}