| // Copyright 2020 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::bss_cache::{Bss, BssId}, |
| async_trait::async_trait, |
| fidl::{Error as FidlError, Socket as FidlSocket}, |
| fidl_fuchsia_location_position::{Position, PositionExtras}, |
| fidl_fuchsia_mem::Buffer as MemBuffer, |
| fidl_fuchsia_net_http::{ |
| Body as HttpBody, LoaderProxyInterface, Request as HttpRequest, Response as HttpResponse, |
| }, |
| fuchsia_async::futures::io::AsyncReadExt, |
| fuchsia_async::futures::Future, |
| fuchsia_zircon as zx, |
| itertools::Itertools, |
| serde_json::{json, map::Map as JsonMap, value::Value as JsonValue}, |
| static_assertions::assert_eq_size_val, |
| std::{borrow::Borrow, convert::TryFrom}, |
| }; |
| |
| // Geographic constants. |
| const LATITUDE_RANGE: std::ops::RangeInclusive<f64> = -90.0..=90.0; |
| const LONGITUDE_RANGE: std::ops::RangeInclusive<f64> = -180.0..=180.0; |
| |
| // Google Maps constants. |
| const SERVICE_URL: &'static str = "https://www.googleapis.com/geolocation/v1/geolocate"; |
| const MAC_ADDR_KEY: &'static str = "macAddress"; |
| const AP_LIST_KEY: &'static str = "wifiAccessPoints"; |
| const RSSI_KEY: &'static str = "signalStrength"; |
| const LOCATION_KEY: &'static str = "location"; |
| const LATITUDE_KEY: &'static str = "lat"; |
| const LONGITUDE_KEY: &'static str = "lng"; |
| const ACCURACY_KEY: &'static str = "accuracy"; |
| |
| // HTTP constants. |
| const HTTP_METHOD_POST: &'static str = "POST"; |
| |
| #[async_trait(?Send)] |
| pub trait BssResolver { |
| /// Resolves WLAN BSS (base-station) meta-data to a `Position`. |
| async fn resolve<'a, I, T, U>(&self, bsses: I) -> Result<Position, ResolverError> |
| where |
| I: IntoIterator, |
| I::Item: Borrow<(T, U)>, |
| T: Borrow<BssId>, |
| U: Borrow<Bss>; |
| } |
| |
| /// A service for resolving WLAN BSS (base-station) meta-data to `Position`s. |
| pub struct RealBssResolver<L: LoaderProxyInterface> { |
| http_loader: L, |
| api_key: String, |
| } |
| |
| #[derive(Clone, Copy, Debug, PartialEq)] |
| pub enum ResolverError { |
| NoBsses, |
| Internal, |
| Lookup, |
| } |
| |
| impl<L: LoaderProxyInterface> RealBssResolver<L> { |
| pub fn new(http_loader: L, api_key: impl Into<String>) -> Self { |
| Self { http_loader, api_key: api_key.into() } |
| } |
| } |
| |
| #[async_trait(?Send)] |
| impl<L: LoaderProxyInterface> BssResolver for RealBssResolver<L> { |
| async fn resolve<'a, I, T, U>(&self, bsses: I) -> Result<Position, ResolverError> |
| where |
| I: IntoIterator, |
| I::Item: Borrow<(T, U)>, |
| T: Borrow<BssId>, |
| U: Borrow<Bss>, |
| { |
| let mut bsses = bsses.into_iter().peekable(); |
| if bsses.peek().is_none() { |
| return Err(ResolverError::NoBsses); |
| } |
| parse_response(send_query(bsses, &self.api_key, &self.http_loader)?.await).await |
| } |
| } |
| |
| fn send_query<'a, I, T, U>( |
| bsses: I, |
| api_key: impl AsRef<str>, |
| http_loader: &impl LoaderProxyInterface, |
| ) -> Result<impl Future<Output = Result<HttpResponse, FidlError>>, ResolverError> |
| where |
| I: Iterator, |
| I::Item: Borrow<(T, U)>, |
| T: Borrow<BssId>, |
| U: Borrow<Bss>, |
| { |
| let api_key = api_key.as_ref(); |
| let request_body = serialize_bsses(bsses); |
| let request_size = { |
| let body_size = request_body.len(); |
| assert_eq_size_val!(body_size, 0u64); |
| u64::try_from(body_size).expect("failed to convert usize to u64") |
| }; |
| let request_vmo = zx::Vmo::create(request_size).map_err(|_| ResolverError::Internal)?; |
| let _ = request_vmo.write(&request_body.as_bytes(), 0).map_err(|_| ResolverError::Internal)?; |
| Ok(http_loader.fetch(HttpRequest { |
| method: Some(HTTP_METHOD_POST.to_owned()), |
| url: Some(format!("{}?key={}", SERVICE_URL, api_key)), |
| headers: None, |
| body: Some(HttpBody::Buffer(MemBuffer { vmo: request_vmo, size: request_size })), |
| deadline: None, |
| ..HttpRequest::EMPTY |
| })) |
| } |
| |
| async fn parse_response( |
| response: Result<HttpResponse, FidlError>, |
| ) -> Result<Position, ResolverError> { |
| let response: HttpResponse = response.map_err(|_fidl_error| ResolverError::Internal)?; |
| let response: FidlSocket = response.body.ok_or(ResolverError::Lookup)?; |
| let response: String = read_socket(response).await.ok_or(ResolverError::Lookup)?; |
| json_to_position(serde_json::from_str(&response).map_err(|_| ResolverError::Lookup)?) |
| } |
| |
| fn serialize_bsses<'a, I, T, U>(bsses: I) -> String |
| where |
| I: Iterator, |
| I::Item: Borrow<(T, U)>, |
| T: Borrow<BssId>, |
| U: Borrow<Bss>, |
| { |
| let bsses = bsses |
| .map(|item| bss_to_json(item.borrow().0.borrow(), item.borrow().1.borrow())) |
| .collect::<Vec<_>>(); |
| json!({ AP_LIST_KEY: bsses }).to_string() |
| } |
| |
| fn bss_to_json(bss_id: impl Borrow<BssId>, bss: impl Borrow<Bss>) -> JsonValue { |
| let mut json = JsonMap::new(); |
| json.insert( |
| MAC_ADDR_KEY.to_owned(), |
| json!(bss_id.borrow().iter().map(|bss_byte| format!("{:02x}", bss_byte)).join(":")), |
| ); |
| if let Some(rssi) = bss.borrow().rssi { |
| json.insert(RSSI_KEY.to_owned(), json!(rssi)); |
| }; |
| JsonValue::from(json) |
| } |
| |
| async fn read_socket(socket: zx::Socket) -> Option<String> { |
| let mut buf = Vec::new(); |
| match fuchsia_async::Socket::from_socket(socket).ok() { |
| Some(mut socket) => match socket.read_to_end(&mut buf).await { |
| Ok(_num_bytes_read) => String::from_utf8(buf).ok(), |
| Err(_) => None, |
| }, |
| None => None, |
| } |
| } |
| |
| fn json_to_position(response: JsonValue) -> Result<Position, ResolverError> { |
| let latitude = response[LOCATION_KEY][LATITUDE_KEY].as_f64().ok_or(ResolverError::Lookup)?; |
| if !LATITUDE_RANGE.contains(&latitude) { |
| return Err(ResolverError::Lookup); |
| } |
| |
| let longitude = response[LOCATION_KEY][LONGITUDE_KEY].as_f64().ok_or(ResolverError::Lookup)?; |
| if !LONGITUDE_RANGE.contains(&longitude) { |
| return Err(ResolverError::Lookup); |
| } |
| |
| let extras = match response[ACCURACY_KEY].as_f64() { |
| Some(accuracy) => PositionExtras { |
| accuracy_meters: Some(accuracy), |
| altitude_meters: None, |
| ..PositionExtras::EMPTY |
| }, |
| None => { |
| PositionExtras { accuracy_meters: None, altitude_meters: None, ..PositionExtras::EMPTY } |
| } |
| }; |
| |
| Ok(Position { latitude, longitude, extras }) |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| mod request_generation { |
| use { |
| super::super::{test_doubles::HttpRequestValidator, *}, |
| fuchsia_async as fasync, |
| }; |
| |
| #[fasync::run_until_stalled(test)] |
| async fn request_uses_post_method() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: Some(-30), frequency: Some(2412) })]; |
| let mut request_method = None; |
| let http_loader = HttpRequestValidator::new(|request| { |
| request_method = Some(request.method.expect("request had no method")); |
| }); |
| let _ = RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await; |
| assert_eq!(request_method.expect("request was never issued"), "POST".to_owned()); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn request_url_is_correct() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: Some(-30), frequency: Some(2412) })]; |
| let mut request_url = None; |
| let http_loader = HttpRequestValidator::new(|request| { |
| request_url = Some(request.url.expect("request had no url")); |
| }); |
| let _ = RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await; |
| assert_eq!( |
| request_url.expect("request was never issued"), |
| "https://www.googleapis.com/geolocation/v1/geolocate?key=fake_key".to_owned() |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn request_body_contains_all_bsses() { |
| let bsses = vec![ |
| ([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None }), |
| ([1, 1, 1, 1, 1, 1], Bss { rssi: None, frequency: None }), |
| ]; |
| let mut request_body = None; |
| let http_loader = HttpRequestValidator::new(|request| { |
| request_body = Some(request.body.expect("request had no body")); |
| }); |
| let _ = RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await; |
| assert_eq!( |
| strip_whitespace(read_request_body( |
| request_body.expect("request was never issued") |
| )), |
| strip_whitespace( |
| r#"{ |
| "wifiAccessPoints":[ |
| {"macAddress":"00:00:00:00:00:00"}, |
| {"macAddress":"01:01:01:01:01:01"} |
| ] |
| }"# |
| ) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn request_body_includes_rssi() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: Some(-30), frequency: None })]; |
| let mut request_body = None; |
| let http_loader = HttpRequestValidator::new(|request| { |
| request_body = Some(request.body.expect("request had no body")); |
| }); |
| let _ = RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await; |
| assert_eq!( |
| strip_whitespace(read_request_body( |
| request_body.expect("request was never issued") |
| )), |
| strip_whitespace( |
| r#"{ |
| "wifiAccessPoints":[ |
| {"macAddress":"00:00:00:00:00:00", |
| "signalStrength": -30} |
| ] |
| }"# |
| ) |
| ) |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn skips_api_query_when_bsses_is_empty() { |
| let http_loader = |
| HttpRequestValidator::new(|_request| panic!("should not issue API query")); |
| let _ = RealBssResolver::new(http_loader, "fake_key") |
| .resolve(std::iter::empty::<(BssId, Bss)>()) |
| .await; |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_no_bsses_error_when_bsses_is_empty() { |
| let http_loader = HttpRequestValidator::new(|_| ()); |
| assert_eq!( |
| RealBssResolver::new(http_loader, "fake_key") |
| .resolve(std::iter::empty::<(BssId, Bss)>()) |
| .await, |
| Err(ResolverError::NoBsses) |
| ); |
| } |
| |
| fn read_request_body(body: HttpBody) -> String { |
| match body { |
| HttpBody::Buffer(shared_buf) => { |
| let mut local_buf = vec![ |
| 0_u8; |
| usize::try_from(shared_buf.size).expect( |
| "internal error: failed to convert u64 to usize" |
| ) |
| ]; |
| shared_buf |
| .vmo |
| .read(&mut local_buf, 0) |
| .expect("internal error: failed to read from VMO"); |
| String::from_utf8(local_buf) |
| .expect("internal error: failed to convert buffer to UTF-8") |
| } |
| HttpBody::Stream(_) => panic!("internal error: stream bodies not supported"), |
| } |
| } |
| |
| fn strip_whitespace<S: AsRef<str>>(input: S) -> String { |
| input.as_ref().replace("\n", "").replace(" ", "") |
| } |
| } |
| |
| mod response_error_handling { |
| use { |
| super::super::{ |
| test_doubles::{HttpByteResponder, HttpFidlResponder}, |
| *, |
| }, |
| fuchsia_async as fasync, |
| }; |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_internal_error_on_fidl_error() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpFidlResponder::new(|| Err(FidlError::InvalidHeader)); |
| assert_eq!( |
| RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await, |
| Err(ResolverError::Internal) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_lookup_error_when_response_has_no_body() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpFidlResponder::new(|| { |
| Ok(HttpResponse { |
| error: None, |
| body: None, |
| final_url: None, |
| status_code: None, |
| status_line: None, |
| headers: None, |
| redirect: None, |
| ..HttpResponse::EMPTY |
| }) |
| }); |
| assert_eq!( |
| RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await, |
| Err(ResolverError::Lookup) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_lookup_error_when_body_is_unreadable() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpFidlResponder::new(|| { |
| Ok(HttpResponse { |
| error: None, |
| body: Some(zx::Socket::from(zx::Handle::invalid())), |
| final_url: None, |
| status_code: None, |
| status_line: None, |
| headers: None, |
| redirect: None, |
| ..HttpResponse::EMPTY |
| }) |
| }); |
| assert_eq!( |
| RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await, |
| Err(ResolverError::Lookup) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_lookup_error_when_body_is_not_valid_json() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new(b"hello world".to_vec()); |
| assert_eq!( |
| RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await, |
| Err(ResolverError::Lookup) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_lookup_error_when_body_is_not_a_dictionary() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new(b"42".to_vec()); |
| assert_eq!( |
| RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await, |
| Err(ResolverError::Lookup) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_lookup_error_when_body_is_missing_location() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new(b"{}".to_vec()); |
| assert_eq!( |
| RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await, |
| Err(ResolverError::Lookup) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_lookup_error_when_body_is_missing_latitude() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new( |
| br#"{ |
| "location": { |
| "lng": -0.1 |
| }, |
| "accuracy": 1200.4 |
| }"# |
| .to_vec(), |
| ); |
| assert_eq!( |
| RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await, |
| Err(ResolverError::Lookup) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_lookup_error_when_body_is_missing_longitude() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new( |
| br#"{ |
| "location": { |
| "lat": 51.0, |
| }, |
| "accuracy": 1200.4 |
| }"# |
| .to_vec(), |
| ); |
| assert_eq!( |
| RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await, |
| Err(ResolverError::Lookup) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_lookup_error_when_latitude_is_too_high() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new( |
| br#"{ |
| "location": { |
| "lat": 90.1, |
| "lng": 0.0 |
| } |
| }"# |
| .to_vec(), |
| ); |
| assert_eq!( |
| RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await, |
| Err(ResolverError::Lookup) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_lookup_error_when_latitude_is_too_low() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new( |
| br#"{ |
| "location": { |
| "lat": -90.1, |
| "lng": 0.0 |
| } |
| }"# |
| .to_vec(), |
| ); |
| assert_eq!( |
| RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await, |
| Err(ResolverError::Lookup) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_lookup_error_when_longitude_is_too_high() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new( |
| br#"{ |
| "location": { |
| "lat": 0.0, |
| "lng": 180.1 |
| } |
| }"# |
| .to_vec(), |
| ); |
| assert_eq!( |
| RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await, |
| Err(ResolverError::Lookup) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_lookup_error_when_longitude_is_too_low() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new( |
| br#"{ |
| "location": { |
| "lat": 0.0, |
| "lng": -180.1 |
| } |
| }"# |
| .to_vec(), |
| ); |
| assert_eq!( |
| RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await, |
| Err(ResolverError::Lookup) |
| ); |
| } |
| } |
| |
| mod response_success_reporting { |
| use { |
| super::super::{test_doubles::HttpByteResponder, *}, |
| fuchsia_async as fasync, |
| matches::assert_matches, |
| }; |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_success_when_all_fields_are_present() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new( |
| br#"{ |
| "location": { |
| "lat": 51.0, |
| "lng": -0.1 |
| }, |
| "accuracy": 1200.4 |
| }"# |
| .to_vec(), |
| ); |
| assert_matches!( |
| RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await, |
| Ok(_) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn returns_success_when_all_fields_except_accuracy_are_present() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new( |
| br#"{ |
| "location": { |
| "lat": 51.0, |
| "lng": -0.1 |
| } |
| }"# |
| .to_vec(), |
| ); |
| assert_matches!( |
| RealBssResolver::new(http_loader, "fake_key").resolve(bsses).await, |
| Ok(_) |
| ); |
| } |
| } |
| |
| mod response_success_contents { |
| use { |
| super::super::{test_doubles::HttpByteResponder, *}, |
| fuchsia_async as fasync, |
| matches::assert_matches, |
| }; |
| |
| #[fasync::run_until_stalled(test)] |
| async fn provides_precise_latitude() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new( |
| br#"{ |
| "location": { |
| "lat": 89.0, |
| "lng": 0 |
| } |
| }"# |
| .to_vec(), |
| ); |
| assert_matches!( |
| RealBssResolver::new(http_loader, "fake_key") |
| .resolve(bsses) |
| .await.expect("position is none").latitude, |
| // One degree of latitude is approximately 111 kilometers. By limiting rounding |
| // error to 1/10,000,000 of a degree, we limit rounding error to |
| // 111/10000 = 0.011 meters, or 1.1 cm. |
| latitude if (88.999_999_9..89.000_000_1).contains(&latitude) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn provides_precise_longitude() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new( |
| br#"{ |
| "location": { |
| "lat": 0, |
| "lng": 179.0 |
| } |
| }"# |
| .to_vec(), |
| ); |
| assert_matches!( |
| RealBssResolver::new(http_loader, "fake_key") |
| .resolve(bsses) |
| .await.expect("no position").longitude, |
| // At the equator, one degree of longitude is approximately 111 kilometers. |
| // By limiting rounding error to 1/10,000,000 of a degree, we limit rounding error |
| // to 111/10000 = 0.011 meters, or 1.1 cm. |
| longitude if (178.999_999_9..179.099_999_9).contains(&longitude) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn provides_precise_accuracy_when_present() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new( |
| br#"{ |
| "location": { |
| "lat": 51.0, |
| "lng": -0.1 |
| }, |
| "accuracy": 1200.4 |
| }"# |
| .to_vec(), |
| ); |
| assert_matches!( |
| RealBssResolver::new(http_loader, "fake_key") |
| .resolve(bsses) |
| .await.expect("no position").extras.accuracy_meters.expect("accuracy is none"), |
| accuracy if (1200.39..1200.41).contains(&accuracy) |
| ); |
| } |
| |
| #[fasync::run_until_stalled(test)] |
| async fn does_not_fabricate_accuracy() { |
| let bsses = vec![([0, 0, 0, 0, 0, 0], Bss { rssi: None, frequency: None })]; |
| let http_loader = HttpByteResponder::new( |
| br#"{ |
| "location": { |
| "lat": 51.0, |
| "lng": -0.1 |
| } |
| }"# |
| .to_vec(), |
| ); |
| assert_eq!( |
| RealBssResolver::new(http_loader, "fake_key") |
| .resolve(bsses) |
| .await |
| .expect("no position") |
| .extras |
| .accuracy_meters, |
| None |
| ); |
| } |
| } |
| } |
| |
| #[cfg(test)] |
| mod test_doubles { |
| use { |
| super::*, |
| fidl::endpoints::ClientEnd, |
| fidl_fuchsia_net_http::LoaderClientMarker, |
| fuchsia_async::futures::future::{ready, Ready}, |
| std::sync::RwLock, |
| }; |
| |
| const HTTP_OK: u32 = 200; |
| |
| type FetchResponse = Result<HttpResponse, FidlError>; |
| |
| // Test double that |
| // 1) invokes `validate` to run test assertions, and |
| // 2) returns HTTP_OK, assuming `validate` did not abort |
| pub(super) struct HttpRequestValidator<F> |
| where |
| F: FnMut(HttpRequest) + Send + Sync, |
| { |
| // RwLock is needed because |
| // a) we need interior mutability for F to be FnMut, and |
| // b) we need to implement Send and Sync. |
| validate: RwLock<F>, |
| } |
| |
| // Test double that invokes a function which yields `FetchResponse`, |
| // and returns that as a FIDL response. Useful for testing error |
| // handling. |
| pub(super) struct HttpFidlResponder<F> |
| where |
| F: Fn() -> FetchResponse + Send + Sync, |
| { |
| fetch: F, |
| } |
| |
| // Test double that invokes a function which yields a `Vec<u8>`, |
| // and returns the Vec as the HTTP response. Useful for testing |
| // response parsing. |
| pub(super) struct HttpByteResponder { |
| response: Vec<u8>, |
| } |
| |
| impl<F> HttpRequestValidator<F> |
| where |
| F: FnMut(HttpRequest) + Send + Sync, |
| { |
| pub(super) fn new(validate: F) -> Self { |
| Self { validate: RwLock::new(validate) } |
| } |
| } |
| |
| impl<F> LoaderProxyInterface for HttpRequestValidator<F> |
| where |
| F: FnMut(HttpRequest) + Send + Sync, |
| { |
| type FetchResponseFut = Ready<Result<HttpResponse, FidlError>>; |
| |
| fn fetch(&self, request: HttpRequest) -> Self::FetchResponseFut { |
| // Note: the `&mut *` here is due to https://github.com/rust-lang/rust/issues/65489 |
| let validate = &mut *self.validate.write().expect("internal error"); |
| let final_url = request.url.clone(); |
| validate(request); |
| ready(Ok(HttpResponse { |
| error: None, |
| body: None, |
| final_url, |
| status_code: Some(HTTP_OK), |
| status_line: None, |
| headers: None, |
| redirect: None, |
| ..HttpResponse::EMPTY |
| })) |
| } |
| |
| fn start( |
| &self, |
| _request: HttpRequest, |
| _client: ClientEnd<LoaderClientMarker>, |
| ) -> Result<(), FidlError> { |
| panic!("internal error: this fake does not implement `start()`"); |
| } |
| } |
| |
| impl<F> HttpFidlResponder<F> |
| where |
| F: Fn() -> FetchResponse + Send + Sync, |
| { |
| pub(super) fn new(fetch: F) -> Self { |
| Self { fetch } |
| } |
| } |
| |
| impl<F> LoaderProxyInterface for HttpFidlResponder<F> |
| where |
| F: Fn() -> FetchResponse + Send + Sync, |
| { |
| type FetchResponseFut = Ready<FetchResponse>; |
| |
| fn fetch(&self, _request: HttpRequest) -> Self::FetchResponseFut { |
| ready((self.fetch)()) |
| } |
| |
| fn start( |
| &self, |
| _request: HttpRequest, |
| _client: ClientEnd<LoaderClientMarker>, |
| ) -> Result<(), FidlError> { |
| panic!("internal error: this stub does not implement `start()`"); |
| } |
| } |
| |
| impl HttpByteResponder { |
| pub(super) fn new(response: Vec<u8>) -> Self { |
| Self { response } |
| } |
| } |
| |
| impl LoaderProxyInterface for HttpByteResponder { |
| type FetchResponseFut = Ready<FetchResponse>; |
| |
| fn fetch(&self, _request: HttpRequest) -> Self::FetchResponseFut { |
| let (local_socket, remote_socket) = |
| zx::Socket::create(zx::SocketOpts::STREAM).expect("internal error"); |
| local_socket.write(&self.response).expect("internal error"); |
| ready(Ok(HttpResponse { |
| error: None, |
| body: Some(remote_socket), |
| final_url: None, |
| status_code: Some(HTTP_OK), |
| status_line: None, |
| headers: None, |
| redirect: None, |
| ..HttpResponse::EMPTY |
| })) |
| } |
| |
| fn start( |
| &self, |
| _request: HttpRequest, |
| _client: ClientEnd<LoaderClientMarker>, |
| ) -> Result<(), FidlError> { |
| panic!("internal error: this stub does not implement `start()`"); |
| } |
| } |
| } |
