add bigger test in cache by rtype to prove the correctly cleaning in a layer down (fails)

Author: konegoro

src/dns_cache/cache_by_record_type.rs

@@ -945,4 +945,86 @@ mod cache_data_test{
         }
     }
 
+    #[test]
+    //this test is going to prove if the cleaning after the timeout is acting correctly one layer down (CacheByDomain)
+    // ------BEFORE THE 5 SECONDS-----
+    // RTYPE:A -> {uchile (invalid) -> [..], example.com (valid) -> [..]}
+    // RTYPE:NS -> {uchile (valid) -> [..], example.com (invalid) -> [...]}
+    //-------AFTER THE 5 SECONDS-----
+    // RTYPE:A -> {example.com -> [...]}
+    // RTYPE:NS -> {uchile.com -> [...]}
+    fn filter_timout_cache_data_cleaning_layer_down(){
+        use std::{thread, time};
+        let mut cache_record_type = CacheByRecordType::new();
+        //Defaults Rdatas to use
+        let a_rdata = Rdata::A(ARdata::new());
+        let ns_rdata = Rdata::NS(NsRdata::new());
+
+                
+        let mut domain_name_1 = DomainName::new();
+        domain_name_1.set_name(String::from("example.com"));
+
+        let mut domain_name_2 = DomainName::new();
+        domain_name_2.set_name(String::from("uchile.cl"));
+
+        //adding in A rtypes
+        let mut resource_record_valid_a = ResourceRecord::new(a_rdata.clone());
+        resource_record_valid_a.set_ttl(1000);
+        let rr_cache_valid_a = RRStoredData::new(resource_record_valid_a.clone());
+        cache_record_type.add_to_cache_data(Rtype::A, domain_name_1.clone(), rr_cache_valid_a);
+                
+        let mut resource_record_invalid_a = ResourceRecord::new(a_rdata.clone());
+        resource_record_invalid_a.set_ttl(4);
+        let rr_cache_invalid_a = RRStoredData::new(resource_record_invalid_a.clone());
+        cache_record_type.add_to_cache_data(Rtype::A, domain_name_2.clone(), rr_cache_invalid_a);
+
+        //adding in NS rtypes
+        let mut resource_record_valid_ns = ResourceRecord::new(ns_rdata.clone());
+        resource_record_valid_ns.set_ttl(1000);
+        let rr_cache_valid_ns = RRStoredData::new(resource_record_valid_ns.clone());
+        cache_record_type.add_to_cache_data(Rtype::NS, domain_name_2.clone(), rr_cache_valid_ns);
+    
+        let mut resource_record_invalid_ns = ResourceRecord::new(ns_rdata.clone());
+        resource_record_invalid_ns.set_ttl(4);
+        let rr_cache_invalid_ns = RRStoredData::new(resource_record_invalid_ns.clone());
+        cache_record_type.add_to_cache_data(Rtype::NS, domain_name_1.clone(), rr_cache_invalid_ns);
+
+
+        //check if every record_types_data (HashMap for A and for NS) has 2 element 
+        let record_types_data = cache_record_type.get_cache_data();
+        //CacheByDomainName for A type
+        if let Some(record_types_data_a) = record_types_data.get(&Rtype::A) {
+            // println!("the cache by domain for A type is : \n {:?}",record_types_data_a.get_domain_names_data());
+            assert_eq!(record_types_data_a.get_domain_names_data().len(), 2);
+        }
+        //CacheByDomainName for NS type
+        if let Some(record_types_data_ns) = record_types_data.get(&Rtype::NS) {
+            // println!("the cache by domain for NS type is : \n {:?}",record_types_data_ns.get_domain_names_data());
+            assert_eq!(record_types_data_ns.get_domain_names_data().len(), 2);
+        }
+
+        println!("Before timeout: {:?}", Utc::now());
+        thread::sleep(time::Duration::from_secs(5));
+        println!("After timeout: {:?}", Utc::now());
+        cache_record_type.filter_timeout_cache_data();
+
+        let record_types_data_after_cleaning = cache_record_type.get_cache_data();
+
+        //after the cleaning, each cache shoud have 1 element
+        if let Some(record_types_data_a) = record_types_data_after_cleaning.get(&Rtype::A) {
+            println!("the cache by domain for A type after the cleaning is : \n {:?}",record_types_data_a.get_domain_names_data());
+            //FIXME: Does not delete the invadil rrstore, instead points to a empty array (same error as in cache by domain)
+            assert_eq!(record_types_data_a.get_domain_names_data().len(), 1);
+        }
+        //CacheByDomainName for NS type
+        if let Some(record_types_data_ns) = record_types_data_after_cleaning.get(&Rtype::NS) {
+            println!("the cache by domain for NS type after the cleaning is : \n {:?}",record_types_data_ns.get_domain_names_data());
+            //FIXME: Does not delete the invadil rrstore, instead points to a empty array (same error as in cache by domain)
+            assert_eq!(record_types_data_ns.get_domain_names_data().len(), 1);
+        }
+
+
+    }
+
+  
 }