Simplify repo structure (#16)

Author: abbiemery

src/clients.rs

@@ -1,17 +1,65 @@
 use std::fmt;
+#[cfg(test)]
+use std::fs::File;
+#[cfg(test)]
+use std::path::PathBuf;
 
-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?;
+        let json = response.json().await?;
+
+        Ok(serde_json::from_value(json)?)
+    }
+}
+impl Client for TiledClient {
+    async fn metadata(&self) -> ClientResult<Metadata> {
+        self.request::<Metadata>("/api/v1/").await
+    }
+}
+
+#[cfg(test)]
+pub struct MockTiledClient {
+    pub dir_path: PathBuf,
+}
+
+#[cfg(test)]
+impl MockTiledClient {
+    async fn deserialize_from_file<T: DeserializeOwned>(&self, filename: &str) -> ClientResult<T> {
+        println!("Requesting data from mock");
+
+        let path = self.dir_path.join(filename);
+        let file = File::open(&path)?;
+
+        Ok(serde_json::from_reader(file)?)
+    }
+}
+#[cfg(test)]
+impl Client for MockTiledClient {
+    async fn metadata(&self) -> ClientResult<Metadata> {
+        self.deserialize_from_file("tiled_metadata.json").await
+    }
+}
+
 #[derive(Debug)]
 pub enum ClientError {
     Parse(url::ParseError),

src/clients/mock_tiled_client.rs

@@ -1 +1,47 @@
-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<T>, 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())
+}
+
+#[cfg(test)]
+mod tests {
+    use async_graphql::{EmptyMutation, EmptySubscription, Schema};
+
+    use crate::TiledQuery;
+    use crate::clients::MockTiledClient;
+
+    #[tokio::test]
+    async fn test_api_version_query() {
+        let schema = Schema::build(
+            TiledQuery(MockTiledClient {
+                dir_path: "./resources".into(),
+            }),
+            EmptyMutation,
+            EmptySubscription,
+        )
+        .finish();
+
+        let response = schema.execute("{metadata { apiVersion } }").await;
+
+        println!("{:?}", response.data.to_string());
+
+        assert!(response.data.to_string() == "{metadata: {apiVersion: 0}}")
+    }
+}

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]