Add API modules with the code to implement currency endpoints

Author: davidsteiner

src/api.rs

@@ -0,0 +1,82 @@
+mod endpoints;
+mod payload;
+
+use poem::{Endpoint, EndpointExt, Route};
+use poem_openapi::OpenApiService;
+
+use crate::api::endpoints::CurrencyApi;
+use crate::repository::SharedRepository;
+
+pub fn build_app(repository: SharedRepository) -> anyhow::Result<impl Endpoint> {
+    let api_service =
+        OpenApiService::new(CurrencyApi, "Currencies", "1.0").server("http://localhost:3000/api");
+    let ui = api_service.swagger_ui();
+    let app = Route::new()
+        .nest("/api", api_service)
+        .nest("/", ui)
+        .data(repository);
+
+    Ok(app)
+}
+
+#[cfg(test)]
+mod tests {
+    use poem::http::StatusCode;
+    use poem::test::TestClient;
+    use poem::Endpoint;
+    use std::sync::Arc;
+
+    use crate::build_app;
+    use crate::repository::{Currency, InMemoryRepository};
+
+    fn setup_client() -> TestClient<impl Endpoint> {
+        let repository = Arc::new(InMemoryRepository::default());
+        let app = build_app(repository).expect("app to be created successfully");
+        TestClient::new(app)
+    }
+
+    #[tokio::test]
+    async fn test_get_currency() {
+        let client = setup_client();
+        let ccy = Currency {
+            code: "GBP".to_string(),
+            name: "British Pound".to_string(),
+            symbol: "£".to_string(),
+        };
+        let response = client.post("/api/currencies").body_json(&ccy).send().await;
+        response.assert_status_is_ok();
+
+        let response = client.get("/api/currencies/gbp").send().await;
+        response.assert_status_is_ok();
+        response.assert_json(ccy).await;
+    }
+
+    #[tokio::test]
+    async fn test_get_non_existent() {
+        let client = setup_client();
+        let response = client.get("/api/currencies/eur").send().await;
+        response.assert_status(StatusCode::NOT_FOUND);
+    }
+
+    #[tokio::test]
+    async fn test_create_then_delete() {
+        let client = setup_client();
+        let ccy = Currency {
+            code: "GBP".to_string(),
+            name: "British Pound".to_string(),
+            symbol: "£".to_string(),
+        };
+        let response = client.post("/api/currencies").body_json(&ccy).send().await;
+        response.assert_status_is_ok();
+
+        let response = client.delete("/api/currencies/gbp").send().await;
+        response.assert_status_is_ok();
+    }
+
+    #[tokio::test]
+    async fn test_delete_non_existent() {
+        let client = setup_client();
+        let response = client.delete("/api/currencies/eur").send().await;
+        response.assert_status(StatusCode::NOT_FOUND);
+    }
+}

src/api/endpoints.rs

@@ -0,0 +1,49 @@
+use poem::web::Data;
+use poem_openapi::param::Path;
+use poem_openapi::payload::Json;
+use poem_openapi::OpenApi;
+use tracing::info;
+
+use crate::api::payload::{Currency, Response};
+use crate::repository;
+
+pub struct CurrencyApi;
+
+#[OpenApi]
+impl CurrencyApi {
+    #[oai(path = "/currencies", method = "post")]
+    async fn create(
+        &self,
+        Data(repository): Data<&repository::SharedRepository>,
+        Json(payload): Json<Currency>,
+    ) -> Response {
+        info!(code = payload.code, "creating currency");
+
+        let currency = repository::Currency {
+            code: payload.code,
+            name: payload.name,
+            symbol: payload.symbol,
+        };
+        repository.add_currency(currency).await.into()
+    }
+
+    #[oai(path = "/currencies/:code", method = "get")]
+    async fn get(
+        &self,
+        Data(repository): Data<&repository::SharedRepository>,
+        Path(code): Path<String>,
+    ) -> Response {
+        info!(code, "getting currency");
+        repository.get_currency(&code).await.into()
+    }
+
+    #[oai(path = "/currencies/:code", method = "delete")]
+    async fn delete(
+        &self,
+        Data(repository): Data<&repository::SharedRepository>,
+        Path(code): Path<String>,
+    ) -> Response {
+        info!(code, "deleting currency");
+        repository.delete_currency(&code).await.into()
+    }
+}

src/api/payload.rs

@@ -0,0 +1,51 @@
+use poem_openapi::payload::{Json, PlainText};
+use poem_openapi::{ApiResponse, Object};
+
+use crate::error::{Error, Result};
+
+#[derive(Object)]
+pub struct Currency {
+    pub code: String,
+    pub name: String,
+    pub symbol: String,
+}
+
+impl From<crate::repository::Currency> for Currency {
+    fn from(currency: crate::repository::Currency) -> Self {
+        Self {
+            code: currency.code,
+            name: currency.name,
+            symbol: currency.symbol,
+        }
+    }
+}
+
+#[derive(ApiResponse)]
+pub(crate) enum Response {
+    #[oai(status = 200)]
+    Currency(Json<Currency>),
+
+    #[oai(status = 404)]
+    NotFound(PlainText<String>),
+
+    #[oai(status = 500)]
+    InternalServerError(PlainText<String>),
+}
+
+impl From<Result<crate::repository::Currency>> for Response {
+    fn from(result: Result<crate::repository::Currency>) -> Self {
+        match result {
+            Ok(currency) => Response::Currency(Json(currency.into())),
+            Err(err) => match err {
+                Error::NotFound(code) => {
+                    let msg = format!("{code} is not found");
+                    Response::NotFound(PlainText(msg))
+                }
+                Error::Other => {
+                    let msg = "internal server error".to_string();
+                    Response::InternalServerError(PlainText(msg))
+                }
+            },
+        }
+    }
+}

src/error.rs

@@ -8,4 +8,4 @@ pub enum Error {
     Other,
 }
 
-pub type Result<T> = std::result::Result<T, Error>;
+pub type Result<T> = std::result::Result<T, Error>;

src/lib.rs

@@ -1,3 +1,4 @@
+pub mod api;
 pub mod repository;
 
-mod error;
+mod error;

src/repository.rs

@@ -2,4 +2,4 @@ mod base;
 mod memory;
 
 pub use base::{Currency, Repository, SharedRepository};
-pub use memory::InMemoryRepository;
+pub use memory::InMemoryRepository;

src/repository/base.rs

@@ -15,4 +15,4 @@ pub trait Repository: Sync + Send + 'static {
     async fn add_currency(&self, currency: Currency) -> crate::error::Result<Currency>;
     async fn get_currency(&self, code: &str) -> crate::error::Result<Currency>;
     async fn delete_currency(&self, code: &str) -> crate::error::Result<Currency>;
-}
+}

src/repository/memory.rs

@@ -39,4 +39,4 @@ impl Repository for InMemoryRepository {
             .remove(&code.to_lowercase())
             .ok_or(Error::NotFound(code.to_string()))
     }
-}
+}