Merge branch 'main' into add-helm

Author: dan-fernandes

Cargo.toml

@@ -14,3 +14,6 @@ async-graphql-axum = "7.0.17"
 url = "2.5.7"
 config = "0.15.16"
 clap = { version = "4.5.48", features = ["derive"] }
+
+[dev-dependencies]
+httpmock = "0.8.2"

src/clients.rs

@@ -1,51 +1,60 @@
 use std::fmt;
 
-use crate::model::metadata::Metadata;
+use reqwest::Url;
+use serde::de::DeserializeOwned;
 
-#[cfg(test)]
-pub(crate) mod mock_tiled_client;
-pub(crate) mod tiled_client;
+use crate::model::metadata::Metadata;
 
 pub trait Client {
     fn metadata(&self) -> impl Future<Output = Result<Metadata, ClientError>> + Send;
 }
 
 pub type ClientResult<T> = Result<T, ClientError>;
 
+pub struct TiledClient {
+    pub address: Url,
+}
+
+impl TiledClient {
+    async fn request<T: DeserializeOwned>(&self, endpoint: &str) -> ClientResult<T> {
+        println!("Requesting data from tiled");
+        let url = self.address.join(endpoint)?;
+        let response = reqwest::get(url).await?.error_for_status()?;
+        let body = response.text().await?;
+        serde_json::from_str(&body).map_err(|e| ClientError::InvalidResponse(e, body))
+    }
+}
+impl Client for TiledClient {
+    async fn metadata(&self) -> ClientResult<Metadata> {
+        self.request::<Metadata>("/api/v1/").await
+    }
+}
+
 #[derive(Debug)]
 pub enum ClientError {
-    Parse(url::ParseError),
-    Reqwest(reqwest::Error),
-    Serde(serde_json::Error),
-    Io(std::io::Error),
+    InvalidPath(url::ParseError),
+    ServerError(reqwest::Error),
+    InvalidResponse(serde_json::Error, String),
 }
 impl From<url::ParseError> for ClientError {
     fn from(err: url::ParseError) -> ClientError {
-        ClientError::Parse(err)
+        ClientError::InvalidPath(err)
     }
 }
 impl From<reqwest::Error> for ClientError {
     fn from(err: reqwest::Error) -> ClientError {
-        ClientError::Reqwest(err)
-    }
-}
-impl From<serde_json::Error> for ClientError {
-    fn from(err: serde_json::Error) -> ClientError {
-        ClientError::Serde(err)
-    }
-}
-impl From<std::io::Error> for ClientError {
-    fn from(err: std::io::Error) -> ClientError {
-        ClientError::Io(err)
+        ClientError::ServerError(err)
     }
 }
+
 impl std::fmt::Display for ClientError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            ClientError::Parse(ref err) => write!(f, "Parse error: {}", err),
-            ClientError::Reqwest(ref err) => write!(f, "Request error: {}", err),
-            ClientError::Serde(ref err) => write!(f, "Serde error: {}", err),
-            ClientError::Io(ref err) => write!(f, "IO Error: {}", err),
+        match self {
+            ClientError::InvalidPath(err) => write!(f, "Invalid URL path: {}", err),
+            ClientError::ServerError(err) => write!(f, "Tiled server error: {}", err),
+            ClientError::InvalidResponse(err, actual) => {
+                write!(f, "Invalid response: {err}, response: {actual}")
+            }
         }
     }
 }

src/clients/mock_tiled_client.rs

@@ -1 +1,21 @@
-pub mod graphql;
+use async_graphql::http::GraphiQLSource;
+use async_graphql::*;
+use async_graphql_axum::{GraphQLRequest, GraphQLResponse};
+use axum::Extension;
+use axum::response::{Html, IntoResponse};
+
+use crate::clients::Client;
+use crate::model::TiledQuery;
+
+pub async fn graphql_handler<T: Client + Send + Sync + 'static>(
+    schema: Extension<Schema<TiledQuery, EmptyMutation, EmptySubscription>>,
+    req: GraphQLRequest,
+) -> GraphQLResponse {
+    let query = req.into_inner().query;
+
+    schema.execute(query).await.into()
+}
+
+pub async fn graphiql_handler() -> impl IntoResponse {
+    Html(GraphiQLSource::build().endpoint("/graphql").finish())
+}

src/clients/tiled_client.rs

@@ -12,9 +12,9 @@ mod model;
 
 use cli::{Cli, Commands};
 
