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)