use super::*;
use crate::error::ErrorKind;
use crate::module::net_status::inner::network_status_snapshot::NetworkNameUpdate;
use crate::module::net_status::inner::refresh::{SampleObservation, WindowsSampler};
use crate::net_status::NetworkNameSource;
use std::sync::atomic::AtomicUsize;
use std::time::{Instant, SystemTime};
type TestResult = Result<(), Box<dyn std::error::Error + Send + Sync>>;
fn running() -> Result<
(
NetworkStatusSource,
Arc<Mutex<MonitorState>>,
NetworkStatusPublisher,
),
NetError,
> {
let source = NetworkStatusSource::for_test()?;
let (publisher, initial) = source.begin_generation()?;
initial.dispatch()?;
publisher
.prepare_observation(
NetworkStatus::Available,
Some(IpStack::DualStack),
Some("old-name".into()),
)?
.dispatch()?;
let state = Arc::new(Mutex::new(MonitorState {
active: Arc::new(AtomicBool::new(true)),
observation: Some(publisher.clone()),
}));
Ok((source, state, publisher))
}
fn name_sample() -> SampleObservation {
SampleObservation {
reachability: NetworkStatus::Available,
network_name: Some("fresh-name".into()),
name_source: NetworkNameSource::NetworkListManager,
name_diagnostics: vec![],
}
}
#[cfg(test)]
#[tokio::test]
async fn name_fault_retries_and_slow_name_cannot_replace_newer_reachability() -> TestResult {
let (source, state, publisher) = running()?;
publisher
.prepare_sampled_observation(
100,
NetworkStatus::Unavailable,
Some(IpStack::V4Only),
NetworkNameUpdate::Preserve,
SystemTime::now(),
|| Ok(true),
)?
.ok_or("fresh reachability was rejected")?
.dispatch()?;
let mut facts = source.subscribe_facts();
facts.borrow_and_update();
let calls = Arc::new(AtomicUsize::new(0));
let counted = calls.clone();
let sampler = Arc::new(WindowsSampler::with_provider(Arc::new(move |_, _| {
if counted.fetch_add(1, Ordering::AcqRel) == 0 {
Err(NetError::from(ErrorKind::Io))
} else {
Ok(name_sample())
}
})));
let owner = state.clone();
let task =
tokio::spawn(
async move { InnerNetStatusClient::monitor_windows_names(&owner, &sampler).await },
);
let changed = tokio::time::timeout(Duration::from_secs(5), facts.changed()).await;
task.abort();
let _ = task.await;
changed??;
let snapshot = source.snapshot()?;
assert_eq!(snapshot.network_name.as_deref(), Some("fresh-name"));
assert_eq!(snapshot.reachability, Some(NetworkStatus::Unavailable));
assert_eq!(snapshot.ip_stack, Some(IpStack::V4Only));
assert!(matches!(snapshot.state, PublicMonitorState::Running));
assert!(calls.load(Ordering::Acquire) >= 2);
Ok(())
}
#[cfg(test)]
#[tokio::test]
async fn retiring_name_future_cancels_native_query_and_releases_monitor_owner() -> TestResult {
let (source, state, _publisher) = running()?;
let before = source.snapshot()?;
let (entered, entered_rx) = tokio::sync::oneshot::channel();
let entered = Mutex::new(Some(entered));
let (release, released) = std::sync::mpsc::channel();
let released = Mutex::new(released);
let cancelled = Arc::new(AtomicBool::new(false));
let observed_cancel = cancelled.clone();
let calls = Arc::new(AtomicUsize::new(0));
let counted = calls.clone();
let sampler = Arc::new(WindowsSampler::with_provider(Arc::new(
move |_, cancellation| {
if counted.fetch_add(1, Ordering::AcqRel) == 0 {
if let Some(entered) = entered.lock().map_err(NetError::from_poison)?.take() {
let _ = entered.send(());
}
released
.lock()
.map_err(NetError::from_poison)?
.recv_timeout(Duration::from_secs(5))
.map_err(|_| NetError::from(ErrorKind::Internal))?;
observed_cancel.store(cancellation.load(Ordering::Acquire), Ordering::Release);
}
Ok(name_sample())
},
)));
let owner = state.clone();
let task_sampler = sampler.clone();
let task = tokio::spawn(async move {
InnerNetStatusClient::monitor_windows_names(&owner, &task_sampler).await
});
tokio::time::timeout(Duration::from_secs(3), entered_rx).await??;
task.abort();
let _ = task.await;
assert_eq!(
Arc::strong_count(&state),
1,
"retired name future pinned monitor state"
);
release.send(())?;
tokio::time::timeout(
Duration::from_secs(3),
sampler.sample(
Instant::now() + Duration::from_secs(3),
Arc::new(AtomicBool::new(false)),
),
)
.await??;
assert!(cancelled.load(Ordering::Acquire));
let after = source.snapshot()?;
assert_eq!(after.revision, before.revision);
assert_eq!(after.network_name, before.network_name);
assert_eq!(after.reachability, before.reachability);
Ok(())
}