github.com/onsi/gomega@v1.32.0/gbytes/io_wrappers_test.go (about)

     1  package gbytes_test
     2  
     3  import (
     4  	"fmt"
     5  	"io"
     6  	"time"
     7  
     8  	. "github.com/onsi/gomega/gbytes"
     9  
    10  	. "github.com/onsi/ginkgo/v2"
    11  	. "github.com/onsi/gomega"
    12  )
    13  
    14  type FakeCloser struct {
    15  	err      error
    16  	duration time.Duration
    17  }
    18  
    19  func (f FakeCloser) Close() error {
    20  	time.Sleep(f.duration)
    21  	return f.err
    22  }
    23  
    24  type FakeReader struct {
    25  	err      error
    26  	duration time.Duration
    27  }
    28  
    29  func (f FakeReader) Read(p []byte) (int, error) {
    30  	time.Sleep(f.duration)
    31  	if f.err != nil {
    32  		return 0, f.err
    33  	}
    34  
    35  	for i := 0; i < len(p); i++ {
    36  		p[i] = 'a'
    37  	}
    38  
    39  	return len(p), nil
    40  }
    41  
    42  type FakeWriter struct {
    43  	err      error
    44  	duration time.Duration
    45  }
    46  
    47  func (f FakeWriter) Write(p []byte) (int, error) {
    48  	time.Sleep(f.duration)
    49  	if f.err != nil {
    50  		return 0, f.err
    51  	}
    52  
    53  	return len(p), nil
    54  }
    55  
    56  var _ = Describe("Io Wrappers", func() {
    57  	Describe("TimeoutCloser", func() {
    58  		var innerCloser io.Closer
    59  		var timeoutCloser io.Closer
    60  
    61  		JustBeforeEach(func() {
    62  			timeoutCloser = TimeoutCloser(innerCloser, 20*time.Millisecond)
    63  		})
    64  
    65  		When("the underlying Closer closes with no error", func() {
    66  			BeforeEach(func() {
    67  				innerCloser = FakeCloser{}
    68  			})
    69  
    70  			It("returns with no error", func() {
    71  				Expect(timeoutCloser.Close()).Should(Succeed())
    72  			})
    73  		})
    74  
    75  		When("the underlying Closer closes with an error", func() {
    76  			BeforeEach(func() {
    77  				innerCloser = FakeCloser{err: fmt.Errorf("boom")}
    78  			})
    79  
    80  			It("returns the error", func() {
    81  				Expect(timeoutCloser.Close()).Should(MatchError("boom"))
    82  			})
    83  		})
    84  
    85  		When("the underlying Closer hangs", func() {
    86  			BeforeEach(func() {
    87  				innerCloser = FakeCloser{
    88  					err:      fmt.Errorf("boom"),
    89  					duration: time.Hour,
    90  				}
    91  			})
    92  
    93  			It("returns ErrTimeout", func() {
    94  				Expect(timeoutCloser.Close()).Should(MatchError(ErrTimeout))
    95  			})
    96  		})
    97  	})
    98  
    99  	Describe("TimeoutReader", func() {
   100  		var innerReader io.Reader
   101  		var timeoutReader io.Reader
   102  
   103  		JustBeforeEach(func() {
   104  			timeoutReader = TimeoutReader(innerReader, 20*time.Millisecond)
   105  		})
   106  
   107  		When("the underlying Reader returns no error", func() {
   108  			BeforeEach(func() {
   109  				innerReader = FakeReader{}
   110  			})
   111  
   112  			It("returns with no error", func() {
   113  				p := make([]byte, 5)
   114  				n, err := timeoutReader.Read(p)
   115  				Expect(n).Should(Equal(5))
   116  				Expect(err).ShouldNot(HaveOccurred())
   117  				Expect(p).Should(Equal([]byte("aaaaa")))
   118  			})
   119  		})
   120  
   121  		When("the underlying Reader returns an error", func() {
   122  			BeforeEach(func() {
   123  				innerReader = FakeReader{err: fmt.Errorf("boom")}
   124  			})
   125  
   126  			It("returns the error", func() {
   127  				p := make([]byte, 5)
   128  				_, err := timeoutReader.Read(p)
   129  				Expect(err).Should(MatchError("boom"))
   130  			})
   131  		})
   132  
   133  		When("the underlying Reader hangs", func() {
   134  			BeforeEach(func() {
   135  				innerReader = FakeReader{err: fmt.Errorf("boom"), duration: time.Hour}
   136  			})
   137  
   138  			It("returns ErrTimeout", func() {
   139  				p := make([]byte, 5)
   140  				_, err := timeoutReader.Read(p)
   141  				Expect(err).Should(MatchError(ErrTimeout))
   142  			})
   143  		})
   144  	})
   145  
   146  	Describe("TimeoutWriter", func() {
   147  		var innerWriter io.Writer
   148  		var timeoutWriter io.Writer
   149  
   150  		JustBeforeEach(func() {
   151  			timeoutWriter = TimeoutWriter(innerWriter, 20*time.Millisecond)
   152  		})
   153  
   154  		When("the underlying Writer returns no error", func() {
   155  			BeforeEach(func() {
   156  				innerWriter = FakeWriter{}
   157  			})
   158  
   159  			It("returns with no error", func() {
   160  				n, err := timeoutWriter.Write([]byte("aaaaa"))
   161  				Expect(n).Should(Equal(5))
   162  				Expect(err).ShouldNot(HaveOccurred())
   163  			})
   164  		})
   165  
   166  		When("the underlying Writer returns an error", func() {
   167  			BeforeEach(func() {
   168  				innerWriter = FakeWriter{err: fmt.Errorf("boom")}
   169  			})
   170  
   171  			It("returns the error", func() {
   172  				_, err := timeoutWriter.Write([]byte("aaaaa"))
   173  				Expect(err).Should(MatchError("boom"))
   174  			})
   175  		})
   176  
   177  		When("the underlying Writer hangs", func() {
   178  			BeforeEach(func() {
   179  				innerWriter = FakeWriter{err: fmt.Errorf("boom"), duration: time.Hour}
   180  			})
   181  
   182  			It("returns ErrTimeout", func() {
   183  				_, err := timeoutWriter.Write([]byte("aaaaa"))
   184  				Expect(err).Should(MatchError(ErrTimeout))
   185  			})
   186  		})
   187  	})
   188  })