Add TestServer (#102)

Add a fullblown testing server. This allows us to do integration tests.

Also add a basic proxy test. Further tests will test etcd proxy
and stub zone communication and other "wildish" configurations.
Redo the server startup, so we can access the ports it listens on when
it has started up (with dns.ActivateAndServer).

Extend the .travis file to download etcd and test for that as well.

Put integration tests in test dir

3 files changed, 104 insertions, 0 deletions

diff --git a/test/etcd_test.go b/test/etcd_test.go
new file mode 100644
index 000000000..96be524e4
--- /dev/null
+++ b/test/etcd_test.go
@@ -0,0 +1,11 @@
+// +build etcd
+
+package test
+
+import "testing"
+
+// This test starts two coredns servers (and needs etcd). Configure a stubzones in both (that will loop) and
+// will then test if we detect this loop.
+func TestEtcdStubForwarding(t *testing.T) {
+	// TODO(miek)
+}
diff --git a/test/server_test.go b/test/server_test.go
new file mode 100644
index 000000000..6020e76d3
--- /dev/null
+++ b/test/server_test.go
@@ -0,0 +1,53 @@
+package test
+
+import (
+	"testing"
+
+	"github.com/miekg/dns"
+)
+
+// Start 2 tests server, server A will proxy to B, server B is an CH server.
+func TestProxyToChaosServer(t *testing.T) {
+	corefile := `.:0 {
+	chaos CoreDNS-001 miek@miek.nl
+}
+`
+	chaos, tcpCH, udpCH, err := testServer(t, corefile)
+	if err != nil {
+		t.Fatalf("Could get server: %s", err)
+	}
+	defer chaos.Stop()
+
+	corefileProxy := `.:0 {
+		proxy . ` + udpCH + `
+}
+`
+	proxy, _, udp, err := testServer(t, corefileProxy)
+	if err != nil {
+		t.Fatalf("Could get server: %s", err)
+	}
+	defer proxy.Stop()
+
+	chaosTest(t, udpCH, "udp")
+	chaosTest(t, tcpCH, "tcp")
+
+	chaosTest(t, udp, "udp")
+	// chaosTest(t, tcp, "tcp"), commented out because we use the original transport to reach the
+	// proxy and we only forward to the udp port.
+}
+
+func chaosTest(t *testing.T, server, net string) {
+	m := testMsg("version.bind.", dns.TypeTXT, nil)
+	m.Question[0].Qclass = dns.ClassCHAOS
+
+	r, err := testExchange(m, server, net)
+	if err != nil {
+		t.Fatalf("Could not send message: %s", err)
+	}
+	if r.Rcode != dns.RcodeSuccess || len(r.Answer) == 0 {
+		t.Fatalf("Expected successful reply on %s, got %s", net, dns.RcodeToString[r.Rcode])
+	}
+	if r.Answer[0].String() != `version.bind.	0	CH	TXT	"CoreDNS-001"` {
+		t.Fatalf("Expected version.bind. reply, got %s", r.Answer[0].String())
+	}
+}
diff --git a/test/tests.go b/test/tests.go
new file mode 100644
index 000000000..2b11a5ac9
--- /dev/null
+++ b/test/tests.go
@@ -0,0 +1,40 @@
+package test
+
+import (
+	"testing"
+	"time"
+
+	"github.com/miekg/coredns/core"
+	"github.com/miekg/coredns/middleware"
+	"github.com/miekg/coredns/server"
+
+	"github.com/miekg/dns"
+)
+
+func testMsg(zone string, typ uint16, o *dns.OPT) *dns.Msg {
+	m := new(dns.Msg)
+	m.SetQuestion(zone, typ)
+	if o != nil {
+		m.Extra = []dns.RR{o}
+	}
+	return m
+}
+
+func testExchange(m *dns.Msg, server, net string) (*dns.Msg, error) {
+	c := new(dns.Client)
+	c.Net = net
+	return middleware.Exchange(c, m, server)
+}
+
+// testServer returns a test server and the tcp and udp listeners addresses.
+func testServer(t *testing.T, corefile string) (*server.Server, string, string, error) {
+	srv, err := core.TestServer(t, corefile)
+	if err != nil {
+		return nil, "", "", err
+	}
+	go srv.ListenAndServe()
+
+	time.Sleep(1 * time.Second)
+	tcp, udp := srv.LocalAddr()
+	return srv, tcp.String(), udp.String(), nil
+}