-use crate::clients::tiled_client::TiledClient;
+use crate::clients::TiledClient;
 use crate::config::GlazedConfig;
-use crate::handlers::graphql::{graphiql_handler, graphql_handler};
+use crate::handlers::{graphiql_handler, graphql_handler};
 use crate::model::TiledQuery;
 
 #[tokio::main]

src/handlers.rs

@@ -2,13 +2,131 @@ pub(crate) mod metadata;
 
 use async_graphql::Object;
 
-use crate::clients::{Client, ClientError};
+use crate::clients::{Client, ClientError, TiledClient};
 
-pub(crate) struct TiledQuery<T>(pub T);
+pub(crate) struct TiledQuery(pub TiledClient);
 
 #[Object]
-impl<T: Client + Send + Sync + 'static> TiledQuery<T> {
+impl TiledQuery {
     async fn metadata(&self) -> async_graphql::Result<metadata::Metadata, ClientError> {
         self.0.metadata().await
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use async_graphql::{EmptyMutation, EmptySubscription, Schema, Value};
+    use httpmock::MockServer;
+    use url::Url;
+
+    use crate::TiledQuery;
+    use crate::clients::TiledClient;
+
+    #[tokio::test]
+    async fn test_api_version_query() {
+        let mock_server = MockServer::start();
+        let mock = mock_server
+            .mock_async(|when, then| {
+                when.method("GET").path("/api/v1/");
+                then.status(200)
+                    .body_from_file("resources/tiled_metadata.json");
+            })
+            .await;
+
+        let schema = Schema::build(
+            TiledQuery(TiledClient {
+                address: Url::parse(&mock_server.base_url()).unwrap(),
+            }),
+            EmptyMutation,
+            EmptySubscription,
+        )
+        .finish();
+
+        let response = schema.execute("{metadata { apiVersion } }").await;
+
+        assert_eq!(response.data.to_string(), "{metadata: {apiVersion: 0}}");
+        assert_eq!(response.errors, &[]);
+        mock.assert();
+    }
+
+    #[tokio::test]
+    async fn test_server_unavailable() {
+        let schema = Schema::build(
+            TiledQuery(TiledClient {
+                address: Url::parse("http://tiled.example.com").unwrap(),
+            }),
+            EmptyMutation,
+            EmptySubscription,
+        )
+        .finish();
+
+        let response = schema.execute("{metadata { apiVersion } }").await;
+        assert_eq!(response.data, Value::Null);
+        assert_eq!(
+            response.errors[0].message,
+            "Tiled server error: error sending request for url (http://tiled.example.com/api/v1/)"
+        );
+        assert_eq!(response.errors.len(), 1);
+    }
+
+    #[tokio::test]
+    async fn test_internal_tiled_error() {
+        let mock_server = MockServer::start();
+        let mock = mock_server
+            .mock_async(|when, then| {
+                when.method("GET").path("/api/v1/");
+                then.status(503);
+            })
+            .await;
+
+        let schema = Schema::build(
+            TiledQuery(TiledClient {
+                address: Url::parse(&mock_server.base_url()).unwrap(),
+            }),
+            EmptyMutation,
+            EmptySubscription,
+        )
+        .finish();
+
+        let response = schema.execute("{metadata { apiVersion } }").await;
+        let actual = &response.errors[0].message;
+        let expected =
+            "Tiled server error: HTTP status server error (503 Service Unavailable) for url";
+        assert_eq!(response.data, Value::Null);
+        assert!(
+            actual.starts_with(expected),
+            "Unexpected error: {actual} \nExpected: {expected} [...]"
+        );
+        assert_eq!(response.errors.len(), 1);
+        mock.assert();
+    }
+
+    #[tokio::test]
+    async fn test_invalid_server_response() {
+        let mock_server = MockServer::start();
+        let mock = mock_server
+            .mock_async(|when, then| {
+                when.method("GET").path("/api/v1/");
+                then.status(200).body("{}");
+            })
+            .await;
+
+        let schema = Schema::build(
+            TiledQuery(TiledClient {
+                address: Url::parse(&mock_server.base_url()).unwrap(),
+            }),
+            EmptyMutation,
+            EmptySubscription,
+        )
+        .finish();
+
+        let response = schema.execute("{metadata { apiVersion } }").await;
+        assert_eq!(response.data, Value::Null);
+        assert_eq!(response.errors.len(), 1);
+        assert_eq!(
+            response.errors[0].message,
+            "Invalid response: missing field `api_version` at line 1 column 2, response: {}"
+        );
+        mock.assert();
+    }
+}