mithril_aggregator/http_server/routes/artifact_routes/
cardano_transaction.rsuse crate::http_server::routes::middlewares;
use crate::http_server::routes::router::RouterState;
use warp::Filter;
pub fn routes(
router_state: &RouterState,
) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
artifact_cardano_transactions(router_state).or(artifact_cardano_transaction_by_id(router_state))
}
fn artifact_cardano_transactions(
router_state: &RouterState,
) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
warp::path!("artifact" / "cardano-transactions")
.and(warp::get())
.and(middlewares::with_logger(router_state))
.and(middlewares::with_http_message_service(router_state))
.and_then(handlers::list_artifacts)
}
fn artifact_cardano_transaction_by_id(
router_state: &RouterState,
) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
warp::path!("artifact" / "cardano-transaction" / String)
.and(warp::get())
.and(middlewares::with_logger(router_state))
.and(middlewares::with_http_message_service(router_state))
.and(middlewares::with_metrics_service(router_state))
.and_then(handlers::get_artifact_by_signed_entity_id)
}
pub mod handlers {
use crate::http_server::routes::reply;
use crate::services::MessageService;
use crate::MetricsService;
use slog::{warn, Logger};
use std::convert::Infallible;
use std::sync::Arc;
use warp::http::StatusCode;
pub const LIST_MAX_ITEMS: usize = 20;
pub async fn list_artifacts(
logger: Logger,
http_message_service: Arc<dyn MessageService>,
) -> Result<impl warp::Reply, Infallible> {
match http_message_service
.get_cardano_transaction_list_message(LIST_MAX_ITEMS)
.await
{
Ok(message) => Ok(reply::json(&message, StatusCode::OK)),
Err(err) => {
warn!(logger, "list_artifacts_cardano_transactions"; "error" => ?err);
Ok(reply::server_error(err))
}
}
}
pub async fn get_artifact_by_signed_entity_id(
signed_entity_id: String,
logger: Logger,
http_message_service: Arc<dyn MessageService>,
metrics_service: Arc<MetricsService>,
) -> Result<impl warp::Reply, Infallible> {
metrics_service
.get_artifact_detail_cardano_transaction_total_served_since_startup()
.increment();
match http_message_service
.get_cardano_transaction_message(&signed_entity_id)
.await
{
Ok(Some(message)) => Ok(reply::json(&message, StatusCode::OK)),
Ok(None) => {
warn!(logger, "get_cardano_transaction_details::not_found");
Ok(reply::empty(StatusCode::NOT_FOUND))
}
Err(err) => {
warn!(logger, "get_cardano_transaction_details::error"; "error" => ?err);
Ok(reply::server_error(err))
}
}
}
}
#[cfg(test)]
pub mod tests {
use serde_json::Value::Null;
use std::sync::Arc;
use warp::{
http::{Method, StatusCode},
test::request,
};
use mithril_common::messages::{
CardanoTransactionSnapshotListItemMessage, CardanoTransactionSnapshotMessage,
};
use mithril_common::test_utils::apispec::APISpec;
use mithril_persistence::sqlite::HydrationError;
use crate::{
http_server::SERVER_BASE_PATH, initialize_dependencies, services::MockMessageService,
};
use super::*;
fn setup_router(
state: RouterState,
) -> impl Filter<Extract = (impl warp::Reply,), Error = warp::Rejection> + Clone {
let cors = warp::cors()
.allow_any_origin()
.allow_headers(vec!["content-type"])
.allow_methods(vec![Method::GET, Method::POST, Method::OPTIONS]);
warp::any()
.and(warp::path(SERVER_BASE_PATH))
.and(routes(&state).with(cors))
}
#[tokio::test]
async fn test_cardano_transactions_get_ok() {
let mut mock_http_message_service = MockMessageService::new();
mock_http_message_service
.expect_get_cardano_transaction_list_message()
.return_once(|_| Ok(vec![CardanoTransactionSnapshotListItemMessage::dummy()]))
.once();
let mut dependency_manager = initialize_dependencies().await;
dependency_manager.message_service = Arc::new(mock_http_message_service);
let method = Method::GET.as_str();
let path = "/artifact/cardano-transactions";
let response = request()
.method(method)
.path(&format!("/{SERVER_BASE_PATH}{path}"))
.reply(&setup_router(RouterState::new_with_dummy_config(Arc::new(
dependency_manager,
))))
.await;
APISpec::verify_conformity(
APISpec::get_all_spec_files(),
method,
path,
"application/json",
&Null,
&response,
&StatusCode::OK,
)
.unwrap();
}
#[tokio::test]
async fn test_cardano_transactions_get_ko() {
let mut mock_http_message_service = MockMessageService::new();
mock_http_message_service
.expect_get_cardano_transaction_list_message()
.return_once(|_| Err(HydrationError::InvalidData("invalid data".to_string()).into()))
.once();
let mut dependency_manager = initialize_dependencies().await;
dependency_manager.message_service = Arc::new(mock_http_message_service);
let method = Method::GET.as_str();
let path = "/artifact/cardano-transactions";
let response = request()
.method(method)
.path(&format!("/{SERVER_BASE_PATH}{path}"))
.reply(&setup_router(RouterState::new_with_dummy_config(Arc::new(
dependency_manager,
))))
.await;
APISpec::verify_conformity(
APISpec::get_all_spec_files(),
method,
path,
"application/json",
&Null,
&response,
&StatusCode::INTERNAL_SERVER_ERROR,
)
.unwrap();
}
#[tokio::test]
async fn test_cardano_transaction_increments_artifact_detail_total_served_since_startup_metric()
{
let method = Method::GET.as_str();
let path = "/artifact/cardano-transaction/{hash}";
let dependency_manager = Arc::new(initialize_dependencies().await);
let initial_counter_value = dependency_manager
.metrics_service
.get_artifact_detail_cardano_transaction_total_served_since_startup()
.get();
request()
.method(method)
.path(&format!("/{SERVER_BASE_PATH}{path}"))
.reply(&setup_router(RouterState::new_with_dummy_config(
dependency_manager.clone(),
)))
.await;
assert_eq!(
initial_counter_value + 1,
dependency_manager
.metrics_service
.get_artifact_detail_cardano_transaction_total_served_since_startup()
.get()
);
}
#[tokio::test]
async fn test_cardano_transaction_get_ok() {
let mut mock_http_message_service = MockMessageService::new();
mock_http_message_service
.expect_get_cardano_transaction_message()
.return_once(|_| Ok(Some(CardanoTransactionSnapshotMessage::dummy())))
.once();
let mut dependency_manager = initialize_dependencies().await;
dependency_manager.message_service = Arc::new(mock_http_message_service);
let method = Method::GET.as_str();
let path = "/artifact/cardano-transaction/{hash}";
let response = request()
.method(method)
.path(&format!("/{SERVER_BASE_PATH}{path}"))
.reply(&setup_router(RouterState::new_with_dummy_config(Arc::new(
dependency_manager,
))))
.await;
APISpec::verify_conformity(
APISpec::get_all_spec_files(),
method,
path,
"application/json",
&Null,
&response,
&StatusCode::OK,
)
.unwrap();
}
#[tokio::test]
async fn test_cardano_transaction_return_404_not_found_when_no_record() {
let mut mock_http_message_service = MockMessageService::new();
mock_http_message_service
.expect_get_cardano_transaction_message()
.return_once(|_| Ok(None))
.once();
let mut dependency_manager = initialize_dependencies().await;
dependency_manager.message_service = Arc::new(mock_http_message_service);
let method = Method::GET.as_str();
let path = "/artifact/cardano-transaction/{hash}";
let response = request()
.method(method)
.path(&format!("/{SERVER_BASE_PATH}{path}"))
.reply(&setup_router(RouterState::new_with_dummy_config(Arc::new(
dependency_manager,
))))
.await;
APISpec::verify_conformity(
APISpec::get_all_spec_files(),
method,
path,
"application/json",
&Null,
&response,
&StatusCode::NOT_FOUND,
)
.unwrap();
}
#[tokio::test]
async fn test_cardano_transaction_get_ko() {
let mut mock_http_message_service = MockMessageService::new();
mock_http_message_service
.expect_get_cardano_transaction_message()
.return_once(|_| Err(HydrationError::InvalidData("invalid data".to_string()).into()))
.once();
let mut dependency_manager = initialize_dependencies().await;
dependency_manager.message_service = Arc::new(mock_http_message_service);
let method = Method::GET.as_str();
let path = "/artifact/cardano-transaction/{hash}";
let response = request()
.method(method)
.path(&format!("/{SERVER_BASE_PATH}{path}"))
.reply(&setup_router(RouterState::new_with_dummy_config(Arc::new(
dependency_manager,
))))
.await;
APISpec::verify_conformity(
APISpec::get_all_spec_files(),
method,
path,
"application/json",
&Null,
&response,
&StatusCode::INTERNAL_SERVER_ERROR,
)
.unwrap();
}
}