Skip to content

Commit 7893068

Browse files
thrawn01thrawn01
authored
Merge pull request #4 from ldez/feat/go-module
go module
2 parents a4ef56f + 7d994fa commit 7893068

File tree

5 files changed

+116
-100
lines changed

5 files changed

+116
-100
lines changed

‎Makefile

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,7 @@ clean:
22
find . -name flymake_* -delete
33

44
test: clean
5-
go test -v .
5+
go test -race -v .
66

77
test-grep: clean
88
go test -v . -check.f=$(e)

‎buffer.go

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -27,13 +27,13 @@ type MultiReader interface {
2727
type WriterOnce interface {
2828
// Write implements io.Writer
2929
Write(p []byte) (int, error)
30-
// Reader transfers all data written to this writer to MultiReader. If there was no data written it retuns an error
30+
// Reader transfers all data written to this writer to MultiReader. If there was no data written it returns an error
3131
Reader() (MultiReader, error)
3232
// WriterOnce owns the data before Reader has been called, so Close will close all the underlying files if Reader has not been called.
3333
Close() error
3434
}
3535

36-
// MaxBytes, ignored if set to value >=, if request exceeds the specified limit, the reader will return error,
36+
// MaxBytes ignored if set to value >=, if request exceeds the specified limit, the reader will return error,
3737
// by default buffer is not limited, negative values mean no limit
3838
func MaxBytes(m int64) optionSetter {
3939
return func(o *options) error {
@@ -46,7 +46,7 @@ func MaxBytes(m int64) optionSetter {
4646
func MemBytes(m int64) optionSetter {
4747
return func(o *options) error {
4848
if m < 0 {
49-
return fmt.Errorf("MemBytes should be >= 0")
49+
return fmt.Errorf("memBytes should be >= 0")
5050
}
5151
o.memBytes = m
5252
return nil

‎buffer_test.go

Lines changed: 90 additions & 96 deletions
Original file line numberDiff line numberDiff line change
@@ -9,15 +9,9 @@ import (
99
"os"
1010
"testing"
1111

12-
. "gopkg.in/check.v1"
12+
"github.com/stretchr/testify/assert"
1313
)
1414

15-
func Test(t *testing.T) { TestingT(t) }
16-
17-
type BufferSuite struct{}
18-
19-
var _ = Suite(&BufferSuite{})
20-
2115
func createReaderOfSize(size int64) (reader io.Reader, hash string) {
2216
f, err := os.Open("/dev/urandom")
2317
if err != nil {
@@ -44,232 +38,232 @@ func hashOfReader(r io.Reader) string {
4438
return hex.EncodeToString(h.Sum(nil))
4539
}
4640

47-
func (s *BufferSuite) TestSmallBuffer(c *C) {
41+
func TestSmallBuffer(t *testing.T) {
4842
r, hash := createReaderOfSize(1)
4943
bb, err := New(r)
50-
c.Assert(err, IsNil)
51-
c.Assert(hashOfReader(bb), Equals, hash)
44+
assert.NoError(t, err)
45+
assert.Equal(t, hash, hashOfReader(bb))
5246
bb.Close()
5347
}
5448

55-
func (s *BufferSuite) TestBigBuffer(c *C) {
49+
func TestBigBuffer(t *testing.T) {
5650
r, hash := createReaderOfSize(13631488)
5751
bb, err := New(r)
58-
c.Assert(err, IsNil)
59-
c.Assert(hashOfReader(bb), Equals, hash)
52+
assert.NoError(t, err)
53+
assert.Equal(t, hash, hashOfReader(bb))
6054
}
6155

62-
func (s *BufferSuite) TestSeek(c *C) {
56+
func TestSeek(t *testing.T) {
6357
tlen := int64(1057576)
6458
r, hash := createReaderOfSize(tlen)
6559
bb, err := New(r)
6660

67-
c.Assert(err, IsNil)
68-
c.Assert(hashOfReader(bb), Equals, hash)
61+
assert.NoError(t, err)
62+
assert.Equal(t, hash, hashOfReader(bb))
6963
l, err := bb.Size()
70-
c.Assert(err, IsNil)
71-
c.Assert(l, Equals, tlen)
64+
assert.NoError(t, err)
65+
assert.Equal(t, tlen, l)
7266

7367
bb.Seek(0, 0)
74-
c.Assert(hashOfReader(bb), Equals, hash)
68+
assert.Equal(t, hash, hashOfReader(bb))
7569
l, err = bb.Size()
76-
c.Assert(err, IsNil)
77-
c.Assert(l, Equals, tlen)
70+
assert.NoError(t, err)
71+
assert.Equal(t, tlen, l)
7872
}
7973

80-
func (s *BufferSuite) TestSeekWithFile(c *C) {
74+
func TestSeekWithFile(t *testing.T) {
8175
tlen := int64(DefaultMemBytes)
8276
r, hash := createReaderOfSize(tlen)
8377
bb, err := New(r, MemBytes(1))
8478

85-
c.Assert(err, IsNil)
86-
c.Assert(hashOfReader(bb), Equals, hash)
79+
assert.NoError(t, err)
80+
assert.Equal(t, hash, hashOfReader(bb))
8781
l, err := bb.Size()
88-
c.Assert(err, IsNil)
89-
c.Assert(l, Equals, tlen)
82+
assert.NoError(t, err)
83+
assert.Equal(t, tlen, l)
9084

9185
bb.Seek(0, 0)
92-
c.Assert(hashOfReader(bb), Equals, hash)
86+
assert.Equal(t, hash, hashOfReader(bb))
9387
l, err = bb.Size()
94-
c.Assert(err, IsNil)
95-
c.Assert(l, Equals, tlen)
88+
assert.NoError(t, err)
89+
assert.Equal(t, tlen, l)
9690
}
9791

98-
func (s *BufferSuite) TestSeekFirst(c *C) {
92+
func TestSeekFirst(t *testing.T) {
9993
tlen := int64(1057576)
10094
r, hash := createReaderOfSize(tlen)
10195
bb, err := New(r)
102-
c.Assert(err, IsNil)
96+
assert.NoError(t, err)
10397

10498
l, err := bb.Size()
105-
c.Assert(err, IsNil)
106-
c.Assert(l, Equals, tlen)
99+
assert.NoError(t, err)
100+
assert.Equal(t, tlen, l)
107101

108-
c.Assert(err, IsNil)
109-
c.Assert(hashOfReader(bb), Equals, hash)
102+
assert.NoError(t, err)
103+
assert.Equal(t, hash, hashOfReader(bb))
110104

111105
bb.Seek(0, 0)
112106

113-
c.Assert(hashOfReader(bb), Equals, hash)
107+
assert.Equal(t, hash, hashOfReader(bb))
114108
l, err = bb.Size()
115-
c.Assert(err, IsNil)
116-
c.Assert(l, Equals, tlen)
109+
assert.NoError(t, err)
110+
assert.Equal(t, tlen, l)
117111
}
118112

119-
func (s *BufferSuite) TestLimitDoesNotExceed(c *C) {
113+
func TestLimitDoesNotExceed(t *testing.T) {
120114
requestSize := int64(1057576)
121115
r, hash := createReaderOfSize(requestSize)
122116
bb, err := New(r, MemBytes(1024), MaxBytes(requestSize+1))
123-
c.Assert(err, IsNil)
124-
c.Assert(hashOfReader(bb), Equals, hash)
117+
assert.NoError(t, err)
118+
assert.Equal(t, hash, hashOfReader(bb))
125119
size, err := bb.Size()
126-
c.Assert(err, IsNil)
127-
c.Assert(size, Equals, requestSize)
120+
assert.NoError(t, err)
121+
assert.Equal(t, requestSize, size)
128122
bb.Close()
129123
}
130124

131-
func (s *BufferSuite) TestLimitExceeds(c *C) {
125+
func TestLimitExceeds(t *testing.T) {
132126
requestSize := int64(1057576)
133127
r, _ := createReaderOfSize(requestSize)
134128
bb, err := New(r, MemBytes(1024), MaxBytes(requestSize-1))
135-
c.Assert(err, FitsTypeOf, &MaxSizeReachedError{})
136-
c.Assert(bb, IsNil)
129+
assert.IsType(t, &MaxSizeReachedError{}, err)
130+
assert.Nil(t, bb)
137131
}
138132

139-
func (s *BufferSuite) TestLimitExceedsMemBytes(c *C) {
133+
func TestLimitExceedsMemBytes(t *testing.T) {
140134
requestSize := int64(1057576)
141135
r, _ := createReaderOfSize(requestSize)
142136
bb, err := New(r, MemBytes(requestSize+1), MaxBytes(requestSize-1))
143-
c.Assert(err, FitsTypeOf, &MaxSizeReachedError{})
144-
c.Assert(bb, IsNil)
137+
assert.IsType(t, &MaxSizeReachedError{}, err)
138+
assert.Nil(t, bb)
145139
}
146140

147-
func (s *BufferSuite) TestWriteToBigBuffer(c *C) {
141+
func TestWriteToBigBuffer(t *testing.T) {
148142
l := int64(13631488)
149143
r, hash := createReaderOfSize(l)
150144
bb, err := New(r)
151-
c.Assert(err, IsNil)
145+
assert.NoError(t, err)
152146

153147
other := &bytes.Buffer{}
154148
wrote, err := bb.WriteTo(other)
155-
c.Assert(err, IsNil)
156-
c.Assert(wrote, Equals, l)
157-
c.Assert(hashOfReader(other), Equals, hash)
149+
assert.NoError(t, err)
150+
assert.Equal(t, l, wrote)
151+
assert.Equal(t, hash, hashOfReader(other))
158152
}
159153

160-
func (s *BufferSuite) TestWriteToSmallBuffer(c *C) {
154+
func TestWriteToSmallBuffer(t *testing.T) {
161155
l := int64(1)
162156
r, hash := createReaderOfSize(l)
163157
bb, err := New(r)
164-
c.Assert(err, IsNil)
158+
assert.NoError(t, err)
165159

166160
other := &bytes.Buffer{}
167161
wrote, err := bb.WriteTo(other)
168-
c.Assert(err, IsNil)
169-
c.Assert(wrote, Equals, l)
170-
c.Assert(hashOfReader(other), Equals, hash)
162+
assert.NoError(t, err)
163+
assert.Equal(t, l, wrote)
164+
assert.Equal(t, hash, hashOfReader(other))
171165
}
172166

173-
func (s *BufferSuite) TestWriterOnceSmallBuffer(c *C) {
167+
func TestWriterOnceSmallBuffer(t *testing.T) {
174168
r, hash := createReaderOfSize(1)
175169

176170
w, err := NewWriterOnce()
177-
c.Assert(err, IsNil)
171+
assert.NoError(t, err)
178172

179173
total, err := io.Copy(w, r)
180-
c.Assert(err, Equals, nil)
181-
c.Assert(total, Equals, int64(1))
174+
assert.Equal(t, nil, err)
175+
assert.Equal(t, int64(1), total)
182176

183177
bb, err := w.Reader()
184-
c.Assert(err, IsNil)
178+
assert.NoError(t, err)
185179

186-
c.Assert(hashOfReader(bb), Equals, hash)
180+
assert.Equal(t, hash, hashOfReader(bb))
187181
bb.Close()
188182
}
189183

190-
func (s *BufferSuite) TestWriterOnceBigBuffer(c *C) {
184+
func TestWriterOnceBigBuffer(t *testing.T) {
191185
size := int64(13631488)
192186
r, hash := createReaderOfSize(size)
193187

194188
w, err := NewWriterOnce()
195-
c.Assert(err, IsNil)
189+
assert.NoError(t, err)
196190

197191
total, err := io.Copy(w, r)
198-
c.Assert(err, Equals, nil)
199-
c.Assert(total, Equals, size)
192+
assert.Equal(t, nil, err)
193+
assert.Equal(t, size, total)
200194

201195
bb, err := w.Reader()
202-
c.Assert(err, IsNil)
196+
assert.NoError(t, err)
203197

204-
c.Assert(hashOfReader(bb), Equals, hash)
198+
assert.Equal(t, hash, hashOfReader(bb))
205199
bb.Close()
206200
}
207201

208-
func (s *BufferSuite) TestWriterOncePartialWrites(c *C) {
202+
func TestWriterOncePartialWrites(t *testing.T) {
209203
size := int64(13631488)
210204
r, hash := createReaderOfSize(size)
211205

212206
w, err := NewWriterOnce()
213-
c.Assert(err, IsNil)
207+
assert.NoError(t, err)
214208

215209
total, err := io.CopyN(w, r, DefaultMemBytes+1)
216-
c.Assert(err, Equals, nil)
217-
c.Assert(total, Equals, int64(DefaultMemBytes+1))
210+
assert.Equal(t, nil, err)
211+
assert.Equal(t, int64(DefaultMemBytes+1), total)
218212

219213
remained := size - DefaultMemBytes - 1
220214
total, err = io.CopyN(w, r, remained)
221-
c.Assert(err, Equals, nil)
222-
c.Assert(int64(total), Equals, remained)
215+
assert.Equal(t, nil, err)
216+
assert.Equal(t, remained, total)
223217

224218
bb, err := w.Reader()
225-
c.Assert(err, IsNil)
226-
c.Assert(w.(*writerOnce).mem, IsNil)
227-
c.Assert(w.(*writerOnce).file, IsNil)
219+
assert.NoError(t, err)
220+
assert.Nil(t, w.(*writerOnce).mem)
221+
assert.Nil(t, w.(*writerOnce).file)
228222

229-
c.Assert(hashOfReader(bb), Equals, hash)
223+
assert.Equal(t, hash, hashOfReader(bb))
230224
bb.Close()
231225
}
232226

233-
func (s *BufferSuite) TestWriterOnceMaxSizeExceeded(c *C) {
227+
func TestWriterOnceMaxSizeExceeded(t *testing.T) {
234228
size := int64(1000)
235229
r, _ := createReaderOfSize(size)
236230

237231
w, err := NewWriterOnce(MemBytes(10), MaxBytes(100))
238-
c.Assert(err, IsNil)
232+
assert.NoError(t, err)
239233

240234
_, err = io.Copy(w, r)
241-
c.Assert(err, NotNil)
242-
c.Assert(w.Close(), IsNil)
235+
assert.Error(t, err)
236+
assert.NoError(t, w.Close())
243237
}
244238

245-
func (s *BufferSuite) TestWriterReaderCalled(c *C) {
239+
func TestWriterReaderCalled(t *testing.T) {
246240
size := int64(1000)
247241
r, hash := createReaderOfSize(size)
248242

249243
w, err := NewWriterOnce()
250-
c.Assert(err, IsNil)
244+
assert.NoError(t, err)
251245

252246
_, err = io.Copy(w, r)
253-
c.Assert(err, IsNil)
254-
c.Assert(w.Close(), IsNil)
247+
assert.NoError(t, err)
248+
assert.NoError(t, w.Close())
255249

256250
bb, err := w.Reader()
257-
c.Assert(err, IsNil)
251+
assert.NoError(t, err)
258252

259-
c.Assert(hashOfReader(bb), Equals, hash)
253+
assert.Equal(t, hash, hashOfReader(bb))
260254

261255
// Subsequent calls to write and get reader will fail
262256
_, err = w.Reader()
263-
c.Assert(err, NotNil)
257+
assert.Error(t, err)
264258

265259
_, err = w.Write([]byte{1})
266-
c.Assert(err, NotNil)
260+
assert.Error(t, err)
267261
}
268262

269-
func (s *BufferSuite) TestWriterNoData(c *C) {
263+
func TestWriterNoData(t *testing.T) {
270264
w, err := NewWriterOnce()
271-
c.Assert(err, IsNil)
265+
assert.NoError(t, err)
272266

273267
_, err = w.Reader()
274-
c.Assert(err, NotNil)
268+
assert.Error(t, err)
275269
}

‎go.mod

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
module github.com/mailgun/multibuf
2+
3+
go 1.17
4+
5+
require github.com/stretchr/testify v1.7.1
6+
7+
require (
8+
github.com/davecgh/go-spew v1.1.0 // indirect
9+
github.com/pmezard/go-difflib v1.0.0 // indirect
10+
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c // indirect
11+
)

‎go.sum

Lines changed: 11 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
2+
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
3+
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
4+
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
5+
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
6+
github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY=
7+
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
8+
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
9+
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
10+
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c h1:dUUwHk2QECo/6vqA44rthZ8ie2QXMNeKRTHCNY2nXvo=
11+
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=

0 commit comments

Comments
 (0)