Merge branch 'develop' of https://github.com/niclabs/dns-rust into de…

…velop

docker-compose.yml

@@ -1,13 +1,7 @@
 version: "4"
 services:
-  resolver:
-    build: .
-    image: dns-rust:latest
-    ports:
-      - "58396:58396"
-    network_mode: "dns"
-  client:
-    container_name: client
+  dns_rust:
+    container_name: dns_rust
     build: .
     image: dns-rust:latest
   test:

src/async_resolver.rs

@@ -524,9 +524,9 @@ mod async_resolver_test {
         }
     }
 
-    /// Test lookup cache
+    /// Test inner lookup cache
     #[tokio::test]
-    async fn lookup_cache() {
+    async fn inner_lookup_cache_available() {
         let mut resolver = AsyncResolver::new(ResolverConfig::default());
         resolver.cache.set_max_size(1);
 
@@ -537,7 +537,40 @@ mod async_resolver_test {
 
         resolver.cache.add(domain_name, resource_record);
 
-        let _response = resolver.lookup("example.com", "UDP", "A","IN").await;
+        let domain_name = DomainName::new_from_string("example.com".to_string());
+        let response = resolver.inner_lookup(domain_name, Qtype::A, Qclass::IN).await;
+
+        if let Ok(msg) = response {
+            assert_eq!(msg.get_header().get_aa(), false);
+        } else {
+            panic!("No response from cache");
+        }
+    }
+
+    /// Test inner lookup without cache
+    #[tokio::test]
+    async fn inner_lookup_with_no_cache() {
+        let mut config = ResolverConfig::default();
+        config.set_cache_enabled(false);
+
+        let mut resolver = AsyncResolver::new(config);
+        resolver.cache.set_max_size(1);
+
+        let domain_name = DomainName::new_from_string("example.com".to_string());
+        let a_rdata = ARdata::new_from_addr(IpAddr::from_str("93.184.216.34").unwrap());
+        let a_rdata = Rdata::A(a_rdata);
+        let resource_record = ResourceRecord::new(a_rdata);
+
+        resolver.cache.add(domain_name, resource_record);
+
+        let domain_name = DomainName::new_from_string("example.com".to_string());
+        let response = resolver.inner_lookup(domain_name, Qtype::A, Qclass::IN).await;
+
+        if let Ok(msg) = response {
+            assert_eq!(msg.get_header().get_aa(), false);
+        } else {
+            panic!("No response from nameserver");
+        }
     }
 
     /// Test cache data
@@ -546,7 +579,7 @@ mod async_resolver_test {
         let mut resolver = AsyncResolver::new(ResolverConfig::default());
         resolver.cache.set_max_size(1);
         assert_eq!(resolver.cache.is_empty(), true);
-        let _response = resolver.lookup("example.com", "UDP", "A","IN").await;
+        let _response = resolver.lookup("example.com", "UDP", "A", "IN").await;
         assert_eq!(resolver.cache.is_cached(DomainName::new_from_str("example.com"), Rtype::A), true);
 
         // TODO: Test special cases from RFC

src/main.rs

@@ -99,9 +99,11 @@ pub async fn main() {
             let conn = ClientTCPConnection::new(addr.unwrap(), Duration::from_secs(10));
             let mut client = Client::new(conn);
 
-            let mut _response = client.query(DomainName::new_from_string(client_args.host_name.clone()), client_args.qtype.as_str(), client_args.qclass.as_str());
+            let response = client.query(DomainName::new_from_string(client_args.host_name.clone()), client_args.qtype.as_str(), client_args.qclass.as_str());
 
-            //response.print_dns_message()
+            if let Ok(mut resp) = response {
+                resp.print_dns_message()
+            }
         }
 
         Commands::Resolver(resolver_args) => {

src/message/question.rs

@@ -76,7 +76,6 @@ impl Question {
 
         let (qname, bytes_without_name) = domain_name_result.unwrap();
 
-        println!("{}", bytes_without_name.len());
         if bytes_without_name.len() < 4 {
             return Err("Format Error");
         }

tests/integration_test.rs

@@ -0,0 +1,112 @@
+use std::{net::IpAddr, str::FromStr};
+
+use dns_rust::{async_resolver::{config::ResolverConfig, AsyncResolver, resolver_error::ResolverError}, message::{resource_record::ResourceRecord, rdata::Rdata}, domain_name::DomainName};
+
+
+
+// TODO: Change params type to intoDomainName
+async fn query_response(domain_name: &str, protocol: &str, qtype: &str) -> Result<Vec<ResourceRecord>, ResolverError>{
+
+    let config = ResolverConfig::default();
+    let mut resolver = AsyncResolver::new(config);
+
+    let response = resolver.lookup(
+        domain_name,
+        protocol,
+        qtype,
+        "IN").await;
+
+    response
+}
+
+/// 6.2.1 Query test Qtype = A
+#[tokio::test]
+async fn query_a_type() {
+    let response = query_response("example.com", "UDP", "A").await;
+
+    if let Ok(rrs) = response {
+        assert_eq!(rrs.iter().count(), 1);
+        let rdata = rrs[0].get_rdata();
+        if let Rdata::A(ip) = rdata {
+            assert_eq!(ip.get_address(), IpAddr::from_str("93.184.216.34").unwrap());
+        } else {
+            panic!("No ip address");
+        }
+    } 
+}
+
+/// 6.2.2 Query normal Qtype = *
+#[tokio::test]
+async fn query_any_type() {
+    let udp_response = query_response("example.com", "UDP", "ANY").await;
+    let tcp_response = query_response("example.com", "TCP", "ANY").await;
+    assert!(udp_response.is_err());
+    assert!(tcp_response.is_err());
+}
+
+/// 6.2.3 Query Qtype = MX
+#[tokio::test]
+async fn query_mx_type() {
+    let response = query_response("example.com", "UDP", "MX").await;
+
+    if let Ok(rrs) = response {
+        assert_eq!(rrs.len(), 1);
+
+        if let Rdata::MX(mxdata) = rrs[0].get_rdata() {
+            assert_eq!(
+                mxdata.get_exchange(),
+                DomainName::new_from_str(""));
+
+            assert_eq!(
+                mxdata.get_preference(),
+                0
+            )
+        } else { 
+            panic!("Record is not MX type");
+        }
+    }
+}
+
+
+// 6.2.4 Query Qtype = NS
+#[tokio::test]
+async fn query_ns_type() {
+    let response = query_response("example.com", "UDP", "NS").await;
+    if let Ok(rrs) = response {
+        assert_eq!(rrs.len(), 2);
+
+        if let Rdata::NS(ns1) = rrs[0].get_rdata() {
+            assert_eq!(
+                ns1.get_nsdname(),
+                DomainName::new_from_str("a.iana-servers.net"))
+        } else { 
+            panic!("First record is not NS");
+        }
+
+        if let Rdata::NS(ns) = rrs[1].get_rdata() {
+            assert_eq!(
+                ns.get_nsdname(),
+                DomainName::new_from_str("b.iana-servers.net"))
+        } else {
+            panic!("Second record is not NS");
+        }
+    }
+}
+
+/// 6.2.5 Mistyped host name Qtype = A
+#[tokio::test]
+async fn mistyped_host_name() {
+    let response = query_response("exampllee.com", "UDP", "A").await;
+    assert!(response.is_err());
+}
+
+/// No record test
+#[tokio::test]
+async fn no_resource_available() {
+    let response =  query_response("example.com", "UDP", "CNAME").await;
+    println!("{:?}", response);
+    assert!(response.is_err());
+}
+
+
+