Fix stubzone retention (#198)

Make the receiver a pointer so that the uptdateStubZones map update will
retain the stubzones found, unlike the current case where the update
will be applied and then promptly forgotten, because it is working on a
copy.

Add test/etcd_test.go to test a large part of the code. This didn't
catch the chaos middleware hack though. The chaos middleware zones are
now *not* automatically added. You have to take care of that by yourself
(docs updates).

When using debug queries and falling through to the next middleware in
etcd, restore the original (with o-o.debug) query before passing it on.

test/etcd_test.go

@@ -2,10 +2,103 @@
 
 package test
 
-import "testing"
+import (
+	"encoding/json"
+	"io/ioutil"
+	"log"
+	"testing"
+	"time"
+
+	"github.com/miekg/coredns/middleware"
+	"github.com/miekg/coredns/middleware/etcd"
+	"github.com/miekg/coredns/middleware/etcd/msg"
+	"github.com/miekg/coredns/middleware/proxy"
+	"github.com/miekg/coredns/middleware/test"
+
+	etcdc "github.com/coreos/etcd/client"
+	"github.com/miekg/dns"
+	"golang.org/x/net/context"
+)
+
+func etcdMiddleware() *etcd.Etcd {
+	etcdCfg := etcdc.Config{
+		Endpoints: []string{"http://localhost:2379"},
+	}
+	cli, _ := etcdc.New(etcdCfg)
+	client := etcdc.NewKeysAPI(cli)
+	return &etcd.Etcd{Client: client}
+}
 
 // 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)
 }
+
+func TestEtcdStubAndProxyLookup(t *testing.T) {
+	corefile := `.:0 {
+    etcd skydns.local {
+        stubzones
+        path /skydns
+        endpoint http://localhost:2379
+        upstream 8.8.8.8:53 8.8.4.4:53
+    }
+    proxy . 8.8.8.8:53
+}`
+
+	etc := etcdMiddleware()
+	ex, _, udp, err := Server(t, corefile)
+	if err != nil {
+		t.Fatalf("Could get server: %s", err)
+	}
+	defer ex.Stop()
+
+	log.SetOutput(ioutil.Discard)
+
+	var ctx = context.TODO()
+	for _, serv := range servicesStub { // adds example.{net,org} as stubs
+		set(ctx, t, etc, serv.Key, 0, serv)
+		defer delete(ctx, t, etc, serv.Key)
+	}
+
+	p := proxy.New([]string{udp}) // use udp port from the server
+	state := middleware.State{W: &test.ResponseWriter{}, Req: new(dns.Msg)}
+	resp, err := p.Lookup(state, "example.com.", dns.TypeA)
+	if err != nil {
+		t.Error("Expected to receive reply, but didn't")
+		return
+	}
+	if len(resp.Answer) == 0 {
+		t.Error("Expected to at least one RR in the answer section, got none")
+	}
+	if resp.Answer[0].Header().Rrtype != dns.TypeA {
+		t.Error("Expected RR to A, got: %d", resp.Answer[0].Header().Rrtype)
+	}
+	if resp.Answer[0].(*dns.A).A.String() != "93.184.216.34" {
+		t.Error("Expected 93.184.216.34, got: %d", resp.Answer[0].(*dns.A).A.String())
+	}
+}
+
+var servicesStub = []*msg.Service{
+	// Two tests, ask a question that should return servfail because remote it no accessible
+	// and one with edns0 option added, that should return refused.
+	{Host: "127.0.0.1", Port: 666, Key: "b.example.org.stub.dns.skydns.test."},
+	// Actual test that goes out to the internet.
+	{Host: "199.43.132.53", Key: "a.example.net.stub.dns.skydns.test."},
+}
+
+// Copied from middleware/etcd/setup_test.go
+func set(ctx context.Context, t *testing.T, e *etcd.Etcd, k string, ttl time.Duration, m *msg.Service) {
+	b, err := json.Marshal(m)
+	if err != nil {
+		t.Fatal(err)
+	}
+	path, _ := msg.PathWithWildcard(k, e.PathPrefix)
+	e.Client.Set(ctx, path, string(b), &etcdc.SetOptions{TTL: ttl})
+}
+
+// Copied from middleware/etcd/setup_test.go
+func delete(ctx context.Context, t *testing.T, e *etcd.Etcd, k string) {
+	path, _ := msg.PathWithWildcard(k, e.PathPrefix)
+	e.Client.Delete(ctx, path, &etcdc.DeleteOptions{Recursive: false})
+}