use axum::Json;
use axum::extract::{Query, State};
use axum::response::{IntoResponse, Response};
use axum::routing::post;
use super::mock::MockHubject;
use crate::cpo::{
AuthorizeStartRequest, AuthorizeStopRequest, ChargeDetailRecord, ChargingNotification,
PushEvseDataRequest, PushEvseStatusRequest,
};
use crate::emp::{PullEvseDataRequest, PullEvseStatusByIdRequest, PullEvseStatusRequest};
use crate::transport::{Operation, PageQuery};
use crate::types::{Acknowledgement, Code};
pub struct MockHubjectServer {
hubject: MockHubject,
base_url: String,
shutdown: Option<tokio::sync::oneshot::Sender<()>>,
handle: Option<tokio::task::JoinHandle<()>>,
}
impl MockHubjectServer {
pub async fn start(hubject: MockHubject) -> std::io::Result<Self> {
Self::bind(hubject, "127.0.0.1:0").await
}
pub async fn bind(hubject: MockHubject, address: &str) -> std::io::Result<Self> {
let listener = tokio::net::TcpListener::bind(address).await?;
let local = listener.local_addr()?;
let router = router(hubject.clone());
let (shutdown, signal) = tokio::sync::oneshot::channel();
let handle = tokio::spawn(async move {
let served = axum::serve(listener, router).with_graceful_shutdown(async {
let _ = signal.await;
});
if let Err(error) = served.await {
tracing::error!(target: "oicp_kit::testkit", %error, "the mock broker stopped");
}
});
Ok(Self {
hubject,
base_url: format!("http://{local}/api/oicp"),
shutdown: Some(shutdown),
handle: Some(handle),
})
}
#[must_use]
pub fn base_url(&self) -> &str {
&self.base_url
}
#[must_use]
pub fn environment(&self) -> crate::transport::HubjectEnv {
crate::transport::HubjectEnv::Custom(self.base_url.clone())
}
#[must_use]
pub const fn hubject(&self) -> &MockHubject {
&self.hubject
}
pub async fn stop(mut self) {
if let Some(shutdown) = self.shutdown.take() {
let _ = shutdown.send(());
}
if let Some(handle) = self.handle.take() {
let _ = handle.await;
}
}
}
impl Drop for MockHubjectServer {
fn drop(&mut self) {
if let Some(shutdown) = self.shutdown.take() {
let _ = shutdown.send(());
}
}
}
impl core::fmt::Debug for MockHubjectServer {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
f.debug_struct("MockHubjectServer").field("base_url", &self.base_url).finish_non_exhaustive()
}
}
fn router(hubject: MockHubject) -> axum::Router {
let paths = axum::Router::new()
.route(
Operation::PushEvseData.path_template(),
post(|State(h): State<MockHubject>, Json(body): Json<serde_json::Value>| async move {
acknowledge(decode::<PushEvseDataRequest>(body).map(|r| h.push_evse_data(&r)))
}),
)
.route(
Operation::PushEvseStatus.path_template(),
post(|State(h): State<MockHubject>, Json(body): Json<serde_json::Value>| async move {
acknowledge(decode::<PushEvseStatusRequest>(body).map(|r| h.push_evse_status(&r)))
}),
)
.route(
Operation::PullEvseData.path_template(),
post(
|State(h): State<MockHubject>,
Query(query): Query<PageQuery>,
Json(body): Json<serde_json::Value>| async move {
match decode::<PullEvseDataRequest>(body) {
Err(refusal) => json(&refusal),
Ok(request) => json(&h.pull_evse_data(&request, query)),
}
},
),
)
.route(
Operation::PullEvseStatus.path_template(),
post(|State(h): State<MockHubject>, Json(body): Json<serde_json::Value>| async move {
if let Ok(request) = serde_json::from_value::<PullEvseStatusByIdRequest>(body.clone()) {
return json(&h.pull_evse_status_by_id(&request));
}
match decode::<PullEvseStatusRequest>(body) {
Err(refusal) => json(&refusal),
Ok(request) => json(&h.pull_evse_status(&request)),
}
}),
)
.route(
Operation::AuthorizeStart.path_template(),
post(|State(h): State<MockHubject>, Json(body): Json<serde_json::Value>| async move {
match decode::<AuthorizeStartRequest>(body) {
Err(refusal) => json(&refusal),
Ok(request) => json(&h.authorize_start(&request)),
}
}),
)
.route(
Operation::AuthorizeStop.path_template(),
post(|State(h): State<MockHubject>, Json(body): Json<serde_json::Value>| async move {
match decode::<AuthorizeStopRequest>(body) {
Err(refusal) => json(&refusal),
Ok(request) => json(&h.authorize_stop(&request)),
}
}),
)
.route(
Operation::ChargeDetailRecord.path_template(),
post(|State(h): State<MockHubject>, Json(body): Json<serde_json::Value>| async move {
acknowledge(decode::<ChargeDetailRecord>(body).map(|cdr| h.submit_cdr(&cdr)))
}),
)
.route(
Operation::ChargingNotifications.path_template(),
post(|State(h): State<MockHubject>, Json(body): Json<serde_json::Value>| async move {
acknowledge(decode::<ChargingNotification>(body).map(|n| h.notify(&n)))
}),
)
.with_state(hubject);
axum::Router::new().nest("/api/oicp", paths)
}
fn decode<T: serde::de::DeserializeOwned>(body: serde_json::Value) -> Result<T, Acknowledgement> {
serde_path_to_error::deserialize(body)
.map_err(|e| Acknowledgement::failure_with(Code::DataError, format!("{} at {}", e.inner(), e.path())))
}
fn acknowledge(outcome: Result<Result<Acknowledgement, Acknowledgement>, Acknowledgement>) -> Response {
match outcome {
Err(refusal) => (axum::http::StatusCode::BAD_REQUEST, Json(refusal)).into_response(),
Ok(Err(refusal)) => json(&refusal),
Ok(Ok(ack)) => json(&ack),
}
}
fn json<T: serde::Serialize>(value: &T) -> Response {
(axum::http::StatusCode::OK, Json(value)).into_response()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::testkit::{MockEmp, samples};
async fn started() -> MockHubjectServer {
let mut hubject = MockHubject::new();
hubject.register_emp(MockEmp::permissive("DE-DCB".parse().unwrap()));
hubject.push_evse_data(&samples::evse_data_record("DE*ABC*E1").into()).unwrap();
MockHubjectServer::start(hubject).await.expect("the mock binds an ephemeral port")
}
#[tokio::test]
async fn the_base_url_is_the_one_the_endpoint_table_expects() {
let server = started().await;
assert!(server.base_url().ends_with("/api/oicp"));
let url = Operation::PullEvseData
.url(server.base_url(), &crate::transport::PathId::Provider("DE-DCB".parse().unwrap()))
.unwrap();
assert!(url.contains("/api/oicp/evsepull/v23/providers/DE-DCB/data-records"));
server.stop().await;
}
#[tokio::test]
async fn the_broker_behind_the_socket_is_the_one_that_was_given() {
let server = started().await;
assert_eq!(server.hubject().evse_count(), 1);
server.stop().await;
}
}