diff options
Diffstat (limited to 'vendor/github.com/onsi/gomega/gbytes/io_wrappers_test.go')
-rw-r--r-- | vendor/github.com/onsi/gomega/gbytes/io_wrappers_test.go | 188 |
1 files changed, 188 insertions, 0 deletions
diff --git a/vendor/github.com/onsi/gomega/gbytes/io_wrappers_test.go b/vendor/github.com/onsi/gomega/gbytes/io_wrappers_test.go new file mode 100644 index 000000000..3da973498 --- /dev/null +++ b/vendor/github.com/onsi/gomega/gbytes/io_wrappers_test.go @@ -0,0 +1,188 @@ +package gbytes_test + +import ( + "fmt" + "io" + "time" + + . "github.com/onsi/gomega/gbytes" + + . "github.com/onsi/ginkgo" + . "github.com/onsi/gomega" +) + +type FakeCloser struct { + err error + duration time.Duration +} + +func (f FakeCloser) Close() error { + time.Sleep(f.duration) + return f.err +} + +type FakeReader struct { + err error + duration time.Duration +} + +func (f FakeReader) Read(p []byte) (int, error) { + time.Sleep(f.duration) + if f.err != nil { + return 0, f.err + } + + for i := 0; i < len(p); i++ { + p[i] = 'a' + } + + return len(p), nil +} + +type FakeWriter struct { + err error + duration time.Duration +} + +func (f FakeWriter) Write(p []byte) (int, error) { + time.Sleep(f.duration) + if f.err != nil { + return 0, f.err + } + + return len(p), nil +} + +var _ = Describe("Io Wrappers", func() { + Describe("TimeoutCloser", func() { + var innerCloser io.Closer + var timeoutCloser io.Closer + + JustBeforeEach(func() { + timeoutCloser = TimeoutCloser(innerCloser, 20*time.Millisecond) + }) + + Context("when the underlying Closer closes with no error", func() { + BeforeEach(func() { + innerCloser = FakeCloser{} + }) + + It("returns with no error", func() { + Expect(timeoutCloser.Close()).Should(Succeed()) + }) + }) + + Context("when the underlying Closer closes with an error", func() { + BeforeEach(func() { + innerCloser = FakeCloser{err: fmt.Errorf("boom")} + }) + + It("returns the error", func() { + Expect(timeoutCloser.Close()).Should(MatchError("boom")) + }) + }) + + Context("when the underlying Closer hangs", func() { + BeforeEach(func() { + innerCloser = FakeCloser{ + err: fmt.Errorf("boom"), + duration: time.Hour, + } + }) + + It("returns ErrTimeout", func() { + Expect(timeoutCloser.Close()).Should(MatchError(ErrTimeout)) + }) + }) + }) + + Describe("TimeoutReader", func() { + var innerReader io.Reader + var timeoutReader io.Reader + + JustBeforeEach(func() { + timeoutReader = TimeoutReader(innerReader, 20*time.Millisecond) + }) + + Context("when the underlying Reader returns no error", func() { + BeforeEach(func() { + innerReader = FakeReader{} + }) + + It("returns with no error", func() { + p := make([]byte, 5) + n, err := timeoutReader.Read(p) + Expect(n).Should(Equal(5)) + Expect(err).ShouldNot(HaveOccurred()) + Expect(p).Should(Equal([]byte("aaaaa"))) + }) + }) + + Context("when the underlying Reader returns an error", func() { + BeforeEach(func() { + innerReader = FakeReader{err: fmt.Errorf("boom")} + }) + + It("returns the error", func() { + p := make([]byte, 5) + _, err := timeoutReader.Read(p) + Expect(err).Should(MatchError("boom")) + }) + }) + + Context("when the underlying Reader hangs", func() { + BeforeEach(func() { + innerReader = FakeReader{err: fmt.Errorf("boom"), duration: time.Hour} + }) + + It("returns ErrTimeout", func() { + p := make([]byte, 5) + _, err := timeoutReader.Read(p) + Expect(err).Should(MatchError(ErrTimeout)) + }) + }) + }) + + Describe("TimeoutWriter", func() { + var innerWriter io.Writer + var timeoutWriter io.Writer + + JustBeforeEach(func() { + timeoutWriter = TimeoutWriter(innerWriter, 20*time.Millisecond) + }) + + Context("when the underlying Writer returns no error", func() { + BeforeEach(func() { + innerWriter = FakeWriter{} + }) + + It("returns with no error", func() { + n, err := timeoutWriter.Write([]byte("aaaaa")) + Expect(n).Should(Equal(5)) + Expect(err).ShouldNot(HaveOccurred()) + }) + }) + + Context("when the underlying Writer returns an error", func() { + BeforeEach(func() { + innerWriter = FakeWriter{err: fmt.Errorf("boom")} + }) + + It("returns the error", func() { + _, err := timeoutWriter.Write([]byte("aaaaa")) + Expect(err).Should(MatchError("boom")) + }) + }) + + Context("when the underlying Writer hangs", func() { + BeforeEach(func() { + innerWriter = FakeWriter{err: fmt.Errorf("boom"), duration: time.Hour} + }) + + It("returns ErrTimeout", func() { + _, err := timeoutWriter.Write([]byte("aaaaa")) + Expect(err).Should(MatchError(ErrTimeout)) + }) + }) + }) +}) |