github.com/catandhorse/git-lfs@v2.5.2+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 }