Merge pull request #123 from icann/andy_dev

Fix #122

Author: anewton1998

icann-rdap-client/src/rdap/qtype.rs

@@ -122,7 +122,7 @@ impl QueryType {
             Self::DomainNsIpSearch(value) => {
                 search_query(&value.to_string(), "domains?nsIp", base_url)
             }
-            Self::NameserverNameSearch(value) => search_query(value, "nameserver?name=", base_url),
+            Self::NameserverNameSearch(value) => search_query(value, "nameservers?name", base_url),
             Self::NameserverIpSearch(value) => {
                 search_query(&value.to_string(), "nameservers?ip", base_url)
             }
@@ -294,7 +294,6 @@ fn is_nameserver(text: &str) -> bool {
 }
 
 #[cfg(test)]
-#[allow(non_snake_case)]
 mod tests {
     use std::str::FromStr;
 
@@ -303,7 +302,7 @@ mod tests {
     use super::*;
 
     #[test]
-    fn GIVEN_ipv4_WHEN_query_type_from_str_THEN_query_is_ipv4() {
+    fn test_ipv4_query_type_from_str() {
         // GIVEN
         let s = "129.129.1.1";
 
@@ -315,7 +314,7 @@ mod tests {
     }
 
     #[test]
-    fn GIVEN_ipv6_WHEN_query_type_from_str_THEN_query_is_ipv6() {
+    fn test_ipv6_query_type_from_str() {
         // GIVEN
         let s = "2001::1";
 
@@ -327,7 +326,7 @@ mod tests {
     }
 
     #[test]
-    fn GIVEN_ipv4_cidr_WHEN_query_type_from_str_THEN_query_is_ipv4_cidr() {
+    fn test_ipv4_cidr_query_type_from_str() {
         // GIVEN
         let s = "129.129.1.1/8";
 
@@ -339,7 +338,7 @@ mod tests {
     }
 
     #[test]
-    fn GIVEN_ipv6_cidr_WHEN_query_type_from_str_THEN_query_is_ipv6_cidr() {
+    fn test_ipv6_cidr_query_type_from_str() {
         // GIVEN
         let s = "2001::1/20";
 
@@ -351,7 +350,7 @@ mod tests {
     }
 
     #[test]
-    fn GIVEN_number_WHEN_query_type_from_str_THEN_query_is_autnum() {
+    fn test_number_query_type_from_str() {
         // GIVEN
         let s = "16509";
 
@@ -363,7 +362,7 @@ mod tests {
     }
 
     #[test]
-    fn GIVEN_as_followed_by_number_WHEN_query_type_from_str_THEN_query_is_autnum() {
+    fn test_as_followed_by_number_query_type_from_str() {
         // GIVEN
         let s = "as16509";
 
@@ -380,7 +379,7 @@ mod tests {
     #[case("snark.fail")]
     #[case("ns.fail")]
     #[case(".com")]
-    fn GIVEN_domain_name_WHEN_query_type_from_str_THEN_query_is_domain(#[case] input: &str) {
+    fn test_domain_name_query_type_from_str(#[case] input: &str) {
         // GIVEN case input
 
         // WHEN
@@ -394,7 +393,7 @@ mod tests {
     #[case("ns.example.com")]
     #[case("ns1.example.com")]
     #[case("NS1.example.com")]
-    fn GIVEN_name_server_WHEN_query_type_from_str_THEN_query_is_nameserver(#[case] input: &str) {
+    fn test_name_server_query_type_from_str(#[case] input: &str) {
         // GIVEN case input
 
         // WHEN
@@ -405,7 +404,7 @@ mod tests {
     }
 
     #[test]
-    fn GIVEN_single_word_WHEN_query_type_from_str_THEN_query_is_entity() {
+    fn test_single_word_query_type_from_str() {
         // GIVEN
         let s = "foo";
 
@@ -420,7 +419,7 @@ mod tests {
     #[rstest]
     #[case("https://example.com")]
     #[case("http://foo.example.com")]
-    fn GIVEN_url_WHEN_query_type_from_str_THEN_query_is_url(#[case] input: &str) {
+    fn test_url_query_type_from_str(#[case] input: &str) {
         // GIVEN case input
 
         // WHEN
@@ -433,7 +432,7 @@ mod tests {
     #[rstest]
     #[case("ns.foo_bar.com")]
     #[case("ns.foo bar.com")]
-    fn GIVEN_bad_input_WHEN_query_type_from_str_THEN_error(#[case] input: &str) {
+    fn test_bad_input_query_type_from_str(#[case] input: &str) {
         // GIVEN case input
 
         // WHEN
@@ -454,14 +453,193 @@ mod tests {
     #[case("10/24", "10.0.0.0/24")]
     #[case("129.129.1.1/8", "129.0.0.0/8")]
     #[case("2001::1/32", "2001::/32")]
-    fn GIVEN_cidr_WHEN_parse_cidr_THEN_error(#[case] actual: &str, #[case] expected: &str) {
+    fn test_cidr_parse_cidr(#[case] actual: &str, #[case] expected: &str) {
         // GIVEN case input
 
         // WHEN
-
         let q = parse_cidr(actual);
 
         // THEN
         assert_eq!(q.unwrap().to_string(), expected)
     }
+
+    #[test]
+    fn test_ipv4addr_query_url() {
+        // GIVEN ipv4 addr query
+        let q = QueryType::from_str("199.1.1.1").expect("query type");
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/ip/199.1.1.1")
+    }
+
+    #[test]
+    fn test_ipv6addr_query_url() {
+        // GIVEN
+        let q = QueryType::from_str("2000::1").expect("query type");
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/ip/2000%3A%3A1")
+    }
+
+    #[test]
+    fn test_ipv4cidr_query_url() {
+        // GIVEN
+        let q = QueryType::from_str("199.1.1.1/16").expect("query type");
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/ip/199.1.0.0/16")
+    }
+
+    #[test]
+    fn test_ipv6cidr_query_url() {
+        // GIVEN
+        let q = QueryType::from_str("2000::1/16").expect("query type");
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/ip/2000%3A%3A/16")
+    }
+
+    #[test]
+    fn test_autnum_query_url() {
+        // GIVEN
+        let q = QueryType::from_str("as16509").expect("query type");
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/autnum/16509")
+    }
+
+    #[test]
+    fn test_domain_query_url() {
+        // GIVEN
+        let q = QueryType::from_str("example.com").expect("query type");
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/domain/example.com")
+    }
+
+    #[test]
+    fn test_ns_query_url() {
+        // GIVEN
+        let q = QueryType::from_str("ns.example.com").expect("query type");
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/nameserver/ns.example.com")
+    }
+
+    #[test]
+    fn test_entity_query_url() {
+        // GIVEN
+        let q = QueryType::from_str("foo").expect("query type");
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/entity/foo")
+    }
+
+    #[test]
+    fn test_entity_name_search_query_url() {
+        // GIVEN
+        let q = QueryType::EntityNameSearch("foo".to_string());
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/entities?fn=foo")
+    }
+
+    #[test]
+    fn test_entity_handle_search_query_url() {
+        // GIVEN
+        let q = QueryType::EntityHandleSearch("foo".to_string());
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/entities?handle=foo")
+    }
+
+    #[test]
+    fn test_domain_name_search_query_url() {
+        // GIVEN
+        let q = QueryType::DomainNameSearch("foo".to_string());
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/domains?name=foo")
+    }
+
+    #[test]
+    fn test_domain_ns_name_search_query_url() {
+        // GIVEN
+        let q = QueryType::DomainNsNameSearch("foo".to_string());
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/domains?nsLdhName=foo")
+    }
+
+    #[test]
+    fn test_domain_ns_ip_search_query_url() {
+        // GIVEN
+        let q = QueryType::DomainNsIpSearch(IpAddr::V4(Ipv4Addr::new(1, 1, 1, 1)));
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/domains?nsIp=1.1.1.1")
+    }
+
+    #[test]
+    fn test_ns_name_search_query_url() {
+        // GIVEN
+        let q = QueryType::NameserverNameSearch("foo".to_string());
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/nameservers?name=foo")
+    }
+
+    #[test]
+    fn test_ns_ip_search_query_url() {
+        // GIVEN
+        let q = QueryType::NameserverIpSearch(IpAddr::V4(Ipv4Addr::new(1, 1, 1, 1)));
+
+        // WHEN
+        let actual = q.query_url("https://example.com").expect("query url");
+
+        // THEN
+        assert_eq!(actual, "https://example.com/nameservers?ip=1.1.1.1")
+    }
 }