| // Copyright 2021 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| use { |
| crate::expect::{expect_call, Status}, |
| anyhow::Error, |
| fidl_fuchsia_bluetooth::PeerId, |
| fidl_fuchsia_bluetooth_sys::{ |
| AccessMarker, AccessProxy, AccessRequest, AccessRequestStream, Error as AccessError, |
| InputCapability, OutputCapability, PairingDelegateProxy, PairingMarker, PairingOptions, |
| PairingProxy, PairingRequest, PairingRequestStream, |
| }, |
| fuchsia_zircon::Duration, |
| }; |
| |
| /// Provides a simple mock implementation of `fuchsia.bluetooth.sys.Pairing`. |
| pub struct PairingMock { |
| stream: PairingRequestStream, |
| timeout: Duration, |
| } |
| |
| impl PairingMock { |
| pub fn new(timeout: Duration) -> Result<(PairingProxy, PairingMock), Error> { |
| let (proxy, stream) = fidl::endpoints::create_proxy_and_stream::<PairingMarker>()?; |
| Ok((proxy, PairingMock { stream, timeout })) |
| } |
| |
| pub async fn expect_set_pairing_delegate( |
| &mut self, |
| expected_input_cap: InputCapability, |
| expected_output_cap: OutputCapability, |
| ) -> Result<PairingDelegateProxy, Error> { |
| expect_call(&mut self.stream, self.timeout, move |req| match req { |
| PairingRequest::SetPairingDelegate { input, output, delegate, control_handle: _ } |
| if input == expected_input_cap && output == expected_output_cap => |
| { |
| Ok(Status::Satisfied(delegate.into_proxy()?)) |
| } |
| _ => Ok(Status::Pending), |
| }) |
| .await |
| } |
| } |
| |
| /// Provides a simple mock implementation of `fuchsia.bluetooth.sys.Access`. |
| pub struct AccessMock { |
| stream: AccessRequestStream, |
| timeout: Duration, |
| } |
| |
| impl AccessMock { |
| pub fn new(timeout: Duration) -> Result<(AccessProxy, AccessMock), Error> { |
| let (proxy, stream) = fidl::endpoints::create_proxy_and_stream::<AccessMarker>()?; |
| Ok((proxy, AccessMock { stream, timeout })) |
| } |
| |
| pub async fn expect_disconnect( |
| &mut self, |
| expected_peer_id: PeerId, |
| result: Result<(), AccessError>, |
| ) -> Result<(), Error> { |
| expect_call(&mut self.stream, self.timeout, move |req| match req { |
| AccessRequest::Disconnect { id, responder } if id == expected_peer_id => { |
| responder.send(result)?; |
| Ok(Status::Satisfied(())) |
| } |
| _ => Ok(Status::Pending), |
| }) |
| .await |
| } |
| |
| pub async fn expect_forget( |
| &mut self, |
| expected_peer_id: PeerId, |
| result: Result<(), AccessError>, |
| ) -> Result<(), Error> { |
| expect_call(&mut self.stream, self.timeout, move |req| match req { |
| AccessRequest::Forget { id, responder } if id == expected_peer_id => { |
| responder.send(result)?; |
| Ok(Status::Satisfied(())) |
| } |
| _ => Ok(Status::Pending), |
| }) |
| .await |
| } |
| |
| pub async fn expect_pair( |
| &mut self, |
| expected_peer_id: PeerId, |
| expected_options: PairingOptions, |
| result: Result<(), AccessError>, |
| ) -> Result<(), Error> { |
| expect_call(&mut self.stream, self.timeout, move |req| match req { |
| AccessRequest::Pair { id, options, responder } |
| if id == expected_peer_id && options == expected_options => |
| { |
| responder.send(result)?; |
| Ok(Status::Satisfied(())) |
| } |
| _ => Ok(Status::Pending), |
| }) |
| .await |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| use { |
| crate::timeout_duration, fidl_fuchsia_bluetooth_sys::PairingDelegateMarker, futures::join, |
| }; |
| |
| #[fuchsia_async::run_until_stalled(test)] |
| async fn test_expect_disconnect() { |
| let (proxy, mut mock) = AccessMock::new(timeout_duration()).expect("failed to create mock"); |
| let peer_id = PeerId { value: 1 }; |
| |
| let disconnect = proxy.disconnect(&peer_id); |
| let expect = mock.expect_disconnect(peer_id, Ok(())); |
| |
| let (disconnect_result, expect_result) = join!(disconnect, expect); |
| let _ = disconnect_result.expect("disconnect request failed"); |
| let _ = expect_result.expect("expectation not satisfied"); |
| } |
| |
| #[fuchsia_async::run_until_stalled(test)] |
| async fn test_expect_forget() { |
| let (proxy, mut mock) = AccessMock::new(timeout_duration()).expect("failed to create mock"); |
| let peer_id = PeerId { value: 1 }; |
| |
| let forget = proxy.forget(&peer_id); |
| let expect = mock.expect_forget(peer_id, Ok(())); |
| |
| let (forget_result, expect_result) = join!(forget, expect); |
| let _ = forget_result.expect("forget request failed"); |
| let _ = expect_result.expect("expectation not satisifed"); |
| } |
| |
| #[fuchsia_async::run_until_stalled(test)] |
| async fn test_expect_set_pairing_delegate() { |
| let (proxy, mut mock) = |
| PairingMock::new(timeout_duration()).expect("failed to create mock"); |
| |
| let input_cap = InputCapability::None; |
| let output_cap = OutputCapability::Display; |
| let (pairing_delegate_client, _pairing_delegate_server) = |
| fidl::endpoints::create_endpoints::<PairingDelegateMarker>(); |
| |
| let pair_set_result = |
| proxy.set_pairing_delegate(input_cap, output_cap, pairing_delegate_client); |
| let expect_result = mock.expect_set_pairing_delegate(input_cap, output_cap).await; |
| |
| let _ = pair_set_result.expect("set_pairing_delegate request failed"); |
| let _ = expect_result.expect("expectation not satisifed"); |
| } |
| } |