1. docker
  2. Commit 815b472a02dc0f593daee4006ce893fe17236b70
Browse code

Add more ioutils tests.

Closes #11595

Signed-off-by: Vincent Demeester <vincent@sbr.pm>

Vincent Demeester authored on 2015/05/05 02:56:10
Showing 2 changed files
pkg/ioutils/readers_test.go
History View file @ 815b472
... ... 
@@ -2,11 +2,92 @@ package ioutils
2 2
3 3 
 import (
4 4 
 	"bytes"
5 
+	"fmt"
5 6 
 	"io"
6 7 
 	"io/ioutil"
8 
+	"strings"
7 9 
 	"testing"
8 10 
 )
9 11
12 
+// Implement io.Reader
13 
+type errorReader struct{}
14 
+
15 
+func (r *errorReader) Read(p []byte) (int, error) {
16 
+	return 0, fmt.Errorf("Error reader always fail.")
17 
+}
18 
+
19 
+func TestReadCloserWrapperClose(t *testing.T) {
20 
+	reader := strings.NewReader("A string reader")
21 
+	wrapper := NewReadCloserWrapper(reader, func() error {
22 
+		return fmt.Errorf("This will be called when closing")
23 
+	})
24 
+	err := wrapper.Close()
25 
+	if err == nil || !strings.Contains(err.Error(), "This will be called when closing") {
26 
+		t.Fatalf("readCloserWrapper should have call the anonymous func and thus, fail.")
27 
+	}
28 
+}
29 
+
30 
+func TestReaderErrWrapperReadOnError(t *testing.T) {
31 
+	called := false
32 
+	reader := &errorReader{}
33 
+	wrapper := NewReaderErrWrapper(reader, func() {
34 
+		called = true
35 
+	})
36 
+	_, err := wrapper.Read([]byte{})
37 
+	if err == nil || !strings.Contains(err.Error(), "Error reader always fail.") {
38 
+		t.Fatalf("readErrWrapper should returned an error")
39 
+	}
40 
+	if !called {
41 
+		t.Fatalf("readErrWrapper should have call the anonymous function on failure")
42 
+	}
43 
+}
44 
+
45 
+func TestReaderErrWrapperRead(t *testing.T) {
46 
+	called := false
47 
+	reader := strings.NewReader("a string reader.")
48 
+	wrapper := NewReaderErrWrapper(reader, func() {
49 
+		called = true // Should not be called
50 
+	})
51 
+	// Read 20 byte (should be ok with the string above)
52 
+	num, err := wrapper.Read(make([]byte, 20))
53 
+	if err != nil {
54 
+		t.Fatal(err)
55 
+	}
56 
+	if num != 16 {
57 
+		t.Fatalf("readerErrWrapper should have read 16 byte, but read %d", num)
58 
+	}
59 
+}
60 
+
61 
+func TestNewBufReaderWithDrainbufAndBuffer(t *testing.T) {
62 
+	reader, writer := io.Pipe()
63 
+
64 
+	drainBuffer := make([]byte, 1024)
65 
+	buffer := bytes.Buffer{}
66 
+	bufreader := NewBufReaderWithDrainbufAndBuffer(reader, drainBuffer, &buffer)
67 
+
68 
+	// Write everything down to a Pipe
69 
+	// Usually, a pipe should block but because of the buffered reader,
70 
+	// the writes will go through
71 
+	done := make(chan bool)
72 
+	go func() {
73 
+		writer.Write([]byte("hello world"))
74 
+		writer.Close()
75 
+		done <- true
76 
+	}()
77 
+
78 
+	// Drain the reader *after* everything has been written, just to verify
79 
+	// it is indeed buffering
80 
+	<-done
81 
+
82 
+	output, err := ioutil.ReadAll(bufreader)
83 
+	if err != nil {
84 
+		t.Fatal(err)
85 
+	}
86 
+	if !bytes.Equal(output, []byte("hello world")) {
87 
+		t.Error(string(output))
88 
+	}
89 
+}
90 
+
10 91 
 func TestBufReader(t *testing.T) {
11 92 
 	reader, writer := io.Pipe()
12 93 
 	bufreader := NewBufReader(reader)
... ... 
@@ -33,6 +114,50 @@ func TestBufReader(t *testing.T) {
33 33 
 	}
34 34 
 }
35 35
36 
+func TestBufReaderCloseWithNonReaderCloser(t *testing.T) {
37 
+	reader := strings.NewReader("buffer")
38 
+	bufreader := NewBufReader(reader)
39 
+
40 
+	if err := bufreader.Close(); err != nil {
41 
+		t.Fatal(err)
42 
+	}
43 
+
44 
+}
45 
+
46 
+// implements io.ReadCloser
47 
+type simpleReaderCloser struct{}
48 
+
49 
+func (r *simpleReaderCloser) Read(p []byte) (n int, err error) {
50 
+	return 0, nil
51 
+}
52 
+
53 
+func (r *simpleReaderCloser) Close() error {
54 
+	return nil
55 
+}
56 
+
57 
+func TestBufReaderCloseWithReaderCloser(t *testing.T) {
58 
+	reader := &simpleReaderCloser{}
59 
+	bufreader := NewBufReader(reader)
60 
+
61 
+	err := bufreader.Close()
62 
+	if err != nil {
63 
+		t.Fatal(err)
64 
+	}
65 
+
66 
+}
67 
+
68 
+func TestHashData(t *testing.T) {
69 
+	reader := strings.NewReader("hash-me")
70 
+	actual, err := HashData(reader)
71 
+	if err != nil {
72 
+		t.Fatal(err)
73 
+	}
74 
+	expected := "sha256:4d11186aed035cc624d553e10db358492c84a7cd6b9670d92123c144930450aa"
75 
+	if actual != expected {
76 
+		t.Fatalf("Expecting %s, got %s", expected, actual)
77 
+	}
78 
+}
79 
+
36 80 
 type repeatedReader struct {
37 81 
 	readCount int
38 82 
 	maxReads  int
pkg/ioutils/writers_test.go
History View file @ 815b472
... ... 
@@ -6,6 +6,30 @@ import (
6 6 
 	"testing"
7 7 
 )
8 8
9 
+func TestWriteCloserWrapperClose(t *testing.T) {
10 
+	called := false
11 
+	writer := bytes.NewBuffer([]byte{})
12 
+	wrapper := NewWriteCloserWrapper(writer, func() error {
13 
+		called = true
14 
+		return nil
15 
+	})
16 
+	if err := wrapper.Close(); err != nil {
17 
+		t.Fatal(err)
18 
+	}
19 
+	if !called {
20 
+		t.Fatalf("writeCloserWrapper should have call the anonymous function.")
21 
+	}
22 
+}
23 
+
24 
+func TestNopWriteCloser(t *testing.T) {
25 
+	writer := bytes.NewBuffer([]byte{})
26 
+	wrapper := NopWriteCloser(writer)
27 
+	if err := wrapper.Close(); err != nil {
28 
+		t.Fatal("NopWriteCloser always return nil on Close.")
29 
+	}
30 
+
31 
+}
32 
+
9 33 
 func TestNopWriter(t *testing.T) {
10 34 
 	nw := &NopWriter{}
11 35 
 	l, err := nw.Write([]byte{'c'})