@@ -526,31 +526,23 @@ func TestClient(t *testing.T) {
526526
527527 // Assert that the minimum RTT is eventually >250ms.
528528 topo := getTopologyFromClient (mt .Client )
529- assert .Soon (mt , func (ctx context.Context ) {
530- for {
531- // Stop loop if callback has been canceled.
532- select {
533- case <- ctx .Done ():
534- return
535- default :
536- }
537-
538- time .Sleep (100 * time .Millisecond )
539-
540- // Wait for all of the server's minimum RTTs to be >250ms.
541- done := true
542- for _ , desc := range topo .Description ().Servers {
543- server , err := topo .FindServer (desc )
544- assert .Nil (mt , err , "FindServer error: %v" , err )
545- if server .RTTMonitor ().Min () <= 250 * time .Millisecond {
546- done = false
547- }
548- }
549- if done {
550- return
529+ callback := func () bool {
530+ // Wait for all of the server's minimum RTTs to be >250ms.
531+ for _ , desc := range topo .Description ().Servers {
532+ server , err := topo .FindServer (desc )
533+ assert .NoError (mt , err , "FindServer error: %v" , err )
534+ if server .RTTMonitor ().Min () <= 250 * time .Millisecond {
535+ return false // the tick should wait for 100ms in this case
551536 }
552537 }
553- }, 10 * time .Second )
538+
539+ return true
540+ }
541+ assert .Eventually (t ,
542+ callback ,
543+ 10 * time .Second ,
544+ 100 * time .Millisecond ,
545+ "expected that the minimum RTT is eventually >250ms" )
554546 })
555547
556548 // Test that if the minimum RTT is greater than the remaining timeout for an operation, the
@@ -574,31 +566,23 @@ func TestClient(t *testing.T) {
574566
575567 // Assert that the minimum RTT is eventually >250ms.
576568 topo := getTopologyFromClient (mt .Client )
577- assert .Soon (mt , func (ctx context.Context ) {
578- for {
579- // Stop loop if callback has been canceled.
580- select {
581- case <- ctx .Done ():
582- return
583- default :
584- }
585-
586- time .Sleep (100 * time .Millisecond )
587-
588- // Wait for all of the server's minimum RTTs to be >250ms.
589- done := true
590- for _ , desc := range topo .Description ().Servers {
591- server , err := topo .FindServer (desc )
592- assert .Nil (mt , err , "FindServer error: %v" , err )
593- if server .RTTMonitor ().Min () <= 250 * time .Millisecond {
594- done = false
595- }
596- }
597- if done {
598- return
569+ callback := func () bool {
570+ // Wait for all of the server's minimum RTTs to be >250ms.
571+ for _ , desc := range topo .Description ().Servers {
572+ server , err := topo .FindServer (desc )
573+ assert .NoError (mt , err , "FindServer error: %v" , err )
574+ if server .RTTMonitor ().Min () <= 250 * time .Millisecond {
575+ return false
599576 }
600577 }
601- }, 10 * time .Second )
578+
579+ return true
580+ }
581+ assert .Eventually (t ,
582+ callback ,
583+ 10 * time .Second ,
584+ 100 * time .Millisecond ,
585+ "expected that the minimum RTT is eventually >250ms" )
602586
603587 // Once we've waited for the minimum RTT for the single server to be >250ms, run a bunch of
604588 // Ping operations with a timeout of 250ms and expect that they return errors.
@@ -625,31 +609,23 @@ func TestClient(t *testing.T) {
625609
626610 // Assert that RTT90s are eventually >300ms.
627611 topo := getTopologyFromClient (mt .Client )
628- assert .Soon (mt , func (ctx context.Context ) {
629- for {
630- // Stop loop if callback has been canceled.
631- select {
632- case <- ctx .Done ():
633- return
634- default :
635- }
636-
637- time .Sleep (100 * time .Millisecond )
638-
639- // Wait for all of the server's RTT90s to be >300ms.
640- done := true
641- for _ , desc := range topo .Description ().Servers {
642- server , err := topo .FindServer (desc )
643- assert .Nil (mt , err , "FindServer error: %v" , err )
644- if server .RTTMonitor ().P90 () <= 300 * time .Millisecond {
645- done = false
646- }
647- }
648- if done {
649- return
612+ callback := func () bool {
613+ // Wait for all of the server's RTT90s to be >300ms.
614+ for _ , desc := range topo .Description ().Servers {
615+ server , err := topo .FindServer (desc )
616+ assert .NoError (mt , err , "FindServer error: %v" , err )
617+ if server .RTTMonitor ().P90 () <= 300 * time .Millisecond {
618+ return false
650619 }
651620 }
652- }, 10 * time .Second )
621+
622+ return true
623+ }
624+ assert .Eventually (t ,
625+ callback ,
626+ 10 * time .Second ,
627+ 100 * time .Millisecond ,
628+ "expected that the RTT90s are eventually >300ms" )
653629 })
654630
655631 // Test that if Timeout is set and the RTT90 is greater than the remaining timeout for an operation, the
@@ -676,31 +652,23 @@ func TestClient(t *testing.T) {
676652
677653 // Assert that RTT90s are eventually >275ms.
678654 topo := getTopologyFromClient (mt .Client )
679- assert .Soon (mt , func (ctx context.Context ) {
680- for {
681- // Stop loop if callback has been canceled.
682- select {
683- case <- ctx .Done ():
684- return
685- default :
686- }
687-
688- time .Sleep (100 * time .Millisecond )
689-
690- // Wait for all of the server's RTT90s to be >275ms.
691- done := true
692- for _ , desc := range topo .Description ().Servers {
693- server , err := topo .FindServer (desc )
694- assert .Nil (mt , err , "FindServer error: %v" , err )
695- if server .RTTMonitor ().P90 () <= 275 * time .Millisecond {
696- done = false
697- }
698- }
699- if done {
700- return
655+ callback := func () bool {
656+ // Wait for all of the server's RTT90s to be >275ms.
657+ for _ , desc := range topo .Description ().Servers {
658+ server , err := topo .FindServer (desc )
659+ assert .NoError (mt , err , "FindServer error: %v" , err )
660+ if server .RTTMonitor ().P90 () <= 275 * time .Millisecond {
661+ return false
701662 }
702663 }
703- }, 10 * time .Second )
664+
665+ return true
666+ }
667+ assert .Eventually (t ,
668+ callback ,
669+ 10 * time .Second ,
670+ 100 * time .Millisecond ,
671+ "expected that the RTT90s are eventually >275ms" )
704672
705673 // Once we've waited for the RTT90 for the servers to be >275ms, run 10 Ping operations
706674 // with a timeout of 275ms and expect that they return timeout errors.
0 commit comments