func TestRetriableReaderMakesErrorsRetriable(t *testing.T) {
expected := errors.New("example error")
r := tools.NewRetriableReader(&ErrReader{expected})
var buf [1]byte
n, err := r.Read(buf[:])
assert.Equal(t, 0, n)
assert.EqualError(t, err, "LFS: "+expected.Error())
assert.True(t, errors.IsRetriableError(err))
}
func (r *RetriableReader) Read(b []byte) (int, error) {
n, err := r.reader.Read(b)
// EOF is a successful response as it is used to signal a graceful end
// of input c.f. https://git.io/v6riQ
//
// Otherwise, if the error is non-nil and already retriable (in the
// case that the underlying reader `r.reader` is itself a
// `*RetriableReader`, return the error wholesale:
if err == nil || err == io.EOF || errors.IsRetriableError(err) {
return n, err
}
return n, errors.NewRetriableError(err)
}
func TestRetriableReaderDoesNotRewrap(t *testing.T) {
// expected is already "retriable", as would be the case if the
// underlying reader was a *RetriableReader itself.
expected := errors.NewRetriableError(errors.New("example error"))
r := tools.NewRetriableReader(&ErrReader{expected})
var buf [1]byte
n, err := r.Read(buf[:])
assert.Equal(t, 0, n)
// errors.NewRetriableError wraps the given error with the prefix
// message "LFS", so these two errors should be equal, indicating that
// the RetriableReader did not re-wrap the error it received.
assert.EqualError(t, err, expected.Error())
assert.True(t, errors.IsRetriableError(err))
}
// canRetry returns whether or not the given error "err" is retriable.
func (q *TransferQueue) canRetry(err error) bool {
return errors.IsRetriableError(err)
}