| // Copyright 2019 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 { |
| super::*, |
| crate::{ |
| client::{ConnectFailure, ConnectResult}, |
| Ssid, |
| }, |
| fidl_fuchsia_wlan_mlme as fidl_mlme, fuchsia_zircon as zx, |
| std::collections::VecDeque, |
| thiserror::Error, |
| wlan_rsn::{ |
| key::exchange::Key, |
| rsna::{SecAssocStatus, SecAssocUpdate, UpdateSink}, |
| }, |
| }; |
| |
| #[derive(Default)] |
| pub(crate) struct StatsCollector { |
| discovery_scan_stats: Option<PendingScanStats>, |
| /// Track successive connect attempts to the same SSID. This resets when attempt succeeds |
| /// or when attempting to connect to a different SSID from a previous attempt. |
| connect_attempts: Option<ConnectAttempts>, |
| /// Track the most recent disconnection. Intended to be sent out on connection success |
| /// so that client can compute time gap between last disconnect until reconnect. |
| /// This is cleared out as soon as a connection attempt succeeds. |
| previous_disconnect_info: Option<PreviousDisconnectInfo>, |
| } |
| |
| impl StatsCollector { |
| pub fn report_join_scan_started( |
| &mut self, |
| req: fidl_mlme::ScanRequest, |
| is_connected: bool, |
| ) -> Result<(), StatsError> { |
| let now = now(); |
| let pending_scan_stats = |
| PendingScanStats { scan_start_at: now, req, scan_start_while_connected: is_connected }; |
| self.connect_stats()?.pending_scan_stats.replace(pending_scan_stats); |
| Ok(()) |
| } |
| |
| /// Report the start of a new discovery scan so that StatsCollector will begin collecting |
| /// stats for it. If there's an existing pending scan stats, evict and return it. |
| pub fn report_discovery_scan_started( |
| &mut self, |
| req: fidl_mlme::ScanRequest, |
| is_connected: bool, |
| ) -> Option<PendingScanStats> { |
| let now = now(); |
| let pending_scan_stats = |
| PendingScanStats { scan_start_at: now, req, scan_start_while_connected: is_connected }; |
| self.discovery_scan_stats.replace(pending_scan_stats) |
| } |
| |
| pub fn report_discovery_scan_ended( |
| &mut self, |
| result: ScanResult, |
| bss_list: Option<&Vec<fidl_mlme::BssDescription>>, |
| ) -> Result<ScanStats, StatsError> { |
| let now = now(); |
| let pending_stats = self.discovery_scan_stats.take().ok_or(StatsError::NoPendingScan)?; |
| |
| let scan_stats = ScanStats { |
| scan_type: pending_stats.req.scan_type, |
| scan_start_while_connected: pending_stats.scan_start_while_connected, |
| scan_start_at: pending_stats.scan_start_at, |
| scan_end_at: now, |
| result, |
| bss_count: bss_list.map(|bss_list| bss_list.len()).unwrap_or(0), |
| }; |
| Ok(scan_stats) |
| } |
| |
| pub fn report_join_scan_ended( |
| &mut self, |
| result: ScanResult, |
| bss_count: usize, |
| ) -> Result<(), StatsError> { |
| let stats = ScanEndStats { scan_end_at: now(), result, bss_count }; |
| self.connect_stats()?.scan_end_stats.replace(stats); |
| Ok(()) |
| } |
| |
| /// Report the start of a new connect attempt so that StatsCollector will begin collecting |
| /// stats for it. If there's an existing pending connect stats, evict and return it. |
| pub fn report_connect_started(&mut self, ssid: Ssid) -> Option<PendingConnectStats> { |
| match self.connect_attempts.as_mut() { |
| Some(connect_attempts) => connect_attempts.update_with_new_attempt(ssid), |
| None => { |
| self.connect_attempts = Some(ConnectAttempts::new(ssid)); |
| None |
| } |
| } |
| } |
| |
| pub fn report_candidate_network( |
| &mut self, |
| desc: fidl_mlme::BssDescription, |
| ) -> Result<(), StatsError> { |
| self.connect_stats()?.candidate_network.replace(desc); |
| Ok(()) |
| } |
| |
| pub fn report_auth_started(&mut self) -> Result<(), StatsError> { |
| self.connect_stats()?.auth_start_at.replace(now()); |
| Ok(()) |
| } |
| |
| pub fn report_assoc_started(&mut self) -> Result<(), StatsError> { |
| let pending_stats = self.connect_stats()?; |
| let now = now(); |
| pending_stats.auth_end_at.replace(now); |
| pending_stats.assoc_start_at.replace(now); |
| Ok(()) |
| } |
| |
| pub fn report_assoc_success(&mut self) -> Result<(), StatsError> { |
| self.connect_stats()?.assoc_end_at.replace(now()); |
| Ok(()) |
| } |
| |
| pub fn report_rsna_started(&mut self) -> Result<(), StatsError> { |
| self.connect_stats()?.rsna_start_at.replace(now()); |
| Ok(()) |
| } |
| |
| pub fn report_rsna_established(&mut self) -> Result<(), StatsError> { |
| self.connect_stats()?.rsna_end_at.replace(now()); |
| Ok(()) |
| } |
| |
| /// Report updates derived from the supplicant. Used to record progress of establish RSNA step. |
| pub fn report_supplicant_updates( |
| &mut self, |
| update_sink: &UpdateSink, |
| ) -> Result<(), StatsError> { |
| let supplicant_progress = |
| self.connect_stats()?.supplicant_progress.get_or_insert(SupplicantProgress::default()); |
| for update in update_sink { |
| match update { |
| SecAssocUpdate::Status(status) => match status { |
| SecAssocStatus::PmkSaEstablished => { |
| supplicant_progress.pmksa_established = true |
| } |
| SecAssocStatus::EssSaEstablished => { |
| supplicant_progress.esssa_established = true |
| } |
| _ => (), |
| }, |
| SecAssocUpdate::Key(key) => match key { |
| Key::Ptk(..) => supplicant_progress.ptksa_established = true, |
| Key::Gtk(..) => supplicant_progress.gtksa_established = true, |
| _ => (), |
| }, |
| _ => (), |
| } |
| } |
| Ok(()) |
| } |
| |
| pub fn report_supplicant_error(&mut self, error: anyhow::Error) -> Result<(), StatsError> { |
| self.connect_stats()?.supplicant_error.replace(error); |
| Ok(()) |
| } |
| |
| pub fn report_key_exchange_timeout(&mut self) -> Result<(), StatsError> { |
| self.connect_stats()?.num_rsna_key_frame_exchange_timeout += 1; |
| Ok(()) |
| } |
| |
| pub fn report_connect_finished( |
| &mut self, |
| result: ConnectResult, |
| ) -> Result<ConnectStats, StatsError> { |
| let mut connect_attempts = |
| self.connect_attempts.take().ok_or(StatsError::NoPendingConnect)?; |
| let stats = self.finalize_connect_stats(&mut connect_attempts, result.clone())?; |
| |
| if result != ConnectResult::Success { |
| // Successive connect attempts are still tracked unless connection is successful |
| self.connect_attempts.replace(connect_attempts); |
| } |
| Ok(stats) |
| } |
| |
| fn connect_stats(&mut self) -> Result<&mut PendingConnectStats, StatsError> { |
| self.connect_attempts |
| .as_mut() |
| .and_then(|a| a.stats.as_mut()) |
| .ok_or(StatsError::NoPendingConnect) |
| } |
| |
| fn finalize_connect_stats( |
| &mut self, |
| connect_attempts: &mut ConnectAttempts, |
| result: ConnectResult, |
| ) -> Result<ConnectStats, StatsError> { |
| let now = now(); |
| let pending_stats = connect_attempts.handle_result(&result, now)?; |
| let previous_disconnect_info = match &result { |
| ConnectResult::Success => self.previous_disconnect_info.take(), |
| _ => None, |
| }; |
| |
| Ok(ConnectStats { |
| connect_start_at: pending_stats.connect_start_at, |
| connect_end_at: now, |
| scan_start_stats: pending_stats.pending_scan_stats.map(|stats| ScanStartStats { |
| scan_start_at: stats.scan_start_at, |
| scan_type: stats.req.scan_type, |
| scan_start_while_connected: stats.scan_start_while_connected, |
| }), |
| scan_end_stats: pending_stats.scan_end_stats, |
| auth_start_at: pending_stats.auth_start_at, |
| auth_end_at: pending_stats.auth_end_at, |
| assoc_start_at: pending_stats.assoc_start_at, |
| assoc_end_at: pending_stats.assoc_end_at, |
| rsna_start_at: pending_stats.rsna_start_at, |
| rsna_end_at: pending_stats.rsna_end_at, |
| result, |
| candidate_network: pending_stats.candidate_network, |
| supplicant_error: pending_stats.supplicant_error, |
| supplicant_progress: pending_stats.supplicant_progress, |
| num_rsna_key_frame_exchange_timeout: pending_stats.num_rsna_key_frame_exchange_timeout, |
| attempts: connect_attempts.attempts, |
| last_ten_failures: connect_attempts.last_ten_failures.iter().cloned().collect(), |
| previous_disconnect_info, |
| }) |
| } |
| |
| pub fn report_disconnect(&mut self, ssid: Ssid, source: DisconnectSource) { |
| self.previous_disconnect_info.replace(PreviousDisconnectInfo { |
| ssid, |
| disconnect_source: source, |
| disconnect_at: now(), |
| }); |
| } |
| } |
| |
| fn now() -> zx::Time { |
| zx::Time::get_monotonic() |
| } |
| |
| struct ConnectAttempts { |
| ssid: Ssid, |
| attempts: u32, |
| last_ten_failures: VecDeque<ConnectFailure>, |
| stats: Option<PendingConnectStats>, |
| } |
| |
| impl ConnectAttempts { |
| const MAX_FAILURES_TRACKED: usize = 10; |
| |
| pub fn new(ssid: Ssid) -> Self { |
| Self { |
| ssid, |
| attempts: 1, |
| last_ten_failures: VecDeque::with_capacity(Self::MAX_FAILURES_TRACKED), |
| stats: Some(PendingConnectStats::new(now())), |
| } |
| } |
| |
| /// Increment attempt counter if same SSID. Otherwise, reset and start tracking connect |
| /// attempts for the new SSID. |
| /// |
| /// Additionally, evict and return any existing PendingConnectStats. |
| pub fn update_with_new_attempt(&mut self, ssid: Ssid) -> Option<PendingConnectStats> { |
| if self.ssid == ssid { |
| self.attempts += 1; |
| } else { |
| self.ssid = ssid; |
| self.attempts = 1; |
| self.last_ten_failures.clear(); |
| } |
| self.stats.replace(PendingConnectStats::new(now())) |
| } |
| |
| pub fn handle_result( |
| &mut self, |
| result: &ConnectResult, |
| now: zx::Time, |
| ) -> Result<PendingConnectStats, StatsError> { |
| let mut pending_stats = self.stats.take().ok_or(StatsError::NoPendingConnect)?; |
| match result { |
| ConnectResult::Failed(failure) => match failure { |
| ConnectFailure::ScanFailure(code) => { |
| pending_stats.scan_end_stats.replace(ScanEndStats { |
| scan_end_at: now, |
| result: ScanResult::Failed(*code), |
| bss_count: 0, |
| }); |
| } |
| ConnectFailure::AuthenticationFailure(..) => { |
| pending_stats.auth_end_at.replace(now); |
| } |
| ConnectFailure::AssociationFailure(..) => { |
| pending_stats.assoc_end_at.replace(now); |
| } |
| ConnectFailure::EstablishRsnaFailure(..) => { |
| pending_stats.rsna_end_at.replace(now); |
| } |
| _ => (), |
| }, |
| _ => (), |
| } |
| |
| if let ConnectResult::Failed(failure) = result { |
| if self.last_ten_failures.len() >= Self::MAX_FAILURES_TRACKED { |
| self.last_ten_failures.pop_front(); |
| } |
| self.last_ten_failures.push_back(failure.clone()); |
| } |
| |
| Ok(pending_stats) |
| } |
| } |
| |
| #[derive(Debug, Error)] |
| pub(crate) enum StatsError { |
| #[error("no current pending connect")] |
| NoPendingConnect, |
| #[error("no current pending scan")] |
| NoPendingScan, |
| } |
| |
| pub(crate) struct PendingScanStats { |
| scan_start_at: zx::Time, |
| req: fidl_mlme::ScanRequest, |
| scan_start_while_connected: bool, |
| } |
| |
| pub(crate) struct PendingConnectStats { |
| connect_start_at: zx::Time, |
| pending_scan_stats: Option<PendingScanStats>, |
| scan_end_stats: Option<ScanEndStats>, |
| auth_start_at: Option<zx::Time>, |
| auth_end_at: Option<zx::Time>, |
| assoc_start_at: Option<zx::Time>, |
| assoc_end_at: Option<zx::Time>, |
| rsna_start_at: Option<zx::Time>, |
| rsna_end_at: Option<zx::Time>, |
| candidate_network: Option<fidl_mlme::BssDescription>, |
| supplicant_error: Option<anyhow::Error>, |
| supplicant_progress: Option<SupplicantProgress>, |
| num_rsna_key_frame_exchange_timeout: u32, |
| } |
| |
| impl PendingConnectStats { |
| fn new(connect_start_at: zx::Time) -> Self { |
| Self { |
| connect_start_at, |
| pending_scan_stats: None, |
| scan_end_stats: None, |
| auth_start_at: None, |
| auth_end_at: None, |
| assoc_start_at: None, |
| assoc_end_at: None, |
| rsna_start_at: None, |
| rsna_end_at: None, |
| candidate_network: None, |
| supplicant_error: None, |
| supplicant_progress: None, |
| num_rsna_key_frame_exchange_timeout: 0, |
| } |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use { |
| super::*, |
| crate::client::{ |
| test_utils::fake_scan_request, EstablishRsnaFailure, EstablishRsnaFailureReason, |
| SelectNetworkFailure, |
| }, |
| anyhow::format_err, |
| wlan_common::{assert_variant, fake_bss}, |
| wlan_rsn::auth, |
| }; |
| |
| const SSID: &[u8; 3] = b"foo"; |
| |
| #[test] |
| fn test_discovery_scan_stats_lifecycle() { |
| let mut stats_collector = StatsCollector::default(); |
| let req = fake_scan_request(); |
| let is_connected = true; |
| assert!(stats_collector.report_discovery_scan_started(req, is_connected).is_none()); |
| |
| let bss_desc = fake_bss!(Open, ssid: SSID.to_vec(), rates: vec![12]); |
| let stats = |
| stats_collector.report_discovery_scan_ended(ScanResult::Success, Some(&vec![bss_desc])); |
| assert_variant!(stats, Ok(scan_stats) => { |
| assert!(scan_stats.scan_time().into_nanos() > 0); |
| assert_eq!(scan_stats.scan_type, fidl_mlme::ScanTypes::Active); |
| assert_eq!(scan_stats.scan_start_while_connected, is_connected); |
| assert_eq!(scan_stats.result, ScanResult::Success); |
| assert_eq!(scan_stats.bss_count, 1); |
| }) |
| } |
| |
| #[test] |
| fn test_connect_stats_lifecycle() { |
| let mut stats_collector = StatsCollector::default(); |
| let stats = simulate_connect_lifecycle(&mut stats_collector); |
| |
| assert_variant!(stats, Ok(stats) => { |
| assert!(stats.connect_time().into_nanos() > 0); |
| assert_variant!(stats.join_scan_stats(), Some(scan_stats) => { |
| assert!(scan_stats.scan_time().into_nanos() > 0); |
| assert_eq!(scan_stats.scan_type, fidl_mlme::ScanTypes::Active); |
| assert_eq!(scan_stats.scan_start_while_connected, false); |
| assert_eq!(scan_stats.result, ScanResult::Success); |
| assert_eq!(scan_stats.bss_count, 1); |
| }); |
| assert!(stats.auth_time().is_some()); |
| assert!(stats.assoc_time().is_some()); |
| assert!(stats.rsna_time().is_some()); |
| assert_eq!(stats.result, ConnectResult::Success); |
| let bss_desc = fake_bss!(Wpa2, ssid: SSID.to_vec()); |
| assert_eq!(stats.candidate_network, Some(bss_desc)); |
| }); |
| } |
| |
| #[test] |
| fn test_connect_stats_finalized_midway() { |
| let mut stats_collector = StatsCollector::default(); |
| |
| assert!(stats_collector.report_connect_started(b"foo".to_vec()).is_none()); |
| let scan_req = fake_scan_request(); |
| assert!(stats_collector.report_join_scan_started(scan_req, false).is_ok()); |
| assert!(stats_collector.report_join_scan_ended(ScanResult::Success, 1).is_ok()); |
| let bss_desc = fake_bss!(Wpa2, ssid: SSID.to_vec()); |
| assert!(stats_collector.report_candidate_network(bss_desc).is_ok()); |
| assert!(stats_collector.report_auth_started().is_ok()); |
| let result = ConnectResult::Failed(ConnectFailure::AuthenticationFailure( |
| fidl_mlme::AuthenticateResultCodes::Refused, |
| )); |
| let stats = stats_collector.report_connect_finished(result.clone()); |
| |
| assert_variant!(stats, Ok(stats) => { |
| assert!(stats.connect_time().into_nanos() > 0); |
| assert!(stats.join_scan_stats().is_some()); |
| assert!(stats.auth_time().is_some()); |
| assert!(stats.assoc_time().is_none()); |
| assert!(stats.rsna_time().is_none()); |
| assert_eq!(stats.result, result); |
| assert!(stats.candidate_network.is_some()); |
| }); |
| } |
| |
| #[test] |
| fn test_connect_stats_establish_rsna_failure() { |
| let mut stats_collector = StatsCollector::default(); |
| |
| assert!(stats_collector.report_connect_started(b"foo".to_vec()).is_none()); |
| // Connecting should complete other steps first before starting establish RSNA step, |
| // but for testing starting with RSNA step right away is sufficient. |
| assert!(stats_collector.report_rsna_started().is_ok()); |
| let update_sink = vec![SecAssocUpdate::Status(SecAssocStatus::PmkSaEstablished)]; |
| assert!(stats_collector.report_supplicant_updates(&update_sink).is_ok()); |
| assert!(stats_collector.report_key_exchange_timeout().is_ok()); |
| assert!(stats_collector.report_key_exchange_timeout().is_ok()); |
| |
| assert!(stats_collector.report_supplicant_error(format_err!("blah")).is_ok()); |
| let stats = stats_collector.report_connect_finished( |
| EstablishRsnaFailure { |
| auth_method: Some(auth::MethodName::Psk), |
| reason: EstablishRsnaFailureReason::OverallTimeout, |
| } |
| .into(), |
| ); |
| |
| assert_variant!(stats, Ok(stats) => { |
| assert!(stats.supplicant_error.is_some()); |
| assert_variant!(stats.supplicant_progress, Some(SupplicantProgress { |
| pmksa_established: true, |
| ptksa_established: false, |
| gtksa_established: false, |
| esssa_established: false, |
| })); |
| assert_eq!(stats.num_rsna_key_frame_exchange_timeout, 2); |
| }); |
| } |
| |
| #[test] |
| fn test_consecutive_connect_attempts_stats() { |
| let mut stats_collector = StatsCollector::default(); |
| |
| assert!(stats_collector.report_connect_started(b"foo".to_vec()).is_none()); |
| let failure1: ConnectFailure = SelectNetworkFailure::NoScanResultWithSsid.into(); |
| let stats = stats_collector.report_connect_finished(failure1.clone().into()); |
| assert_variant!(stats, Ok(stats) => { |
| assert_eq!(stats.attempts, 1); |
| assert_eq!(stats.last_ten_failures, &[failure1.clone()]) |
| }); |
| |
| assert!(stats_collector.report_connect_started(b"foo".to_vec()).is_none()); |
| let failure2: ConnectFailure = EstablishRsnaFailure { |
| auth_method: Some(auth::MethodName::Psk), |
| reason: EstablishRsnaFailureReason::OverallTimeout, |
| } |
| .into(); |
| let stats = stats_collector.report_connect_finished(failure2.clone().into()); |
| assert_variant!(stats, Ok(stats) => { |
| assert_eq!(stats.attempts, 2); |
| assert_eq!(stats.last_ten_failures, &[failure1.clone(), failure2.clone()]); |
| }); |
| |
| assert!(stats_collector.report_connect_started(b"foo".to_vec()).is_none()); |
| let stats = stats_collector.report_connect_finished(ConnectResult::Success); |
| assert_variant!(stats, Ok(stats) => { |
| assert_eq!(stats.attempts, 3); |
| assert_eq!(stats.last_ten_failures, &[failure1.clone(), failure2.clone()]); |
| }); |
| |
| // After a successful connection, new connect attempts tracking is reset |
| assert!(stats_collector.report_connect_started(b"foo".to_vec()).is_none()); |
| let stats = stats_collector.report_connect_finished(ConnectResult::Success); |
| assert_variant!(stats, Ok(stats) => { |
| assert_eq!(stats.attempts, 1); |
| assert_eq!(stats.last_ten_failures, &[]) |
| }); |
| } |
| |
| #[test] |
| fn test_consecutive_connect_attempts_different_ssid_resets_stats() { |
| let mut stats_collector = StatsCollector::default(); |
| |
| assert!(stats_collector.report_connect_started(b"foo".to_vec()).is_none()); |
| let failure1: ConnectFailure = SelectNetworkFailure::NoScanResultWithSsid.into(); |
| let _stats = stats_collector.report_connect_finished(failure1.clone().into()); |
| |
| assert!(stats_collector.report_connect_started(b"bar".to_vec()).is_none()); |
| let failure2: ConnectFailure = EstablishRsnaFailure { |
| auth_method: Some(auth::MethodName::Psk), |
| reason: EstablishRsnaFailureReason::OverallTimeout, |
| } |
| .into(); |
| let stats = stats_collector.report_connect_finished(failure2.clone().into()); |
| assert_variant!(stats, Ok(stats) => { |
| assert_eq!(stats.attempts, 1); |
| assert_eq!(stats.last_ten_failures, &[failure2.clone()]); |
| }); |
| } |
| |
| #[test] |
| fn test_consecutive_connect_attempts_only_ten_failures_are_tracked() { |
| let mut stats_collector = StatsCollector::default(); |
| for i in 1..=20 { |
| assert!(stats_collector.report_connect_started(b"foo".to_vec()).is_none()); |
| let stats = stats_collector |
| .report_connect_finished(SelectNetworkFailure::NoScanResultWithSsid.into()); |
| assert_variant!(stats, Ok(stats) => { |
| assert_eq!(stats.attempts, i); |
| assert_eq!(stats.last_ten_failures.len(), std::cmp::min(i as usize, 10)); |
| }); |
| } |
| } |
| |
| #[test] |
| fn test_disconnect_then_reconnect() { |
| let mut stats_collector = StatsCollector::default(); |
| let stats = simulate_connect_lifecycle(&mut stats_collector); |
| assert_variant!(stats, Ok(stats) => stats.previous_disconnect_info.is_none()); |
| |
| stats_collector.report_disconnect(b"foo".to_vec(), DisconnectSource::User); |
| let stats = simulate_connect_lifecycle(&mut stats_collector); |
| assert_variant!(stats, Ok(stats) => { |
| assert_variant!(stats.previous_disconnect_info, Some(info) => { |
| assert_eq!(info.disconnect_source, DisconnectSource::User); |
| }) |
| }); |
| } |
| |
| #[test] |
| fn test_disconnect_then_connect_fails_before_succeeding() { |
| let mut stats_collector = StatsCollector::default(); |
| |
| // Connects then disconnect |
| let stats = simulate_connect_lifecycle(&mut stats_collector); |
| assert_variant!(stats, Ok(stats) => stats.previous_disconnect_info.is_none()); |
| stats_collector.report_disconnect(b"foo".to_vec(), DisconnectSource::User); |
| |
| // Attempt to connect but fails |
| assert!(stats_collector.report_connect_started(b"foo".to_vec()).is_none()); |
| let scan_req = fake_scan_request(); |
| assert!(stats_collector.report_join_scan_started(scan_req, false).is_ok()); |
| let failure = ConnectFailure::ScanFailure(fidl_mlme::ScanResultCodes::InternalError).into(); |
| let stats = stats_collector.report_connect_finished(failure); |
| |
| // Previous disconnect info should not be reported on fail attempt |
| assert_variant!(stats, Ok(stats) => stats.previous_disconnect_info.is_none()); |
| |
| // Connect now succeeds, hence previous disconnect info is reported |
| let stats = simulate_connect_lifecycle(&mut stats_collector); |
| assert_variant!(stats, Ok(stats) => { |
| assert_variant!(stats.previous_disconnect_info, Some(info) => { |
| assert_eq!(info.disconnect_source, DisconnectSource::User); |
| }) |
| }); |
| } |
| |
| #[test] |
| fn test_no_pending_discovery_scan_stats() { |
| let mut stats_collector = StatsCollector::default(); |
| let bss_desc = fake_bss!(Wpa2, ssid: SSID.to_vec()); |
| let stats = |
| stats_collector.report_discovery_scan_ended(ScanResult::Success, Some(&vec![bss_desc])); |
| assert_variant!(stats, Err(StatsError::NoPendingScan)); |
| } |
| |
| #[test] |
| fn test_no_pending_connect_stats() { |
| assert_variant!( |
| StatsCollector::default().report_join_scan_ended(ScanResult::Success, 1), |
| Err(StatsError::NoPendingConnect) |
| ); |
| let bss_desc = fake_bss!(Wpa2, ssid: SSID.to_vec()); |
| assert_variant!( |
| StatsCollector::default().report_candidate_network(bss_desc), |
| Err(StatsError::NoPendingConnect) |
| ); |
| assert_variant!( |
| StatsCollector::default().report_auth_started(), |
| Err(StatsError::NoPendingConnect) |
| ); |
| assert_variant!( |
| StatsCollector::default().report_assoc_started(), |
| Err(StatsError::NoPendingConnect) |
| ); |
| assert_variant!( |
| StatsCollector::default().report_assoc_success(), |
| Err(StatsError::NoPendingConnect) |
| ); |
| assert_variant!( |
| StatsCollector::default().report_rsna_started(), |
| Err(StatsError::NoPendingConnect) |
| ); |
| assert_variant!( |
| StatsCollector::default().report_rsna_established(), |
| Err(StatsError::NoPendingConnect) |
| ); |
| assert_variant!( |
| StatsCollector::default().report_connect_finished(ConnectResult::Success), |
| Err(StatsError::NoPendingConnect) |
| ); |
| } |
| |
| fn simulate_connect_lifecycle( |
| stats_collector: &mut StatsCollector, |
| ) -> Result<ConnectStats, StatsError> { |
| assert!(stats_collector.report_connect_started(SSID.to_vec()).is_none()); |
| let scan_req = fake_scan_request(); |
| assert!(stats_collector.report_join_scan_started(scan_req, false).is_ok()); |
| assert!(stats_collector.report_join_scan_ended(ScanResult::Success, 1).is_ok()); |
| let bss_desc = fake_bss!(Wpa2, ssid: SSID.to_vec()); |
| assert!(stats_collector.report_candidate_network(bss_desc).is_ok()); |
| assert!(stats_collector.report_auth_started().is_ok()); |
| assert!(stats_collector.report_assoc_started().is_ok()); |
| assert!(stats_collector.report_assoc_success().is_ok()); |
| assert!(stats_collector.report_rsna_started().is_ok()); |
| assert!(stats_collector.report_rsna_established().is_ok()); |
| stats_collector.report_connect_finished(ConnectResult::Success) |
| } |
| } |
