Function TestServeFromStaleCacheFetchVerifyTimeout

plugin/cache/cache_test.go:525–581

(t *testing.T)

}

func TestServeFromStaleCacheFetchVerifyTimeout(t *testing.T) {
	// Verify that when verifyStaleTimeout is set and the upstream is slow,
	// the client gets the stale entry within ~timeout, while the in-flight
	// verify continues in the background and refreshes the cache.
	c := New()
	c.staleUpTo = 1 * time.Hour
	c.verifyStale = true
	c.verifyStaleTimeout = 50 * time.Millisecond
	c.Next = ttlBackend(120)

	req := new(dns.Msg)
	req.SetQuestion("cached.org.", dns.TypeA)
	ctx := context.TODO()

	// Prime the cache with a 120s TTL entry.
	rec := dnstest.NewRecorder(&test.ResponseWriter{})
	c.ServeDNS(ctx, rec, req)
	if c.pcache.Len() != 1 {
		t.Fatalf("Msg with > 0 TTL should have been cached")
	}

	// Move forward past the TTL so the entry is stale.
	c.now = func() time.Time { return time.Now().Add(3 * time.Minute) }

	// Swap in a slow backend that takes longer than the verify timeout.
	bgDone := make(chan struct{})
	c.Next = slowTTLBackend(60, 200*time.Millisecond, bgDone)

	rec = dnstest.NewRecorder(&test.ResponseWriter{})
	start := time.Now()
	ret, err := c.ServeDNS(ctx, rec, req.Copy())
	elapsed := time.Since(start)

	if err != nil {
		t.Fatalf("unexpected error: %v", err)
	}
	if ret != dns.RcodeSuccess {
		t.Fatalf("expected RcodeSuccess, got %d", ret)
	}
	if elapsed > 150*time.Millisecond {
		t.Errorf("expected response within ~timeout (50ms); took %v", elapsed)
	}
	if rec.Msg == nil || len(rec.Msg.Answer) == 0 {
		t.Fatalf("expected an answer, got %+v", rec.Msg)
	}
	// Stale serve sets TTL to 0.
	if got := rec.Msg.Answer[0].Header().Ttl; got != 0 {
		t.Errorf("expected stale TTL=0, got %d", got)
	}

	// Wait for the background verify to complete.
	select {
	case <-bgDone:
	case <-time.After(2 * time.Second):
		t.Fatalf("background verify never completed")
	}
}