resolver_test.go

package main

import (
	"strings"
	"testing"

	"github.com/coreos/go-etcd/etcd"
	"github.com/miekg/dns"
)

var (
	client   = etcd.NewClient([]string{"http://127.0.0.1:2379"})
	resolver = &Resolver{etcd: client}
)

func TestEtcd(t *testing.T) {
	// Enable debug logging
	log_debug = true

	if !client.SyncCluster() {
		t.Error("Failed to sync etcd cluster")
		t.Fatal()
	}
}

func TestGetFromStorageSingleKey(t *testing.T) {
	resolver.etcdPrefix = "TestGetFromStorageSingleKey/"
	client.Set("TestGetFromStorageSingleKey/net/disco/.A", "1.1.1.1", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	nodes, err := resolver.GetFromStorage("net/disco/.A")
	if err != nil {
		t.Error("Error returned from etcd", err)
		t.Fatal()
	}

	if len(nodes) != 1 {
		t.Error("Number of nodes should be 1: ", len(nodes))
		t.Fatal()
	}

	node := nodes[0]
	if node.node.Value != "1.1.1.1" {
		t.Error("Node value should be 1.1.1.1: ", node)
		t.Fatal()
	}
}

func TestGetFromStorageNestedKeys(t *testing.T) {
	resolver.etcdPrefix = "TestGetFromStorageNestedKeys/"
	client.Set("TestGetFromStorageNestedKeys/net/disco/.A/0", "1.1.1.1", 0)
	client.Set("TestGetFromStorageNestedKeys/net/disco/.A/1", "1.1.1.2", 0)
	client.Set("TestGetFromStorageNestedKeys/net/disco/.A/2/0", "1.1.1.3", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	nodes, err := resolver.GetFromStorage("net/disco/.A")
	if err != nil {
		t.Error("Error returned from etcd", err)
		t.Fatal()
	}

	if len(nodes) != 3 {
		t.Error("Number of nodes should be 3: ", len(nodes))
		t.Fatal()
	}

	var node *EtcdRecord

	node = nodes[0]
	if node.node.Value != "1.1.1.1" {
		t.Error("Node value should be 1.1.1.1: ", node)
		t.Fatal()
	}
	node = nodes[1]
	if node.node.Value != "1.1.1.2" {
		t.Error("Node value should be 1.1.1.2: ", node)
		t.Fatal()
	}
	node = nodes[2]
	if node.node.Value != "1.1.1.3" {
		t.Error("Node value should be 1.1.1.3: ", node)
		t.Fatal()
	}
}

func TestNameToKeyConverter(t *testing.T) {
	var key string

	key = nameToKey("foo.net.", "")
	if key != "/net/foo" {
		t.Error("Expected key /net/foo")
	}

	key = nameToKey("foo.net", "")
	if key != "/net/foo" {
		t.Error("Expected key /net/foo")
	}

	key = nameToKey("foo.net.", "/.A")
	if key != "/net/foo/.A" {
		t.Error("Expected key /net/foo/.A")
	}
}

/**
 * Test that the right authority is being returned for different types of DNS
 * queries.
 */

func TestAuthorityRoot(t *testing.T) {
	resolver.etcdPrefix = "TestAuthorityRoot/"
	client.Set("TestAuthorityRoot/net/disco/.SOA", "ns1.disco.net.\tadmin.disco.net.\t3600\t600\t86400\t10", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	query := new(dns.Msg)
	query.SetQuestion("disco.net.", dns.TypeA)

	answer := resolver.Lookup(query)

	if len(answer.Answer) > 0 {
		t.Error("Expected zero answers")
		t.Fatal()
	}

	if len(answer.Ns) != 1 {
		t.Error("Expected one authority record")
		t.Fatal()
	}

	rr := answer.Ns[0].(*dns.SOA)
	header := rr.Header()

	// Verify the header is correct
	if header.Name != "disco.net." {
		t.Error("Expected record with name disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeSOA {
		t.Error("Expected record with type SOA:", header.Rrtype)
		t.Fatal()
	}

	// Verify the record itself is correct
	if rr.Ns != "ns1.disco.net." {
		t.Error("Expected NS to be ns1.disco.net.: ", rr.Ns)
		t.Fatal()
	}
	if rr.Mbox != "admin.disco.net." {
		t.Error("Expected MBOX to be admin.disco.net.: ", rr.Mbox)
		t.Fatal()
	}
	// if rr.Serial != "admin.disco.net" {
	//     t.Error("Expected MBOX to be admin.disco.net: ", rr.Mbox)
	// }
	if rr.Refresh != 3600 {
		t.Error("Expected REFRESH to be 3600: ", rr.Refresh)
		t.Fatal()
	}
	if rr.Retry != 600 {
		t.Error("Expected RETRY to be 600: ", rr.Retry)
		t.Fatal()
	}
	if rr.Expire != 86400 {
		t.Error("Expected EXPIRE to be 86400: ", rr.Expire)
		t.Fatal()
	}
	if rr.Minttl != 10 {
		t.Error("Expected MINTTL to be 10: ", rr.Minttl)
		t.Fatal()
	}
}

func TestAuthorityDomain(t *testing.T) {
	resolver.etcdPrefix = "TestAuthorityDomain/"
	client.Set("TestAuthorityDomain/net/disco/.SOA", "ns1.disco.net.\tadmin.disco.net.\t3600\t600\t86400\t10", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	query := new(dns.Msg)
	query.SetQuestion("bar.disco.net.", dns.TypeA)

	answer := resolver.Lookup(query)

	if len(answer.Answer) > 0 {
		t.Error("Expected zero answers")
		t.Fatal()
	}

	if len(answer.Ns) != 1 {
		t.Error("Expected one authority record")
		t.Fatal()
	}

	rr := answer.Ns[0].(*dns.SOA)
	header := rr.Header()

	// Verify the header is correct
	if header.Name != "disco.net." {
		t.Error("Expected record with name disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeSOA {
		t.Error("Expected record with type SOA:", header.Rrtype)
		t.Fatal()
	}

	// Verify the record itself is correct
	if rr.Ns != "ns1.disco.net." {
		t.Error("Expected NS to be ns1.disco.net.: ", rr.Ns)
		t.Fatal()
	}
	if rr.Mbox != "admin.disco.net." {
		t.Error("Expected MBOX to be admin.disco.net.: ", rr.Mbox)
		t.Fatal()
	}
	if rr.Refresh != 3600 {
		t.Error("Expected REFRESH to be 3600: ", rr.Refresh)
		t.Fatal()
	}
	if rr.Retry != 600 {
		t.Error("Expected RETRY to be 600: ", rr.Retry)
		t.Fatal()
	}
	if rr.Expire != 86400 {
		t.Error("Expected EXPIRE to be 86400: ", rr.Expire)
		t.Fatal()
	}
	if rr.Minttl != 10 {
		t.Error("Expected MINTTL to be 10: ", rr.Minttl)
		t.Fatal()
	}
}

func TestAuthoritySubdomain(t *testing.T) {
	resolver.etcdPrefix = "TestAuthoritySubdomain/"
	client.Set("TestAuthoritySubdomain/net/disco/.SOA", "ns1.disco.net.\tadmin.disco.net.\t3600\t600\t86400\t10", 0)
	client.Set("TestAuthoritySubdomain/net/disco/bar/.SOA", "ns1.bar.disco.net.\tbar.disco.net.\t3600\t600\t86400\t10", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	query := new(dns.Msg)
	query.SetQuestion("foo.bar.disco.net.", dns.TypeA)

	answer := resolver.Lookup(query)

	if len(answer.Answer) > 0 {
		t.Error("Expected zero answers")
		t.Fatal()
	}

	if len(answer.Ns) != 1 {
		t.Error("Expected one authority record")
		t.Fatal()
	}

	rr := answer.Ns[0].(*dns.SOA)
	header := rr.Header()

	// Verify the header is correct
	if header.Name != "bar.disco.net." {
		t.Error("Expected record with name bar.disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeSOA {
		t.Error("Expected record with type SOA:", header.Rrtype)
		t.Fatal()
	}

	// Verify the record itself is correct
	if rr.Ns != "ns1.bar.disco.net." {
		t.Error("Expected NS to be ns1.disco.net.: ", rr.Ns)
		t.Fatal()
	}
	if rr.Mbox != "bar.disco.net." {
		t.Error("Expected MBOX to be admin.disco.net.: ", rr.Mbox)
		t.Fatal()
	}
	if rr.Refresh != 3600 {
		t.Error("Expected REFRESH to be 3600: ", rr.Refresh)
		t.Fatal()
	}
	if rr.Retry != 600 {
		t.Error("Expected RETRY to be 600: ", rr.Retry)
		t.Fatal()
	}
	if rr.Expire != 86400 {
		t.Error("Expected EXPIRE to be 86400: ", rr.Expire)
		t.Fatal()
	}
	if rr.Minttl != 10 {
		t.Error("Expected MINTTL to be 10: ", rr.Minttl)
		t.Fatal()
	}
}

/**
 * Test different that types of DNS queries return the correct answers
 **/

func TestAnswerQuestionA(t *testing.T) {
	resolver.etcdPrefix = "TestAnswerQuestionA/"
	client.Set("TestAnswerQuestionA/net/disco/bar/.A", "1.2.3.4", 0)
	client.Set("TestAnswerQuestionA/net/disco/.SOA", "ns1.disco.net.\tadmin.disco.net.\t3600\t600\t86400\t10", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	query := new(dns.Msg)
	query.SetQuestion("bar.disco.net.", dns.TypeA)

	answer := resolver.Lookup(query)

	if len(answer.Answer) != 1 {
		t.Error("Expected one answer, got ", len(answer.Answer))
		t.Fatal()
	}

	if len(answer.Ns) > 0 {
		t.Error("Didn't expect any authority records")
		t.Fatal()
	}

	rr := answer.Answer[0].(*dns.A)
	header := rr.Header()

	// Verify the header is correct
	if header.Name != "bar.disco.net." {
		t.Error("Expected record with name bar.disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeA {
		t.Error("Expected record with type A:", header.Rrtype)
		t.Fatal()
	}

	// Verify the record itself is correct
	if rr.A.String() != "1.2.3.4" {
		t.Error("Expected A record to be 1.2.3.4: ", rr.A)
		t.Fatal()
	}
}

func TestAnswerQuestionAAAA(t *testing.T) {
	resolver.etcdPrefix = "TestAnswerQuestionAAAA/"
	client.Set("TestAnswerQuestionAAAA/net/disco/bar/.AAAA", "::1", 0)
	client.Set("TestAnswerQuestionAAAA/net/disco/.SOA", "ns1.disco.net.\tadmin.disco.net.\t3600\t600\t86400\t10", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	query := new(dns.Msg)
	query.SetQuestion("bar.disco.net.", dns.TypeAAAA)

	answer := resolver.Lookup(query)

	if len(answer.Answer) != 1 {
		t.Error("Expected one answer, got ", len(answer.Answer))
		t.Fatal()
	}

	if len(answer.Ns) > 0 {
		t.Error("Didn't expect any authority records")
		t.Fatal()
	}

	rr := answer.Answer[0].(*dns.AAAA)
	header := rr.Header()

	// Verify the header is correct
	if header.Name != "bar.disco.net." {
		t.Error("Expected record with name bar.disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeAAAA {
		t.Error("Expected record with type AAAA:", header.Rrtype)
		t.Fatal()
	}

	// Verify the record itself is correct
	if rr.AAAA.String() != "::1" {
		t.Error("Expected AAAA record to be ::1: ", rr.AAAA)
		t.Fatal()
	}
}

func TestAnswerQuestionANY(t *testing.T) {
	resolver.etcdPrefix = "TestAnswerQuestionANY/"
	client.Set("TestAnswerQuestionANY/net/disco/bar/.TXT", "google.com.", 0)
	client.Set("TestAnswerQuestionANY/net/disco/bar/.A/0", "1.2.3.4", 0)
	client.Set("TestAnswerQuestionANY/net/disco/bar/.A/1", "2.3.4.5", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	query := new(dns.Msg)
	query.SetQuestion("bar.disco.net.", dns.TypeANY)

	answer := resolver.Lookup(query)

	if len(answer.Answer) != 3 {
		t.Error("Expected one answer, got ", len(answer.Answer))
		t.Fatal()
	}

	if len(answer.Ns) > 0 {
		t.Error("Didn't expect any authority records")
		t.Fatal()
	}
}

func TestAnswerQuestionUnsupportedType(t *testing.T) {
	// query for a type that we don't have support for (I tried to pick the most
	// obscure rr type that the dns library supports and that we're unlikely to
	// add support for)
	query := new(dns.Msg)
	query.SetQuestion("bar.disco.net.", dns.TypeEUI64)

	answer := resolver.Lookup(query)

	if len(answer.Answer) != 0 {
		t.Error("Expected no answers, got ", len(answer.Answer))
		t.Fatal()
	}

	if answer.Rcode != dns.RcodeNameError {
		t.Error("Expected NXDOMAIN response code, got", dns.RcodeToString[answer.Rcode])
		t.Fatal()
	}

	if len(answer.Ns) > 0 {
		t.Error("Didn't expect any authority records")
	}
}

func TestAnswerQuestionWildcardCNAME(t *testing.T) {
	resolver.etcdPrefix = "TestAnswerQuestionCNAME/"
	client.Set("TestAnswerQuestionCNAME/net/disco/*/.CNAME", "baz.disco.net.", 0)
	client.Set("TestAnswerQuestionCNAME/net/disco/baz/.A", "1.2.3.4", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	query := new(dns.Msg)
	query.SetQuestion("test.disco.net.", dns.TypeA)

	answer := resolver.Lookup(query)

	if len(answer.Answer) != 1 {
		t.Error("Expected one answers, got ", len(answer.Answer))
		t.Fatal()
	}

	if len(answer.Ns) > 0 {
		t.Error("Didn't expect any authority records")
		t.Fatal()
	}

	rr := answer.Answer[0].(*dns.CNAME)
	header := rr.Header()

	// Verify the header is correct
	if header.Name != "test.disco.net." {
		t.Error("Expected record with name test.disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeCNAME {
		t.Error("Expected record with type AAAA:", header.Rrtype)
		t.Fatal()
	}

	// Verify the CNAME data is correct
	if rr.Target != "baz.disco.net." {
		t.Error("Expected CNAME target baz.disco.net.:", header.Rrtype)
		t.Fatal()
	}
}

func TestAnswerQuestionCNAME(t *testing.T) {
	resolver.etcdPrefix = "TestAnswerQuestionCNAME/"
	client.Set("TestAnswerQuestionCNAME/net/disco/bar/.CNAME", "baz.disco.net.", 0)
	client.Set("TestAnswerQuestionCNAME/net/disco/baz/.A", "1.2.3.4", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	query := new(dns.Msg)
	query.SetQuestion("bar.disco.net.", dns.TypeA)

	answer := resolver.Lookup(query)

	if len(answer.Answer) != 1 {
		t.Error("Expected one answers, got ", len(answer.Answer))
		t.Fatal()
	}

	if len(answer.Ns) > 0 {
		t.Error("Didn't expect any authority records")
		t.Fatal()
	}

	rr := answer.Answer[0].(*dns.CNAME)
	header := rr.Header()

	// Verify the header is correct
	if header.Name != "bar.disco.net." {
		t.Error("Expected record with name bar.disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeCNAME {
		t.Error("Expected record with type CNAME:", header.Rrtype)
		t.Fatal()
	}

	// Verify the CNAME data is correct
	if rr.Target != "baz.disco.net." {
		t.Error("Expected CNAME target baz.disco.net.:", header.Rrtype)
		t.Fatal()
	}
}

func TestAnswerQuestionWildcardAAAANoMatch(t *testing.T) {
	resolver.etcdPrefix = "TestAnswerQuestionWildcardANoMatch/"
	client.Set("TestAnswerQuestionWildcardANoMatch/net/disco/bar/*/.AAAA", "::1", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	query := new(dns.Msg)
	query.SetQuestion("bar.disco.net.", dns.TypeAAAA)

	answer := resolver.Lookup(query)

	if len(answer.Answer) > 0 {
		t.Error("Didn't expect any answers, got ", len(answer.Answer))
		t.Fatal()
	}
}

func TestAnswerQuestionWildcardAAAA(t *testing.T) {
	resolver.etcdPrefix = "TestAnswerQuestionWildcardA/"
	client.Set("TestAnswerQuestionWildcardA/net/disco/bar/*/.AAAA", "::1", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	query := new(dns.Msg)
	query.SetQuestion("baz.bar.disco.net.", dns.TypeAAAA)

	answer := resolver.Lookup(query)

	if len(answer.Answer) != 1 {
		t.Error("Expected one answer, got ", len(answer.Answer))
		t.Fatal()
	}

	if len(answer.Ns) > 0 {
		t.Error("Didn't expect any authority records")
		t.Fatal()
	}

	rr := answer.Answer[0].(*dns.AAAA)
	header := rr.Header()

	// Verify the header is correct
	if header.Name != "baz.bar.disco.net." {
		t.Error("Expected record with name baz.bar.disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeAAAA {
		t.Error("Expected record with type AAAA:", header.Rrtype)
		t.Fatal()
	}

	// Verify the record itself is correct
	if rr.AAAA.String() != "::1" {
		t.Error("Expected AAAA record to be ::1: ", rr.AAAA)
		t.Fatal()
	}
}

func TestAnswerQuestionTTL(t *testing.T) {
	resolver.etcdPrefix = "TestAnswerQuestionTTL/"
	client.Set("TestAnswerQuestionTTL/net/disco/bar/.A", "1.2.3.4", 0)
	client.Set("TestAnswerQuestionTTL/net/disco/bar/.A.ttl", "300", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	records, _ := resolver.LookupAnswersForType("bar.disco.net.", dns.TypeA)

	if len(records) != 1 {
		t.Error("Expected one answer, got ", len(records))
		t.Fatal()
	}

	rr := records[0].(*dns.A)
	header := rr.Header()

	if header.Name != "bar.disco.net." {
		t.Error("Expected record with name bar.disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeA {
		t.Error("Expected record with type A:", header.Rrtype)
		t.Fatal()
	}
	if header.Ttl != 300 {
		t.Error("Expected TTL of 300 seconds:", header.Ttl)
		t.Fatal()
	}
	if rr.A.String() != "1.2.3.4" {
		t.Error("Expected A record to be 1.2.3.4: ", rr.A)
		t.Fatal()
	}
}

func TestAnswerQuestionTTLMultipleRecords(t *testing.T) {
	resolver.etcdPrefix = "TestAnswerQuestionTTLMultipleRecords/"
	client.Set("TestAnswerQuestionTTLMultipleRecords/net/disco/bar/.A/0", "1.2.3.4", 0)
	client.Set("TestAnswerQuestionTTLMultipleRecords/net/disco/bar/.A/0.ttl", "300", 0)
	client.Set("TestAnswerQuestionTTLMultipleRecords/net/disco/bar/.A/1", "8.8.8.8", 0)
	client.Set("TestAnswerQuestionTTLMultipleRecords/net/disco/bar/.A/1.ttl", "600", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	records, _ := resolver.LookupAnswersForType("bar.disco.net.", dns.TypeA)

	if len(records) != 2 {
		t.Error("Expected two answers, got ", len(records))
		t.Fatal()
	}

	rrOne := records[0].(*dns.A)
	headerOne := rrOne.Header()

	if headerOne.Ttl != 300 {
		t.Error("Expected TTL of 300 seconds:", headerOne.Ttl)
		t.Fatal()
	}
	if rrOne.A.String() != "1.2.3.4" {
		t.Error("Expected A record to be 1.2.3.4: ", rrOne.A)
		t.Fatal()
	}

	rrTwo := records[1].(*dns.A)
	headerTwo := rrTwo.Header()

	if headerTwo.Ttl != 600 {
		t.Error("Expected TTL of 300 seconds:", headerTwo.Ttl)
		t.Fatal()
	}
	if rrTwo.A.String() != "8.8.8.8" {
		t.Error("Expected A record to be 8.8.8.8: ", rrTwo.A)
		t.Fatal()
	}
}

func TestAnswerQuestionTTLInvalidFormat(t *testing.T) {
	resolver.etcdPrefix = "TestAnswerQuestionTTL/"
	client.Set("TestAnswerQuestionTTL/net/disco/bar/.A", "1.2.3.4", 0)
	client.Set("TestAnswerQuestionTTL/net/disco/bar/.A.ttl", "haha", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	records, _ := resolver.LookupAnswersForType("bar.disco.net.", dns.TypeA)

	if len(records) != 1 {
		t.Error("Expected one answer, got ", len(records))
		t.Fatal()
	}

	rr := records[0].(*dns.A)
	header := rr.Header()

	if header.Name != "bar.disco.net." {
		t.Error("Expected record with name bar.disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeA {
		t.Error("Expected record with type A:", header.Rrtype)
		t.Fatal()
	}
	if header.Ttl != 0 {
		t.Error("Expected TTL of 0 seconds:", header.Ttl)
		t.Fatal()
	}
	if rr.A.String() != "1.2.3.4" {
		t.Error("Expected A record to be 1.2.3.4: ", rr.A)
		t.Fatal()
	}
}

func TestAnswerQuestionTTLDanglingNode(t *testing.T) {
	resolver.etcdPrefix = "TestAnswerQuestionTTLDanglingNode/"
	client.Set("TestAnswerQuestionTTLDanglingNode/net/disco/bar/.TXT.ttl", "600", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	records, _ := resolver.LookupAnswersForType("bar.disco.net.", dns.TypeTXT)

	if len(records) != 0 {
		t.Error("Expected no answer, got ", len(records))
		t.Fatal()
	}
}

func TestAnswerQuestionTTLDanglingDirNode(t *testing.T) {
	resolver.etcdPrefix = "TestAnswerQuestionTTLDanglingDirNode/"
	client.Set("TestAnswerQuestionTTLDanglingDirNode/net/disco/bar/.TXT/0.ttl", "600", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	records, _ := resolver.LookupAnswersForType("bar.disco.net.", dns.TypeTXT)

	if len(records) != 0 {
		t.Error("Expected no answer, got ", len(records))
		t.Fatal()
	}
}

func TestAnswerQuestionTTLDanglingDirSibling(t *testing.T) {
	resolver.etcdPrefix = "TestAnswerQuestionTTLDanglingDirSibling/"
	client.Set("TestAnswerQuestionTTLDanglingDirSibling/net/disco/bar/.TXT/0.ttl", "100", 0)
	client.Set("TestAnswerQuestionTTLDanglingDirSibling/net/disco/bar/.TXT/1", "foo bar", 0)
	client.Set("TestAnswerQuestionTTLDanglingDirSibling/net/disco/bar/.TXT/1.ttl", "600", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	records, _ := resolver.LookupAnswersForType("bar.disco.net.", dns.TypeTXT)

	if len(records) != 1 {
		t.Error("Expected one answer, got ", len(records))
		t.Fatal()
	}

	rr := records[0].(*dns.TXT)
	header := rr.Header()

	if header.Name != "bar.disco.net." {
		t.Error("Expected record with name bar.disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeTXT {
		t.Error("Expected record with type TXT:", header.Rrtype)
		t.Fatal()
	}
	if header.Ttl != 600 {
		t.Error("Expected TTL of 600 seconds:", header.Ttl)
		t.Fatal()
	}
	if strings.Join(rr.Txt, "\n") != "foo bar" {
		t.Error("Expected txt record to be 'foo bar': ", rr.Txt)
		t.Fatal()
	}
}

/**
 * Test converstion of names (i.e etcd nodes) to single records of different
 * types.
 **/

func TestLookupAnswerForA(t *testing.T) {
	resolver.etcdPrefix = "TestLookupAnswerForA/"
	client.Set("TestLookupAnswerForA/net/disco/bar/.A", "1.2.3.4", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	records, _ := resolver.LookupAnswersForType("bar.disco.net.", dns.TypeA)

	if len(records) != 1 {
		t.Error("Expected one answer, got ", len(records))
		t.Fatal()
	}

	rr := records[0].(*dns.A)
	header := rr.Header()

	if header.Name != "bar.disco.net." {
		t.Error("Expected record with name bar.disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeA {
		t.Error("Expected record with type A:", header.Rrtype)
		t.Fatal()
	}
	if rr.A.String() != "1.2.3.4" {
		t.Error("Expected A record to be 1.2.3.4: ", rr.A)
		t.Fatal()
	}
}

func TestLookupAnswerForAAAA(t *testing.T) {
	resolver.etcdPrefix = "TestLookupAnswerForAAAA/"
	client.Set("TestLookupAnswerForAAAA/net/disco/bar/.AAAA", "::1", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	records, _ := resolver.LookupAnswersForType("bar.disco.net.", dns.TypeAAAA)

	if len(records) != 1 {
		t.Error("Expected one answer, got ", len(records))
		t.Fatal()
	}

	rr := records[0].(*dns.AAAA)
	header := rr.Header()

	if header.Name != "bar.disco.net." {
		t.Error("Expected record with name bar.disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeAAAA {
		t.Error("Expected record with type AAAA:", header.Rrtype)
		t.Fatal()
	}
	if rr.AAAA.String() != "::1" {
		t.Error("Expected AAAA record to be ::1: ", rr.AAAA)
		t.Fatal()
	}
}

func TestLookupAnswerForCNAME(t *testing.T) {
	resolver.etcdPrefix = "TestLookupAnswerForCNAME/"
	client.Set("TestLookupAnswerForCNAME/net/disco/bar/.CNAME", "cname.google.com.", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	records, _ := resolver.LookupAnswersForType("bar.disco.net.", dns.TypeCNAME)

	if len(records) != 1 {
		t.Error("Expected one answer, got ", len(records))
		t.Fatal()
	}

	rr := records[0].(*dns.CNAME)
	header := rr.Header()

	if header.Name != "bar.disco.net." {
		t.Error("Expected record with name bar.disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeCNAME {
		t.Error("Expected record with type CNAME:", header.Rrtype)
		t.Fatal()
	}
	if rr.Target != "cname.google.com." {
		t.Error("Expected CNAME record to be cname.google.com.: ", rr.Target)
		t.Fatal()
	}
}

func TestLookupAnswerForNS(t *testing.T) {
	resolver.etcdPrefix = "TestLookupAnswerForNS/"
	client.Set("TestLookupAnswerForNS/net/disco/bar/.NS", "dns.google.com.", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	records, _ := resolver.LookupAnswersForType("bar.disco.net.", dns.TypeNS)

	if len(records) != 1 {
		t.Error("Expected one answer, got ", len(records))
		t.Fatal()
	}

	rr := records[0].(*dns.NS)
	header := rr.Header()

	if header.Name != "bar.disco.net." {
		t.Error("Expected record with name bar.disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeNS {
		t.Error("Expected record with type NS:", header.Rrtype)
		t.Fatal()
	}
	if rr.Ns != "dns.google.com." {
		t.Error("Expected NS record to be dns.google.com.: ", rr.Ns)
		t.Fatal()
	}
}

func TestLookupAnswerForSOA(t *testing.T) {
	resolver.etcdPrefix = "TestLookupAnswerForSOA/"
	client.Set("TestLookupAnswerForSOA/net/disco/.SOA", "ns1.disco.net.\tadmin.disco.net.\t3600\t600\t86400\t10", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	records, _ := resolver.LookupAnswersForType("disco.net.", dns.TypeSOA)

	if len(records) != 1 {
		t.Error("Expected one answer, got ", len(records))
		t.Fatal()
	}

	rr := records[0].(*dns.SOA)
	header := rr.Header()

	if header.Name != "disco.net." {
		t.Error("Expected record with name disco.net.: ", header.Name)
		t.Fatal()
	}
	if header.Rrtype != dns.TypeSOA {
		t.Error("Expected record with type SOA:", header.Rrtype)
		t.Fatal()
	}

	// Verify the record itself is correct
	if rr.Ns != "ns1.disco.net." {
		t.Error("Expected NS to be ns1.disco.net.: ", rr.Ns)
		t.Fatal()
	}
	if rr.Mbox != "admin.disco.net." {
		t.Error("Expected MBOX to be admin.disco.net.: ", rr.Mbox)
		t.Fatal()
	}
	if rr.Refresh != 3600 {
		t.Error("Expected REFRESH to be 3600: ", rr.Refresh)
		t.Fatal()
	}
	if rr.Retry != 600 {
		t.Error("Expected RETRY to be 600: ", rr.Retry)
		t.Fatal()
	}
	if rr.Expire != 86400 {
		t.Error("Expected EXPIRE to be 86400: ", rr.Expire)
		t.Fatal()
	}
	if rr.Minttl != 10 {
		t.Error("Expected MINTTL to be 10: ", rr.Minttl)
		t.Fatal()
	}
}

func TestLookupAnswerForPTR(t *testing.T) {
	resolver.etcdPrefix = "TestLookupAnswerForPTR/"
	client.Set("TestLookupAnswerForPTR/net/disco/alias/.PTR/target1", "target1.disco.net.", 0)
	client.Set("TestLookupAnswerForPTR/net/disco/alias/.PTR/target2", "target2.disco.net.", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	records, _ := resolver.LookupAnswersForType("alias.disco.net.", dns.TypePTR)

	if len(records) != 2 {
		t.Error("Expected two answers, got ", len(records))
		t.Fatal()
	}

	seen_1 := false
	seen_2 := false

	// We can't (and shouldn't try to) guarantee order, so check for all
	// expected records the long way
	for _, record := range records {
		rr := record.(*dns.PTR)
		header := rr.Header()

		if header.Rrtype != dns.TypePTR {
			t.Error("Expected record with type PTR:", header.Rrtype)
			t.Fatal()
		}

		t.Log(rr)

		if rr.Ptr == "target1.disco.net." {
			seen_1 = true
		}

		if rr.Ptr == "target2.disco.net." {
			seen_2 = true
		}
	}

	if seen_1 == false || seen_2 == false {
		t.Error("Didn't get back all expected PTR responses")
		t.Fatal()
	}
}

func TestLookupAnswerForPTRInvalidDomain(t *testing.T) {
	resolver.etcdPrefix = "TestLookupAnswerForPTRInvalidDomain/"
	client.Set("TestLookupAnswerForPTRInvalidDomain/net/disco/bad-alias/.PTR", "...", 0)
	defer client.Delete(resolver.etcdPrefix, true)

	records, err := resolver.LookupAnswersForType("bad-alias.disco.net.", dns.TypePTR)

	if len(records) > 0 {
		t.Error("Expected no answers, got ", len(records))
		t.Fatal()
	}

	if err == nil {
		t.Error("Expected error, didn't get one")
		t.Fatal()
	}
}

func TestLookupAnswerForSRV(t *testing.T) {
	resolver.etcdPrefix = "TestLookupAnswerForSRV/"
	client.Set("TestLookupAnswerForSRV/net/disco/_tcp/_http/.SRV",
		"100\t100\t80\tsome-webserver.disco.net",
		0)
	defer client.Delete(resolver.etcdPrefix, true)

	records, _ := resolver.LookupAnswersForType("_http._tcp.disco.net.", dns.TypeSRV)

	if len(records) != 1 {
		t.Error("Expected one answer, got ", len(records))
		t.Fatal()
	}

	rr := records[0].(*dns.SRV)

	if rr.Priority != 100 {
		t.Error("Unexpected 'priority' value for SRV record:", rr.Priority)
	}

	if rr.Weight != 100 {
		t.Error("Unexpected 'weight' value for SRV record:", rr.Weight)
	}

	if rr.Port != 80 {
		t.Error("Unexpected 'port' value for SRV record:", rr.Port)
	}

	if rr.Target != "some-webserver.disco.net." {
		t.Error("Unexpected 'target' value for SRV record:", rr.Target)
	}
}

func TestLookupAnswerForSRVInvalidValues(t *testing.T) {
	resolver.etcdPrefix = "TestLookupAnswerForSRVInvalidValues/"
	defer client.Delete(resolver.etcdPrefix, true)

	var bad_vals_map = map[string]string{
		"wrong-delimiter":    "10 10 80 foo.disco.net",
		"not-enough-fields":  "0\t0",
		"neg-int-priority":   "-10\t10\t80\tfoo.disco.net",
		"neg-int-weight":     "10\t-10\t80\tfoo.disco.net",
		"neg-int-port":       "10\t10\t-80\tfoo.disco.net",
		"large-int-priority": "65536\t10\t80\tfoo.disco.net",
		"large-int-weight":   "10\t65536\t80\tfoo.disco.net",
		"large-int-port":     "10\t10\t65536\tfoo.disco.net"}

	for name, value := range bad_vals_map {

		client.Set("TestLookupAnswerForSRVInvalidValues/net/disco/"+name+"/.SRV", value, 0)
		records, err := resolver.LookupAnswersForType(name+".disco.net.", dns.TypeSRV)

		if len(records) > 0 {
			t.Error("Expected no answers, got ", len(records))
			t.Fatal()
		}

		if err == nil {
			t.Error("Expected error, didn't get one")
			t.Fatal()
		}
	}
}