github.com/stffabi/git-lfs@v2.3.5-0.20180214015214-8eeaa8d88902+incompatible/tools/iotools_test.go (about)

     1  package tools_test
     2  
     3  import (
     4  	"bytes"
     5  	"io"
     6  	"testing"
     7  
     8  	"github.com/git-lfs/git-lfs/errors"
     9  	"github.com/git-lfs/git-lfs/tools"
    10  	"github.com/stretchr/testify/assert"
    11  )
    12  
    13  func TestRetriableReaderReturnsSuccessfulReads(t *testing.T) {
    14  	r := tools.NewRetriableReader(bytes.NewBuffer([]byte{0x1, 0x2, 0x3, 0x4}))
    15  
    16  	var buf [4]byte
    17  	n, err := r.Read(buf[:])
    18  
    19  	assert.Nil(t, err)
    20  	assert.Equal(t, 4, n)
    21  	assert.Equal(t, []byte{0x1, 0x2, 0x3, 0x4}, buf[:])
    22  }
    23  
    24  func TestRetriableReaderReturnsEOFs(t *testing.T) {
    25  	r := tools.NewRetriableReader(bytes.NewBuffer([]byte{ /* empty */ }))
    26  
    27  	var buf [1]byte
    28  	n, err := r.Read(buf[:])
    29  
    30  	assert.Equal(t, io.EOF, err)
    31  	assert.Equal(t, 0, n)
    32  }
    33  
    34  func TestRetriableReaderMakesErrorsRetriable(t *testing.T) {
    35  	expected := errors.New("example error")
    36  
    37  	r := tools.NewRetriableReader(&ErrReader{expected})
    38  
    39  	var buf [1]byte
    40  	n, err := r.Read(buf[:])
    41  
    42  	assert.Equal(t, 0, n)
    43  	assert.EqualError(t, err, "LFS: "+expected.Error())
    44  	assert.True(t, errors.IsRetriableError(err))
    45  
    46  }
    47  
    48  func TestRetriableReaderDoesNotRewrap(t *testing.T) {
    49  	// expected is already "retriable", as would be the case if the
    50  	// underlying reader was a *RetriableReader itself.
    51  	expected := errors.NewRetriableError(errors.New("example error"))
    52  
    53  	r := tools.NewRetriableReader(&ErrReader{expected})
    54  
    55  	var buf [1]byte
    56  	n, err := r.Read(buf[:])
    57  
    58  	assert.Equal(t, 0, n)
    59  	// errors.NewRetriableError wraps the given error with the prefix
    60  	// message "LFS", so these two errors should be equal, indicating that
    61  	// the RetriableReader did not re-wrap the error it received.
    62  	assert.EqualError(t, err, expected.Error())
    63  	assert.True(t, errors.IsRetriableError(err))
    64  
    65  }
    66  
    67  // ErrReader implements io.Reader and only returns errors.
    68  type ErrReader struct {
    69  	// err is the error that this reader will return.
    70  	err error
    71  }
    72  
    73  // Read implements io.Reader#Read, and returns (0, e.err).
    74  func (e *ErrReader) Read(p []byte) (n int, err error) {
    75  	return 0, e.err
    76  }