pub(crate) mod routes;
pub mod state;
use std::net::SocketAddr;
use std::sync::Arc;
use tokio::net::TcpListener;
use tokio::sync::RwLock;
use tokio::task::JoinHandle;
use state::{MockState, SharedState};
use crate::types::datafeed::DataFeed;
#[cfg(feature = "client")]
use crate::client::VatsimClient;
pub struct MockServer {
state: SharedState,
listener: TcpListener,
security_headers: bool,
}
pub struct MockServerBuilder {
state: MockState,
bind_addr: String,
security_headers: bool,
}
pub struct MockServerHandle {
base_url: String,
state: SharedState,
shutdown_tx: tokio::sync::watch::Sender<bool>,
join_handle: Option<JoinHandle<()>>,
}
impl MockServer {
#[must_use]
pub fn builder() -> MockServerBuilder {
MockServerBuilder {
state: MockState::default(),
bind_addr: "127.0.0.1:0".to_owned(),
security_headers: false,
}
}
pub async fn serve(self) -> std::io::Result<()> {
let router = routes::router(self.state, self.security_headers);
axum::serve(self.listener, router).await
}
pub async fn serve_with_shutdown<F>(self, shutdown: F) -> std::io::Result<()>
where
F: std::future::Future<Output = ()> + Send + 'static,
{
let router = routes::router(self.state, self.security_headers);
axum::serve(self.listener, router)
.with_graceful_shutdown(shutdown)
.await
}
pub fn local_addr(&self) -> std::io::Result<SocketAddr> {
self.listener.local_addr()
}
pub fn spawn(self) -> std::io::Result<MockServerHandle> {
let addr = self.listener.local_addr()?;
let base_url = format!("http://{addr}");
let state = Arc::clone(&self.state);
let (shutdown_tx, mut shutdown_rx) = tokio::sync::watch::channel(false);
let router = routes::router(self.state, self.security_headers);
let join_handle = tokio::spawn(async move {
axum::serve(self.listener, router)
.with_graceful_shutdown(async move {
shutdown_rx.changed().await.ok();
})
.await
.ok();
});
Ok(MockServerHandle {
base_url,
state,
shutdown_tx,
join_handle: Some(join_handle),
})
}
}
impl MockServerBuilder {
#[must_use]
pub fn bind(mut self, addr: impl Into<String>) -> Self {
self.bind_addr = addr.into();
self
}
#[must_use]
pub fn state(mut self, state: MockState) -> Self {
self.state = state;
self
}
#[must_use]
pub fn pilots(mut self, pilots: Vec<crate::types::datafeed::Pilot>) -> Self {
self.state.pilots = pilots;
self
}
#[must_use]
pub fn controllers(mut self, controllers: Vec<crate::types::datafeed::Controller>) -> Self {
self.state.controllers = controllers;
self
}
#[must_use]
pub fn atis(mut self, atis: Vec<crate::types::datafeed::Atis>) -> Self {
self.state.atis = atis;
self
}
#[must_use]
pub fn servers(mut self, servers: Vec<crate::types::datafeed::Server>) -> Self {
self.state.servers = servers;
self
}
#[must_use]
pub fn prefiles(mut self, prefiles: Vec<crate::types::datafeed::Prefile>) -> Self {
self.state.prefiles = prefiles;
self
}
#[must_use]
pub fn users(mut self, users: Vec<crate::types::connect::ConnectUser>) -> Self {
self.state.users = users;
self
}
#[must_use]
pub fn security_headers(mut self, enable: bool) -> Self {
self.security_headers = enable;
self
}
#[must_use]
pub fn seed(mut self, feed: DataFeed) -> Self {
self.state = MockState::from(feed);
self
}
pub async fn build(self) -> std::io::Result<MockServer> {
let listener = TcpListener::bind(&self.bind_addr).await?;
let mut state = self.state;
state.snapshot_seed();
Ok(MockServer {
state: Arc::new(RwLock::new(state)),
listener,
security_headers: self.security_headers,
})
}
pub async fn spawn(self) -> std::io::Result<MockServerHandle> {
self.build().await?.spawn()
}
}
impl MockServerHandle {
#[must_use]
pub fn base_url(&self) -> &str {
&self.base_url
}
#[must_use]
pub fn state(&self) -> &SharedState {
&self.state
}
#[cfg(feature = "client")]
#[must_use]
pub fn client(&self) -> VatsimClient {
VatsimClient::with_mock_base_url(&self.base_url)
}
pub async fn shutdown(mut self) {
self.shutdown_tx.send(true).ok();
if let Some(handle) = self.join_handle.take() {
handle.await.ok();
}
}
}
impl Drop for MockServerHandle {
fn drop(&mut self) {
self.shutdown_tx.send(true).ok();
}
}