zone::tests: catalog test

easytier/src/dns/zone.rs

@@ -172,13 +172,21 @@ pub type ZoneGroup = RepeatedMessageModel<Zone>;
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::common::log;
     use crate::dns::config::DnsConfig;
+    use crate::dns::server::DynamicCatalog;
+    use crate::dns::utils::response::ResponseHandle;
     use hickory_client::client::{Client, ClientHandle};
+    use hickory_proto::op::{Message, MessageType, OpCode, Query, ResponseCode};
     use hickory_proto::rr::{rdata, DNSClass, Name, RData, RecordType};
     use hickory_proto::runtime::TokioRuntimeProvider;
+    use hickory_proto::serialize::binary::{BinDecodable, BinEncodable, BinEncoder};
     use hickory_proto::udp::UdpClientStream;
-    use hickory_server::authority::Catalog;
+    use hickory_proto::xfer::Protocol;
+    use hickory_server::authority::MessageRequest;
+    use hickory_server::server::Request;
     use hickory_server::ServerFuture;
+    use std::net::{Ipv4Addr, SocketAddrV4};
     use std::str::FromStr;
     use std::time::Duration;
     use tokio::net::UdpSocket;
@@ -226,8 +234,13 @@ mod tests {
 
     "#;
 
-    #[tokio::test]
+    // #[tokio::test]
+    #[tokio::test(flavor = "current_thread")]
     async fn test_config() -> anyhow::Result<()> {
+        log::tests::init();
+
+        let catalog = DynamicCatalog::new();
+
         let sep = "=".repeat(80);
         let config = toml::from_str::<DnsConfig>(CONFIG)?;
         assert_eq!(config.domain.to_string(), "测试.net");
@@ -244,6 +257,15 @@ mod tests {
         let records = zone.iter_records().collect_vec();
         assert_eq!(records.len(), 1);
 
+        let mut authorities = Vec::new();
+        authorities.extend(zone.create_memory_authority().into_iter());
+        authorities.extend(zone.create_forward_authority().into_iter());
+        catalog
+            .inner
+            .write()
+            .await
+            .upsert(zone.origin.clone().into(), authorities);
+
         let mut record = Record::update0(zone.origin.clone().into(), 60, RecordType::A);
         record.set_data(RData::A(rdata::a::A("100.100.100.100".parse()?)));
         assert_eq!(record, **records.iter().next().unwrap());
@@ -304,15 +326,47 @@ mod tests {
         let mut authorities = Vec::new();
         authorities.extend(zone.create_memory_authority().into_iter());
         authorities.extend(zone.create_forward_authority().into_iter());
-        assert_eq!(authorities.len(), 2);
+        catalog
-        let mut catalog = Catalog::new();
+            .inner
-        catalog.upsert(zone.origin.clone().into(), authorities);
+            .write()
+            .await
+            .upsert(zone.origin.clone().into(), authorities);
+
+        let mut query = Message::new();
+        query.set_id(0x1234);
+        query.set_message_type(MessageType::Query);
+        query.set_op_code(OpCode::Query);
+        query.set_recursion_desired(true);
+        query.add_query(Query::query(
+            Name::from_ascii("et.top.")?,
+            RecordType::A,
+        ));
+
+        let mut request = Vec::new();
+        let mut encoder = BinEncoder::new(&mut request);
+        query.emit(&mut encoder)?;
+
+        let request = Request::new(
+            MessageRequest::from_bytes(&request)?,
+            SocketAddrV4::new(Ipv4Addr::LOCALHOST, 0).into(),
+            Protocol::Udp,
+        );
+
+        let response = ResponseHandle::new(512);
+        let info = catalog
+            .inner
+            .read()
+            .await
+            .lookup(&request, None, response.clone())
+            .await;
+
+        assert_eq!(info.response_code(), ResponseCode::NoError);
 
         let socket = UdpSocket::bind("127.0.0.1:0").await?;
         let addr = socket.local_addr()?;
         println!("listening on {}", addr);
 
-        let mut server = ServerFuture::new(catalog);
+        let mut server = ServerFuture::new(catalog.clone());
         server.register_socket(socket);
         spawn(async move {
             if let Err(e) = server.block_until_done().await {