mirror of
https://github.com/coredns/coredns.git
synced 2025-11-04 03:03:14 -05:00
c840caf1ef
* Speed up testing * make notification run in the background, this recudes the test_readme time from 18s to 0.10s * reduce time for zone reload * TestServeDNSConcurrent remove entirely. This took a whopping 58s for ... ? A few minutes staring didn't reveal wth it is actually testing. Making values smaller revealed race conditions in the tests. Remove entirely. * Move many interval values to variables so we can reset them to short values for the tests. * test_large_axfr: make the zone smaller. The number used 64K has no rational, make it 64/10 to speed up. * TestProxyThreeWay: use client with shorter timeout A few random tidbits in other tests. Total time saved: 177s (almost 3m) - which makes it worthwhile again to run the test locally: this branch: ~~~ ok github.com/coredns/coredns/test 10.437s cd plugin; time go t ./... 5,51s user 7,51s system 11,15s elapsed 744%CPU ( ~~~ master: ~~~ ok github.com/coredns/coredns/test 35.252s cd plugin; time go t ./... 157,64s user 15,39s system 50,05s elapsed 345%CPU () ~~~ tests/ -25s plugins/ -40s This brings the total on 20s, and another 10s can be saved by fixing dnstapio. Moving this to 5s would be even better, but 10s is also nice. Signed-off-by: Miek Gieben <miek@miek.nl> * Also 0.01 Signed-off-by: Miek Gieben <miek@miek.nl>
81 lines
1.7 KiB
Go
81 lines
1.7 KiB
Go
package test
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/miekg/dns"
|
|
)
|
|
|
|
func TestProxyThreeWay(t *testing.T) {
|
|
// Run 3 CoreDNS server, 2 upstream ones and a proxy. 1 Upstream is unhealthy after 1 query, but after
|
|
// that we should still be able to send to the other one.
|
|
|
|
// Backend CoreDNS's.
|
|
corefileUp1 := `example.org:0 {
|
|
erratic {
|
|
drop 2
|
|
}
|
|
}`
|
|
|
|
up1, err := CoreDNSServer(corefileUp1)
|
|
if err != nil {
|
|
t.Fatalf("Could not get CoreDNS serving instance: %s", err)
|
|
}
|
|
defer up1.Stop()
|
|
|
|
corefileUp2 := `example.org:0 {
|
|
whoami
|
|
}`
|
|
|
|
up2, err := CoreDNSServer(corefileUp2)
|
|
if err != nil {
|
|
t.Fatalf("Could not get CoreDNS serving instance: %s", err)
|
|
}
|
|
defer up2.Stop()
|
|
|
|
addr1, _ := CoreDNSServerPorts(up1, 0)
|
|
if addr1 == "" {
|
|
t.Fatalf("Could not get UDP listening port")
|
|
}
|
|
addr2, _ := CoreDNSServerPorts(up2, 0)
|
|
if addr2 == "" {
|
|
t.Fatalf("Could not get UDP listening port")
|
|
}
|
|
|
|
// Proxying CoreDNS.
|
|
corefileProxy := `example.org:0 {
|
|
forward . ` + addr1 + " " + addr2 + ` {
|
|
max_fails 1
|
|
}
|
|
}`
|
|
|
|
prx, err := CoreDNSServer(corefileProxy)
|
|
if err != nil {
|
|
t.Fatalf("Could not get CoreDNS serving instance: %s", err)
|
|
}
|
|
defer prx.Stop()
|
|
addr, _ := CoreDNSServerPorts(prx, 0)
|
|
if addr == "" {
|
|
t.Fatalf("Could not get UDP listening port")
|
|
}
|
|
|
|
m := new(dns.Msg)
|
|
m.SetQuestion("example.org.", dns.TypeA)
|
|
c := new(dns.Client)
|
|
c.Timeout = 10 * time.Millisecond
|
|
|
|
for i := 0; i < 10; i++ {
|
|
r, _, err := c.Exchange(m, addr)
|
|
if err != nil {
|
|
continue
|
|
}
|
|
// We would previously get SERVFAIL, so just getting answers here
|
|
// is a good sign. The actual timeouts are handled in the err != nil case
|
|
// above.
|
|
if r.Rcode != dns.RcodeSuccess {
|
|
t.Fatalf("Expected success rcode, got %d", r.Rcode)
|
|
}
|
|
}
|
|
}
|