Update client tests to verify request properties for each call in addition to the response

Author: cameronfyfe

Cargo.toml

@@ -7,6 +7,8 @@ edition = "2018"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+form_urlencoded = "1"
+http = "0.2"
 serde = { version = "1", features = ["derive"] } 
 serde_json = "1"
 tokio = { version = "1", features = ["full"] }

tests/client_tests.rs

@@ -6,80 +6,180 @@ macro_rules! b {
 
 mod mock {
     use serde_json::json;
+    use std::borrow::Cow;
 
     fn client<'a>() -> podcast_api::Client<'a> {
         podcast_api::Client::new(None)
     }
 
     #[test]
     fn search() {
-        let response = b!(client().search(&json!({
-            "q": "dummy",
-            "sort_by_date": 1
-        })))
-        .unwrap();
-        assert!(response.is_object());
-        assert!(response["results"].as_array().unwrap().len() > 0);
+        b!(async {
+            let response = client()
+                .search(&json!({
+                        "q": "dummy",
+                        "sort_by_date": 1
+                }))
+                .await
+                .unwrap();
+            // Request
+            assert_eq!(response.request.method(), http::Method::GET);
+            assert_eq!(response.request.url().path(), "/api/v2/search");
+            let mut p = response.request.url().query_pairs();
+            assert_eq!(p.count(), 2);
+            assert_eq!(p.next(), Some((Cow::Borrowed("q"), Cow::Borrowed("dummy"))));
+            assert_eq!(
+                p.next(),
+                Some((Cow::Borrowed("sort_by_date"), Cow::Borrowed("1")))
+            );
+            // Response
+            let body = response.json().await.unwrap();
+            assert!(body.is_object());
+            assert!(body["results"].as_array().unwrap().len() > 0);
+        });
     }
 
     #[test]
     fn typeahead() {
-        let response = b!(client().typeahead(&json!({
-            "q": "dummy",
-            "show_podcasts": 1
-        })))
-        .unwrap();
-        assert!(response.is_object());
-        assert!(response["terms"].as_array().unwrap().len() > 0);
+        b!(async {
+            let response = client()
+                .typeahead(&json!({
+                    "q": "dummy",
+                    "show_podcasts": 1
+                }))
+                .await
+                .unwrap();
+            // Request
+            assert_eq!(response.request.method(), http::Method::GET);
+            assert_eq!(response.request.url().path(), "/api/v2/typeahead");
+            let mut p = response.request.url().query_pairs();
+            assert_eq!(p.count(), 2);
+            assert_eq!(p.next(), Some((Cow::Borrowed("q"), Cow::Borrowed("dummy"))));
+            assert_eq!(
+                p.next(),
+                Some((Cow::Borrowed("show_podcasts"), Cow::Borrowed("1")))
+            );
+            // Response
+            let body = response.json().await.unwrap();
+            assert!(body.is_object());
+            assert!(body["terms"].as_array().unwrap().len() > 0);
+        });
     }
 
     #[test]
     fn fetch_best_podcasts() {
-        let response = b!(client().fetch_best_podcasts(&json!({
-            "genre_id": 23,
-        })))
-        .unwrap();
-        assert!(response.is_object());
-        assert!(response["total"].as_i64().unwrap() > 0);
+        b!(async {
+            let response = client()
+                .fetch_best_podcasts(&json!({
+                    "genre_id": 23
+                }))
+                .await
+                .unwrap();
+            // Request
+            assert_eq!(response.request.method(), http::Method::GET);
+            assert_eq!(response.request.url().path(), "/api/v2/best_podcasts");
+            let mut p = response.request.url().query_pairs();
+            assert_eq!(p.count(), 1);
+            assert_eq!(
+                p.next(),
+                Some((Cow::Borrowed("genre_id"), Cow::Borrowed("23")))
+            );
+            // Response
+            let body = response.json().await.unwrap();
+            assert!(body.is_object());
+            assert!(body["total"].as_i64().unwrap() > 0);
+        });
     }
 
     #[test]
     fn fetch_podcast_by_id() {
-        let response = b!(client().fetch_podcast_by_id("dummy_id", &json!({}))).unwrap();
-        assert!(response.is_object());
-        assert!(response["episodes"].as_array().unwrap().len() > 0);
+        b!(async {
+            let response = client()
+                .fetch_podcast_by_id("dummy_id", &json!({}))
+                .await
+                .unwrap();
+            // Request
+            assert_eq!(response.request.method(), http::Method::GET);
+            assert_eq!(response.request.url().path(), "/api/v2/podcasts/dummy_id");
+            let p = response.request.url().query_pairs();
+            assert_eq!(p.count(), 0);
+            // Response
+            let body = response.json().await.unwrap();
+            assert!(body.is_object());
+            assert!(body["episodes"].as_array().unwrap().len() > 0);
+        });
     }
 
     #[test]
     fn batch_fetch_podcasts() {
-        let response = b!(client().batch_fetch_podcasts(&json!({
-            "ids": "996,777,888,1000"
-        })))
-        .unwrap();
-        assert!(response.is_object());
-        assert!(response["podcasts"].as_array().unwrap().len() > 0);
+        b!(async {
+            let response = client()
+                .batch_fetch_podcasts(&json!({
+                    "ids": "996,777,888,1000"
+                }))
+                .await
+                .unwrap();
+            // Request
+            assert_eq!(response.request.method(), http::Method::POST);
+            assert_eq!(response.request.url().path(), "/api/v2/podcasts");
+            let mut p = form_urlencoded::parse(response.request.body().unwrap().as_bytes().unwrap());
+            assert_eq!(p.count(), 1);
+            assert_eq!(
+                p.next(),
+                Some((Cow::Borrowed("ids"), Cow::Borrowed("996,777,888,1000")))
+            );
+            // Response
+            let body = response.json().await.unwrap();
+            assert!(body.is_object());
+            assert!(body["podcasts"].as_array().unwrap().len() > 0);
+        });
     }
 
     #[test]
     fn fetch_episode_by_id() {
-        let response = b!(client().fetch_episode_by_id("dummy_id", &json!({}))).unwrap();
-        assert!(response.is_object());
-        assert!(
-            response["podcast"].as_object().unwrap()["rss"]
-                .as_str()
-                .unwrap()
-                .len()
-                > 0
-        );
+        b!(async {
+            let response = client()
+                .fetch_episode_by_id("dummy_id", &json!({}))
+                .await
+                .unwrap();
+            // Request
+            assert_eq!(response.request.method(), http::Method::GET);
+            assert_eq!(response.request.url().path(), "/api/v2/episodes/dummy_id");
+            let p = response.request.url().query_pairs();
+            assert_eq!(p.count(), 0);
+            // Response
+            let body = response.json().await.unwrap();
+            assert!(body.is_object());
+            assert!(body["podcast"].as_object().unwrap()["rss"]
+            .as_str()
+            .unwrap()
+            .len()
+            > 0);
+        });
     }
 
     #[test]
     fn batch_fetch_episodes() {
-        let response = b!(client().batch_fetch_episodes(&json!({
-            "ids": "996,777,888,1000"
-        })))
-        .unwrap();
-        assert!(response.is_object());
-        assert!(response["episodes"].as_array().unwrap().len() > 0);
+        b!(async {
+            let response = client()
+                .batch_fetch_episodes(&json!({
+                    "ids": "996,777,888,1000"
+                }))
+                .await
+                .unwrap();
+            // Request
+            assert_eq!(response.request.method(), http::Method::POST);
+            assert_eq!(response.request.url().path(), "/api/v2/episodes");
+            let mut p = form_urlencoded::parse(response.request.body().unwrap().as_bytes().unwrap());
+            assert_eq!(p.count(), 1);
+            assert_eq!(
+                p.next(),
+                Some((Cow::Borrowed("ids"), Cow::Borrowed("996,777,888,1000")))
+            );
+            // Response
+            let body = response.json().await.unwrap();
+            assert!(body.is_object());
+            assert!(body["episodes"].as_array().unwrap().len() > 0);
+        });
     }
 }