vendor/github.com/cenkalti/backoff/ticker_test.go

   1 package backoff
   2
   3 import (
   4         "context"
   5         "errors"
   6         "fmt"
   7         "log"
   8         "testing"
   9         "time"
  10 )
  11
  12 func TestTicker(t *testing.T) {
  13         const successOn = 3
  14         var i = 0
  15
  16         // This function is successful on "successOn" calls.
  17         f := func() error {
  18                 i++
  19                 log.Printf("function is called %d. time\n", i)
  20
  21                 if i == successOn {
  22                         log.Println("OK")
  23                         return nil
  24                 }
  25
  26                 log.Println("error")
  27                 return errors.New("error")
  28         }
  29
  30         b := NewExponentialBackOff()
  31         ticker := NewTicker(b)
  32         elapsed := b.GetElapsedTime()
  33         if elapsed > time.Second {
  34                 t.Errorf("elapsed time too large: %v", elapsed)
  35         }
  36
  37         var err error
  38         for _ = range ticker.C {
  39                 if err = f(); err != nil {
  40                         t.Log(err)
  41                         continue
  42                 }
  43
  44                 break
  45         }
  46         if err != nil {
  47                 t.Errorf("unexpected error: %s", err.Error())
  48         }
  49         if i != successOn {
  50                 t.Errorf("invalid number of retries: %d", i)
  51         }
  52 }
  53
  54 func TestTickerContext(t *testing.T) {
  55         const cancelOn = 3
  56         var i = 0
  57
  58         ctx, cancel := context.WithCancel(context.Background())
  59         defer cancel()
  60
  61         // This function cancels context on "cancelOn" calls.
  62         f := func() error {
  63                 i++
  64                 log.Printf("function is called %d. time\n", i)
  65
  66                 // cancelling the context in the operation function is not a typical
  67                 // use-case, however it allows to get predictable test results.
  68                 if i == cancelOn {
  69                         cancel()
  70                 }
  71
  72                 log.Println("error")
  73                 return fmt.Errorf("error (%d)", i)
  74         }
  75
  76         b := WithContext(NewConstantBackOff(time.Millisecond), ctx)
  77         ticker := NewTicker(b)
  78
  79         var err error
  80         for _ = range ticker.C {
  81                 if err = f(); err != nil {
  82                         t.Log(err)
  83                         continue
  84                 }
  85
  86                 break
  87         }
  88         if err == nil {
  89                 t.Errorf("error is unexpectedly nil")
  90         }
  91         if err.Error() != "error (3)" {
  92                 t.Errorf("unexpected error: %s", err.Error())
  93         }
  94         if i != cancelOn {
  95                 t.Errorf("invalid number of retries: %d", i)
  96         }
  97 }