Test network errors

Author: tomhoule

graphql_client_web/Cargo.toml

@@ -15,6 +15,7 @@ log = "0.4.5"
 serde_json = "1.0.32"
 wasm-bindgen = "0.2.25"
 wasm-bindgen-futures = "0.3.2"
+js-sys = "0.3.5"
 
 [dependencies.web-sys]
 version = "0.3.2"

graphql_client_web/src/lib.rs

@@ -8,16 +8,17 @@
 
 #[macro_use]
 pub extern crate graphql_client;
+extern crate js_sys;
 #[macro_use]
 extern crate wasm_bindgen;
 
-pub use graphql_client::GraphQLQuery;
 use failure::*;
 use futures::{Future, IntoFuture};
+pub use graphql_client::GraphQLQuery;
 use log::*;
 use std::collections::HashMap;
-use wasm_bindgen_futures::JsFuture;
 use wasm_bindgen::{JsCast, JsValue};
+use wasm_bindgen_futures::JsFuture;
 
 /// The main interface to the library.
 ///
@@ -34,15 +35,15 @@ pub struct Client {
 /// All the ways a request can go wrong.
 ///
 /// not exhaustive
-#[derive(Debug, Fail)]
+#[derive(Debug, Fail, PartialEq)]
 #[non_exhaustive]
 pub enum ClientError {
     /// The body couldn't be built
     #[fail(display = "Request body is not a valid string")]
     Body,
     /// An error caused by window.fetch
     #[fail(display = "Network error")]
-    Network,
+    Network(String),
     /// Error in a dynamic JS cast that should have worked
     #[fail(display = "JS casting error")]
     Cast,
@@ -52,13 +53,13 @@ pub enum ClientError {
     )]
     NoWindow,
     /// Response shape does not match the generated code
-    #[fail(display = "Response shape error",)]
+    #[fail(display = "Response shape error")]
     ResponseShape,
     /// Response could not be converted to text
     #[fail(display = "Response conversion to text failed (Response.text threw)")]
     ResponseText,
     /// Exception thrown when building the request
-    #[fail(display = "Error building the request",)]
+    #[fail(display = "Error building the request")]
     RequestError,
     /// Other JS exception
     #[fail(display = "Unexpected JS exception")]
@@ -73,9 +74,15 @@ impl Client {
     {
         Client {
             endpoint: endpoint.into(),
+            headers: HashMap::new(),
         }
     }
 
+    /// Add a header to those sent with the requests. Can be used for things like authorization.
+    pub fn add_header(&mut self, name: &str, value: &str) {
+        self.headers.insert(name.into(), value.into());
+    }
+
     /// Perform a query.
     pub fn call<Q: GraphQLQuery + 'static>(
         &self,
@@ -93,7 +100,8 @@ impl Client {
                 serde_json::to_string(&Q::build_query(variables))
                     .map_err(|_| ClientError::Body)
                     .map(move |body| (window, body))
-            }).and_then(move |(window, body)| {
+            })
+            .and_then(move |(window, body)| {
                 let mut request_init = web_sys::RequestInit::new();
                 request_init
                     .method("POST")
@@ -103,7 +111,8 @@ impl Client {
                     .map_err(|_| ClientError::JsException)
                     .map(|request| (window, request))
                 // "Request constructor threw");
-            }).and_then(move |(window, request)| {
+            })
+            .and_then(move |(window, request)| {
                 let request: Result<web_sys::Request, _> = request
                     .headers()
                     .set("Content-Type", "application/json")
@@ -118,18 +127,23 @@ impl Client {
                 });
 
                 request.map(move |request| (window, request))
-            }).and_then(move |(window, request)| {
+            })
+            .and_then(move |(window, request)| {
                 JsFuture::from(window.fetch_with_request(&request))
-                    .map_err(|_| ClientError::Network)
-            }).and_then(move |res| {
+                    .map_err(|err| ClientError::Network(js_sys::Error::from(err).message().into()))
+            })
+            .and_then(move |res| {
                 debug!("response: {:?}", res);
                 res.dyn_into::<web_sys::Response>()
                     .map_err(|_| ClientError::Cast)
-            }).and_then(move |cast_response| {
+            })
+            .and_then(move |cast_response| {
                 cast_response.text().map_err(|_| ClientError::ResponseText)
-            }).and_then(move |text_promise| {
+            })
+            .and_then(move |text_promise| {
                 JsFuture::from(text_promise).map_err(|_| ClientError::ResponseText)
-            }).and_then(|text| {
+            })
+            .and_then(|text| {
                 let response_text = text.as_string().unwrap_or_else(|| String::new());
                 debug!("response text as string: {:?}", response_text);
                 serde_json::from_str(&response_text).map_err(|_| ClientError::ResponseShape)

graphql_client_web/tests/web.rs

@@ -42,7 +42,8 @@ fn test_germany() -> impl Future<Item = (), Error = JsValue> {
                 .expect("germany is on a continent");
 
             assert_eq!(continent_name, "Europe");
-        }).map_err(|err| {
+        })
+        .map_err(|err| {
             panic!("{:?}", err);
             JsValue::NULL
         })
@@ -63,7 +64,8 @@ fn test_country() -> impl Future<Item = (), Error = JsValue> {
             country::Variables {
                 country_code: "CN".to_owned(),
             },
-        ).map(|response| {
+        )
+        .map(|response| {
             let continent_name = response
                 .data
                 .expect("response data is not null")
@@ -75,8 +77,36 @@ fn test_country() -> impl Future<Item = (), Error = JsValue> {
                 .expect("country is on a continent");
 
             assert_eq!(continent_name, "Asia");
-        }).map_err(|err| {
+        })
+        .map_err(|err| {
             panic!("{:?}", err);
             JsValue::NULL
         })
 }
+
+#[wasm_bindgen_test(async)]
+fn test_bad_url() -> impl Future<Item = (), Error = JsValue> {
+    Client::new("https://example.com/non-existent/graphql/endpoint")
+        .call(
+            Country,
+            country::Variables {
+                country_code: "CN".to_owned(),
+            },
+        )
+        .map(|_response| panic!("The API endpoint does not exist, this should not be called."))
+        .map_err(|err| {
+            assert_eq!(
+                err,
+                graphql_client_web::ClientError::Network(
+                    "NetworkError when attempting to fetch resource.".into()
+                )
+            );
+            JsValue::NULL
+        })
+        .then(|_| Ok(()))
+}
+
+#[wasm_bindgen_test]
+fn test_404() {
+    unimplemented!()
+}