bt_test_harness/
host.rs

1// Copyright 2024 The Fuchsia Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5use anyhow::{format_err, Context, Error};
6use fidl_fuchsia_bluetooth_host::{BondingDelegateProxy, HostProxy, PeerWatcherGetNextResponse};
7use fidl_fuchsia_hardware_bluetooth::EmulatorProxy;
8use fuchsia_bluetooth::expectation::asynchronous::{
9    expectable, Expectable, ExpectableExt, ExpectableState, ExpectableStateExt,
10};
11use fuchsia_bluetooth::expectation::Predicate;
12use fuchsia_bluetooth::types::{HostInfo, Peer, PeerId};
13use futures::future::{self, BoxFuture, Future};
14use futures::{FutureExt, TryFutureExt};
15use hci_emulator_client::Emulator;
16use log::warn;
17use std::collections::HashMap;
18use std::ops::{Deref, DerefMut};
19use std::sync::Arc;
20use test_harness::{SharedState, TestHarness, SHARED_STATE_TEST_COMPONENT_INDEX};
21
22use crate::core_realm::SHARED_STATE_INDEX;
23use crate::emulator::{watch_controller_parameters, EmulatorState};
24use crate::host_realm::HostRealm;
25use crate::timeout_duration;
26
27#[derive(Clone, Debug)]
28pub struct HostState {
29    emulator_state: EmulatorState,
30
31    // Current bt-host component state.
32    host_info: HostInfo,
33
34    // All known remote devices, indexed by their identifiers.
35    peers: HashMap<PeerId, Peer>,
36}
37
38impl HostState {
39    pub fn peers(&self) -> &HashMap<PeerId, Peer> {
40        &self.peers
41    }
42    pub fn info(&self) -> &HostInfo {
43        &self.host_info
44    }
45}
46
47impl AsMut<EmulatorState> for HostState {
48    fn as_mut(&mut self) -> &mut EmulatorState {
49        &mut self.emulator_state
50    }
51}
52
53impl AsRef<EmulatorState> for HostState {
54    fn as_ref(&self) -> &EmulatorState {
55        &self.emulator_state
56    }
57}
58
59/// Auxiliary data for the HostHarness
60pub struct Aux {
61    pub host: HostProxy,
62    pub emulator: EmulatorProxy,
63    pub bonding_delegate: BondingDelegateProxy,
64}
65
66impl AsRef<EmulatorProxy> for Aux {
67    fn as_ref(&self) -> &EmulatorProxy {
68        &self.emulator
69    }
70}
71
72#[derive(Clone)]
73pub struct HostHarness(Expectable<HostState, Aux>);
74
75impl Deref for HostHarness {
76    type Target = Expectable<HostState, Aux>;
77
78    fn deref(&self) -> &Self::Target {
79        &self.0
80    }
81}
82
83impl DerefMut for HostHarness {
84    fn deref_mut(&mut self) -> &mut Self::Target {
85        &mut self.0
86    }
87}
88
89impl TestHarness for HostHarness {
90    type Env = (Emulator, Arc<HostRealm>);
91    type Runner = BoxFuture<'static, Result<(), Error>>;
92
93    fn init(
94        shared_state: &Arc<SharedState>,
95    ) -> BoxFuture<'static, Result<(Self, Self::Env, Self::Runner), Error>> {
96        let shared_state = shared_state.clone();
97        async move {
98            let test_component: Arc<String> = shared_state
99                .get(SHARED_STATE_TEST_COMPONENT_INDEX)
100                .expect("SharedState must have TEST-COMPONENT")?;
101            let inserter = move || HostRealm::create(test_component.to_string());
102            let realm = shared_state.get_or_insert_with(SHARED_STATE_INDEX, inserter).await?;
103
104            let (harness, emulator) = new_host_harness(realm.clone()).await?;
105
106            let watch_info = watch_host_info(harness.clone())
107                .map_err(|e| e.context("Error watching host state"))
108                .err_into();
109            let watch_peers = watch_peers(harness.clone())
110                .map_err(|e| e.context("Error watching peers"))
111                .err_into();
112            let watch_emulator_params = watch_controller_parameters(harness.0.clone())
113                .map_err(|e| e.context("Error watching controller parameters"))
114                .err_into();
115
116            let run = future::try_join3(watch_info, watch_peers, watch_emulator_params)
117                .map_ok(|((), (), ())| ())
118                .boxed();
119            Ok((harness, (emulator, realm), run))
120        }
121        .boxed()
122    }
123
124    fn terminate(env: Self::Env) -> BoxFuture<'static, Result<(), Error>> {
125        // Keep the realm alive until the future resolves.
126        async move {
127            let (mut emulator, _realm) = env;
128            emulator.destroy_and_wait().await
129        }
130        .boxed()
131    }
132}
133
134async fn new_host_harness(realm: Arc<HostRealm>) -> Result<(HostHarness, Emulator), Error> {
135    // Publishing an HCI device can only occur after HostRealm::create() is called
136    let dev_dir = realm.dev().context("failed to open dev directory")?;
137    let emulator =
138        Emulator::create(dev_dir).await.context("Error creating emulator root device")?;
139    let device_path = emulator
140        .publish_and_wait_for_device_path(Emulator::default_settings())
141        .await
142        .context("Error publishing emulator hci device")?;
143
144    let host = HostRealm::create_bt_host_in_collection(&realm, &device_path).await?.into_proxy();
145    let host_info = host
146        .watch_state()
147        .await
148        .context("Error calling WatchState()")?
149        .try_into()
150        .context("Invalid HostInfo received")?;
151
152    let peers = HashMap::new();
153
154    let (bonding_delegate, bonding_server) = fidl::endpoints::create_proxy();
155    host.set_bonding_delegate(bonding_server).context("Error setting bonding delegate")?;
156
157    let harness = HostHarness(expectable(
158        HostState { emulator_state: EmulatorState::default(), host_info, peers },
159        Aux { host, emulator: emulator.emulator().clone(), bonding_delegate },
160    ));
161
162    Ok((harness, emulator))
163}
164
165async fn watch_peers(harness: HostHarness) -> Result<(), Error> {
166    // Clone the proxy so that the aux() lock is not held while waiting.
167    let proxy = harness.aux().host.clone();
168    let (peer_watcher, server) = fidl::endpoints::create_proxy();
169    proxy.set_peer_watcher(server)?;
170    loop {
171        let response = peer_watcher.get_next().await?;
172        match response {
173            PeerWatcherGetNextResponse::Updated(updated) => {
174                for peer in updated.into_iter() {
175                    let peer: Peer = peer.try_into()?;
176                    let _ = harness.write_state().peers.insert(peer.id.clone(), peer);
177                    harness.notify_state_changed();
178                }
179            }
180            PeerWatcherGetNextResponse::Removed(removed) => {
181                for id in removed.into_iter() {
182                    let id = id.into();
183                    if harness.write_state().peers.remove(&id).is_none() {
184                        warn!(id:%; "HostHarness: Removed id that wasn't present");
185                    }
186                }
187            }
188            _ => return Err(format_err!("unknown PeerWatcher.GetNext response")),
189        }
190    }
191}
192
193async fn watch_host_info(harness: HostHarness) -> Result<(), Error> {
194    let proxy = harness.aux().host.clone();
195    loop {
196        let info = proxy.watch_state().await?;
197        harness.write_state().host_info = info.try_into()?;
198        harness.notify_state_changed();
199    }
200}
201
202pub mod expectation {
203    use super::*;
204
205    /// Returns a Future that resolves when the state of any RemoteDevice matches `target`.
206    pub fn peer(
207        host: &HostHarness,
208        p: Predicate<Peer>,
209    ) -> impl Future<Output = Result<HostState, Error>> + '_ {
210        host.when_satisfied(
211            Predicate::any(p).over_value(
212                |host: &HostState| host.peers.values().cloned().collect::<Vec<_>>(),
213                ".peers.values()",
214            ),
215            timeout_duration(),
216        )
217    }
218
219    /// Returns a Future that resolves when the HostInfo matches `target`.
220    pub fn host_state(
221        host: &HostHarness,
222        p: Predicate<HostInfo>,
223    ) -> impl Future<Output = Result<HostState, Error>> + '_ {
224        host.when_satisfied(
225            p.over(|host: &HostState| &host.host_info, ".host_info"),
226            timeout_duration(),
227        )
228    }
229
230    /// Returns a Future that resolves when a peer matching `id` is not present on the host.
231    pub fn no_peer(host: &HostHarness, id: PeerId) -> impl Future<Output = Result<(), Error>> + '_ {
232        host.when_satisfied(
233            Predicate::all(Predicate::not_equal(id)).over_value(
234                |host: &HostState| host.peers.keys().cloned().collect::<Vec<_>>(),
235                ".peers.keys()",
236            ),
237            timeout_duration(),
238        )
239        .map_ok(|_| ())
240    }
241}
bt_test_harness/host.rs

bt_test_harness/
host.rs
