Modified TestMinResolutionInterval_NoExtraDelay to avoid running for 4s

Author: purnesh42H

internal/resolver/dns/dns_resolver.go

@@ -63,6 +63,7 @@ var (
 func init() {
 	resolver.Register(NewBuilder())
 	internal.TimeAfterFunc = time.After
+	internal.TimeUntilFunc = time.Until
 	internal.NewNetResolver = newNetResolver
 	internal.AddressDialer = addressDialer
 }
@@ -229,7 +230,7 @@ func (d *dnsResolver) watcher() {
 		select {
 		case <-d.ctx.Done():
 			return
-		case <-internal.TimeAfterFunc(time.Until(nextResolutionTime)):
+		case <-internal.TimeAfterFunc(internal.TimeUntilFunc(nextResolutionTime)):
 		}
 	}
 }

internal/resolver/dns/dns_resolver_test.go

@@ -102,6 +102,15 @@ func overrideTimeAfterFuncWithChannel(t *testing.T) (durChan chan time.Duration,
 	return durChan, timeChan
 }
 
+// Override the remaining time used by the DNS resolver to allow resolution
+func overrideTimeUntilFunc(t *testing.T, now time.Time) {
+	origTimeUntil := dnsinternal.TimeUntilFunc
+	dnsinternal.TimeUntilFunc = func(tm time.Time) time.Duration {
+		return now.Sub(tm)
+	}
+	t.Cleanup(func() { dnsinternal.TimeUntilFunc = origTimeUntil })
+}
+
 func enableSRVLookups(t *testing.T) {
 	origEnableSRVLookups := dns.EnableSRVLookups
 	dns.EnableSRVLookups = true
@@ -1292,16 +1301,12 @@ func (s) TestMinResolutionInterval(t *testing.T) {
 }
 
 // TestMinResolutionInterval_NoExtraDelay verifies that there is no extra delay
-// between two resolution requests apart from [MinResolutionInterval]
-// i.e. if a request is made after [MinResolutionInterval], it should resolve
-// immediately. Test sets [MinResolutionInterval] to 1 second and calls
-// ResolveNow() 4 times with a wait of 1 second between each request.
-// A correct implementation should resolve all requests without timing out in
-// test duration of 5 seconds.
+// between two resolution requests apart from [minResolutionInterval].
+// It sets the minResolutionInterval 1s and overrides timeUntilFunc to
+// calculate remaining time to allow resolution after 1s and verifies that
+// remaining time to allow resolution is very small
 func (s) TestMinResolutionInterval_NoExtraDelay(t *testing.T) {
-	const target = "foo.bar.com"
-
-	overrideResolutionInterval(t, 1*time.Second)
+	durChan, timeChan := overrideTimeAfterFuncWithChannel(t)
 	tr := &testNetResolver{
 		hostLookupTable: map[string][]string{
 			"foo.bar.com": {"1.2.3.4", "5.6.7.8"},
@@ -1311,34 +1316,44 @@ func (s) TestMinResolutionInterval_NoExtraDelay(t *testing.T) {
 		},
 	}
 	overrideNetResolver(t, tr)
+	var minResolutionInterval = 1 * time.Second
+	overrideResolutionInterval(t, minResolutionInterval)
 
-	r, stateCh, _ := buildResolverWithTestClientConn(t, target)
+	r, stateCh, errorCh := buildResolverWithTestClientConn(t, "foo.bar.com")
 
-	wantAddrs := []resolver.Address{{Addr: "1.2.3.4" + colonDefaultPort}, {Addr: "5.6.7.8" + colonDefaultPort}}
-	wantSC := scJSON
-
-	// set context timeout to test duration of 5 seconds
-	// to make sure all 4 resolutions happen successfully
-	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-	defer cancel()
+	ctx, ctxCancel := context.WithTimeout(context.Background(), defaultTestTimeout)
+	defer ctxCancel()
+	select {
+	case <-ctx.Done():
+		t.Fatal("Timeout when waiting for an error from the resolver")
+	case <-stateCh:
+	case err := <-errorCh:
+		t.Fatalf("Unexpected error from resolver, %v", err)
+	}
 
-	// We chose to make 4 requests to strike a balance between coverage and
-	// test duration. This number is sufficiently large to validate the
-	// behavior across multiple resolution attempts, while also reducing
-	// the likelihood of flakiness due to timing issues.
-	for i := 1; i <= 4; i++ {
-		verifyUpdateFromResolver(ctx, t, stateCh, wantAddrs, nil, wantSC)
+	// Make next resolution request after 1s.
+	var now = time.Now().Add(minResolutionInterval)
+	overrideTimeUntilFunc(t, now)
+	r.ResolveNow(resolver.ResolveNowOptions{})
 
-		// Wait for 1 second to respect [MinResolutionInterval]
-		// before sending another resolution request
-		select {
-		case <-dnsinternal.TimeAfterFunc(1 * time.Second):
-			// Waited for 1 second
-		case <-ctx.Done():
-			// If the context is done, exit the loop
-			t.Fatal("Timeout when waiting for a state update from the resolver")
+	ctx, cancel := context.WithTimeout(context.Background(), defaultTestTimeout)
+	defer cancel()
+	select {
+	case <-ctx.Done():
+		t.Fatal("Timeout when waiting for an error from the resolver")
+	case dur := <-durChan:
+		if dur > 1*time.Millisecond {
+			t.Fatalf("Remaining time duration to allow next resolution is higher than expected")
 		}
+	}
 
-		r.ResolveNow(resolver.ResolveNowOptions{})
+	// Unblock the DNS resolver's backoff by pushing the current time.
+	timeChan <- time.Now()
+
+	select {
+	case <-ctx.Done():
+		t.Fatal("Timeout when waiting for an error from the resolver")
+	case err := <-errorCh:
+		t.Fatalf("Unexpected error from resolver, %v", err)
 	}
 }

internal/resolver/dns/internal/internal.go

@@ -51,11 +51,17 @@ var (
 // The following vars are overridden from tests.
 var (
 	// TimeAfterFunc is used by the DNS resolver to wait for the given duration
-	// to elapse. In non-test code, this is implemented by time.After.  In test
+	// to elapse. In non-test code, this is implemented by time.After. In test
 	// code, this can be used to control the amount of time the resolver is
 	// blocked waiting for the duration to elapse.
 	TimeAfterFunc func(time.Duration) <-chan time.Time
 
+	// TimeUntilFunc is used by the DNS resolver to get the time remaining
+	// to allow next resolution. In non-test code, this is implemented by
+	// time.Until. In test code, this can be used to control the remaining
+	// time for resolver to allow next resolution.
+	TimeUntilFunc func(time.Time) time.Duration
+
 	// NewNetResolver returns the net.Resolver instance for the given target.
 	NewNetResolver func(string) (NetResolver, error)