basic DNS cache

unit tests
This commit is contained in:
Alvaro Saurin committed 2015-03-24 12:44:01 +01:00
1 parent 0bcadb1e4e
commit 9dcec8ca16
8 files changed
+996 -113

No files matched your search

+77 -40
View File
@@ -15,6 +15,7 @@ const (
testRDNSsuccess = "1.2.2.10.in-addr.arpa."
testRDNSfail = "4.3.2.1.in-addr.arpa."
testRDNSnonlocal = "8.8.8.8.in-addr.arpa."
testUdpBufSize = 16384
)
var (
@@ -64,7 +65,7 @@ func TestUDPDNSServer(t *testing.T) {
}
// Run another DNS server for fallback
s, fallbackAddr, err := RunLocalUDPServer(t, "127.0.0.1:0", fallbackHandler)
s, fallbackAddr, err := runLocalUDPServer(t, "127.0.0.1:0", fallbackHandler)
wt.AssertNoErr(t, err)
defer s.Shutdown()
@@ -80,57 +81,34 @@ func TestUDPDNSServer(t *testing.T) {
var r *dns.Msg
r = testExchange(t, successTestName, dns.TypeA, 1, 1)
r = assertExchange(t, successTestName, dns.TypeA, 1, 1, 0)
wt.AssertType(t, r.Answer[0], (*dns.A)(nil), "DNS record")
wt.AssertEqualString(t, r.Answer[0].(*dns.A).A.String(), testAddr1, "IP address")
testExchange(t, failTestName, dns.TypeA, 0, 0)
assertExchange(t, failTestName, dns.TypeA, 0, 0, dns.RcodeNameError)
r = testExchange(t, testRDNSsuccess, dns.TypePTR, 1, 1)
r = assertExchange(t, testRDNSsuccess, dns.TypePTR, 1, 1, 0)
wt.AssertType(t, r.Answer[0], (*dns.PTR)(nil), "DNS record")
wt.AssertEqualString(t, r.Answer[0].(*dns.PTR).Ptr, successTestName, "IP address")
testExchange(t, testRDNSfail, dns.TypePTR, 0, 0)
assertExchange(t, testRDNSfail, dns.TypePTR, 0, 0, dns.RcodeNameError)
// This should fail because we don't handle MX records
testExchange(t, successTestName, dns.TypeMX, 0, 0)
assertExchange(t, successTestName, dns.TypeMX, 0, 0, dns.RcodeNotImplemented)
// This non-local query for an MX record should succeed by being
// passed on to the fallback server
testExchange(t, nonLocalName, dns.TypeMX, 1, -1)
assertExchange(t, nonLocalName, dns.TypeMX, 1, -1, 0)
// Now ask a query that we expect to return a lot of data.
testExchange(t, nonLocalName, dns.TypeANY, 5, -1)
assertExchange(t, nonLocalName, dns.TypeANY, 5, -1, 0)
testExchange(t, testRDNSnonlocal, dns.TypePTR, 1, -1)
assertExchange(t, testRDNSnonlocal, dns.TypePTR, 1, -1, 0)
// Not testing MDNS functionality of server here (yet), since it
// needs two servers, each listening on its own address
}
func testExchange(t *testing.T, z string, ty uint16, minAnswers int, maxAnswers int) *dns.Msg {
c := new(dns.Client)
c.UDPSize = DEFAULT_UDP_BUFLEN
m := new(dns.Msg)
m.RecursionDesired = true
m.SetQuestion(z, ty)
r, _, err := c.Exchange(m, fmt.Sprintf("127.0.0.1:%d", testPort))
wt.AssertNoErr(t, err)
if minAnswers == 0 && maxAnswers == 0 {
wt.AssertStatus(t, r.Rcode, dns.RcodeNameError, "DNS response code")
} else {
wt.AssertStatus(t, r.Rcode, dns.RcodeSuccess, "DNS response code")
}
answers := len(r.Answer)
if minAnswers >= 0 && answers < minAnswers {
wt.Fatalf(t, "Number of answers >= %d", minAnswers)
}
if maxAnswers >= 0 && answers > maxAnswers {
wt.Fatalf(t, "Number of answers <= %d", maxAnswers)
}
return r
}
func TestTCPDNSServer(t *testing.T) {
setupForTest()
const (
@@ -142,6 +120,7 @@ func TestTCPDNSServer(t *testing.T) {
InitDefaultLogging(true)
var zone = new(ZoneDb)
// generate a list of `numAnswers` IP addresses
var addrs []net.IP
bs := make([]byte, 4)
for i := 0; i < numAnswers; i++ {
@@ -151,10 +130,18 @@ func TestTCPDNSServer(t *testing.T) {
// handler for the fallback server: it will just return a very long response
fallbackUDPHandler := func(w dns.ResponseWriter, req *dns.Msg) {
maxLen := getMaxReplyLen(req, protUdp)
t.Logf("Fallback UDP server got asked: returning %d answers", numAnswers)
q := req.Question[0]
m := makeAddressReply(req, &q, addrs)
m.Truncated = true
mLen := m.Len()
m.SetEdns0(uint16(maxLen), false)
if mLen > maxLen {
t.Logf("... truncated response (%d > %d)", mLen, maxLen)
m.Truncated = true
}
w.WriteMsg(m)
}
fallbackTCPHandler := func(w dns.ResponseWriter, req *dns.Msg) {
@@ -164,17 +151,17 @@ func TestTCPDNSServer(t *testing.T) {
w.WriteMsg(m)
}
// Run another DNS server for fallback
us, fallbackUdpAddr, err := RunLocalUDPServer(t, "127.0.0.1:0", fallbackUDPHandler)
t.Logf("Running a DNS fallback server with UDP")
us, fallbackUdpAddr, err := runLocalUDPServer(t, "127.0.0.1:0", fallbackUDPHandler)
wt.AssertNoErr(t, err)
defer us.Shutdown()
_, fallbackPort, err := net.SplitHostPort(fallbackUdpAddr)
wt.AssertNoErr(t, err)
// start the TCP server on the same port as the UDP server
t.Logf("Starting another fallback server, with TCP, on the same port as the UDP server")
fallbackTcpAddr := fmt.Sprintf("127.0.0.1:%s", fallbackPort)
ts, fallbackTcpAddr, err := RunLocalTCPServer(t, fallbackTcpAddr, fallbackTCPHandler)
ts, fallbackTcpAddr, err := runLocalTCPServer(t, fallbackTcpAddr, fallbackTCPHandler)
wt.AssertNoErr(t, err)
defer ts.Shutdown()
@@ -188,7 +175,7 @@ func TestTCPDNSServer(t *testing.T) {
t.Logf("Creating a UDP and a TCP client")
uc := new(dns.Client)
uc.UDPSize = DEFAULT_UDP_BUFLEN
uc.UDPSize = minUdpSize
tc := new(dns.Client)
tc.Net = "tcp"
@@ -199,24 +186,73 @@ func TestTCPDNSServer(t *testing.T) {
t.Logf("Checking the fallback server at %s returns a truncated response with UDP", fallbackUdpAddr)
r, _, err := uc.Exchange(m, fallbackUdpAddr)
t.Logf("Got response from fallback server (UDP) with %d answers", len(r.Answer))
t.Logf("Response:\n%+v\n", r)
wt.AssertNoErr(t, err)
wt.AssertTrue(t, r.MsgHdr.Truncated, "DNS truncated reponse flag")
wt.AssertNotEqualInt(t, len(r.Answer), numAnswers, "number of answers (UDP)")
t.Logf("Checking the WeaveDNS server at %s returns a truncated reponse with UDP", dnsAddr)
r, _, err = uc.Exchange(m, dnsAddr)
t.Logf("UDP Response:\n%+v\n", r)
wt.AssertNoErr(t, err)
wt.AssertNotNil(t, r, "response")
t.Logf("%d answers", len(r.Answer))
wt.AssertTrue(t, r.MsgHdr.Truncated, "DNS truncated reponse flag")
wt.AssertNotEqualInt(t, len(r.Answer), numAnswers, "number of answers (UDP)")
t.Logf("Checking the WeaveDNS server at %s does not return a truncated reponse with TCP", dnsAddr)
r, _, err = tc.Exchange(m, dnsAddr)
t.Logf("TCP Response:\n%+v\n", r)
wt.AssertNoErr(t, err)
wt.AssertNotNil(t, r, "response")
t.Logf("%d answers", len(r.Answer))
wt.AssertFalse(t, r.MsgHdr.Truncated, "DNS truncated response flag")
wt.AssertEqualInt(t, len(r.Answer), numAnswers, "number of answers (TCP)")
t.Logf("Checking the WeaveDNS server at %s does not return a truncated reponse with UDP with a bigger buffer", dnsAddr)
m.SetEdns0(testUdpBufSize, false)
r, _, err = uc.Exchange(m, dnsAddr)
t.Logf("UDP-large Response:\n%+v\n", r)
wt.AssertNoErr(t, err)
wt.AssertNotNil(t, r, "response")
t.Logf("%d answers", len(r.Answer))
wt.AssertNoErr(t, err)
wt.AssertFalse(t, r.MsgHdr.Truncated, "DNS truncated response flag")
wt.AssertEqualInt(t, len(r.Answer), numAnswers, "number of answers (UDP-long)")
}
func RunLocalUDPServer(t *testing.T, laddr string, handler dns.HandlerFunc) (*dns.Server, string, error) {
//////////////////////////////////////////////////////////////////////////////
// perform a DNS query and assert the reply code, number or answers, etc
func assertExchange(t *testing.T, z string, ty uint16, minAnswers int, maxAnswers int, expErr int) *dns.Msg {
c := new(dns.Client)
c.UDPSize = testUdpBufSize
m := new(dns.Msg)
m.RecursionDesired = true
m.SetQuestion(z, ty)
m.SetEdns0(testUdpBufSize, false) // we don't want to play with truncation here...
r, _, err := c.Exchange(m, fmt.Sprintf("127.0.0.1:%d", testPort))
t.Logf("Response:\n%+v\n", r)
wt.AssertNoErr(t, err)
if minAnswers == 0 && maxAnswers == 0 {
wt.AssertStatus(t, r.Rcode, expErr, "DNS response code")
} else {
wt.AssertStatus(t, r.Rcode, dns.RcodeSuccess, "DNS response code")
}
answers := len(r.Answer)
if minAnswers >= 0 && answers < minAnswers {
wt.Fatalf(t, "Number of answers >= %d", minAnswers)
}
if maxAnswers >= 0 && answers > maxAnswers {
wt.Fatalf(t, "Number of answers <= %d", maxAnswers)
}
return r
}
// run a UDP fallback server
func runLocalUDPServer(t *testing.T, laddr string, handler dns.HandlerFunc) (*dns.Server, string, error) {
t.Logf("Starting fallback UDP server at %s", laddr)
pc, err := net.ListenPacket("udp", laddr)
if err != nil {
@@ -233,7 +269,8 @@ func RunLocalUDPServer(t *testing.T, laddr string, handler dns.HandlerFunc) (*dn
return server, pc.LocalAddr().String(), nil
}
func RunLocalTCPServer(t *testing.T, laddr string, handler dns.HandlerFunc) (*dns.Server, string, error) {
// run a TCP fallback server
func runLocalTCPServer(t *testing.T, laddr string, handler dns.HandlerFunc) (*dns.Server, string, error) {
t.Logf("Starting fallback TCP server at %s", laddr)
laddrTcp, err := net.ResolveTCPAddr("tcp", laddr)
if err != nil {