Package retry

func TestX(t *testing.T) {
    retry.Run(t, func(r *retry.R) {
        if err := foo(); err != nil {
            r.Fatal("f: ", err)
        }
    })
}

func Run ¶

func Run(t Failer, f func(r *R))

func RunWith ¶

func RunWith(r Retryer, t Failer, f func(r *R))

type Counter ¶

Counter repeats an operation a given number of times and waits between subsequent operations.

type Counter struct {
    Count int
    Wait  time.Duration
    // contains filtered or unexported fields
}

func ThreeTimes ¶

func ThreeTimes() *Counter

ThreeTimes repeats an operation three times and waits 25ms in between.

func (*Counter) NextOr ¶

func (r *Counter) NextOr(fail func()) bool

type Failer ¶

Failer is an interface compatible with testing.T.

type Failer interface {
    // Log is called for the final test output
    Log(args ...interface{})

    // FailNow is called when the retrying is abandoned.
    FailNow()
}

type R ¶

R provides context for the retryer.

type R struct {
    // contains filtered or unexported fields
}

func (*R) Check ¶

func (r *R) Check(err error)

func (*R) Error ¶

func (r *R) Error(args ...interface{})

func (*R) FailNow ¶

func (r *R) FailNow()

func (*R) Fatal ¶

func (r *R) Fatal(args ...interface{})

func (*R) Fatalf ¶

func (r *R) Fatalf(format string, args ...interface{})

type Retryer ¶

Retryer provides an interface for repeating operations until they succeed or an exit condition is met.

type Retryer interface {
    // NextOr returns true if the operation should be repeated.
    // Otherwise, it calls fail and returns false.
    NextOr(fail func()) bool
}

type Timer ¶

Timer repeats an operation for a given amount of time and waits between subsequent operations.

type Timer struct {
    Timeout time.Duration
    Wait    time.Duration
    // contains filtered or unexported fields
}

func TwoSeconds ¶

func TwoSeconds() *Timer

TwoSeconds repeats an operation for two seconds and waits 25ms in between.

func (*Timer) NextOr ¶

func (r *Timer) NextOr(fail func()) bool