Skip to content

Commit 5c80c3f

Browse files
vdemeestervdemeester
committed
Update httputils tests
- Make sure we use httptest instead of depending on network - Update resumablerequestreader tests Signed-off-by: Vincent Demeester <[email protected]>
1 parent 8562c42 commit 5c80c3f

File tree

2 files changed

+273
-9
lines changed

2 files changed

+273
-9
lines changed

‎pkg/httputils/httputils_test.go‎

Lines changed: 49 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,25 +1,65 @@
11
package httputils
22

3-
import "testing"
3+
import (
4+
"fmt"
5+
"io/ioutil"
6+
"net/http"
7+
"net/http/httptest"
8+
"strings"
9+
"testing"
10+
)
411

512
func TestDownload(t *testing.T) {
6-
_, err := Download("http://docker.com")
7-
13+
expected := "Hello, docker !"
14+
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
15+
fmt.Fprintf(w, expected)
16+
}))
17+
defer ts.Close()
18+
response, err := Download(ts.URL)
819
if err != nil {
9-
t.Fatalf("Expected error to not exist when Download(http://docker.com)")
20+
t.Fatal(err)
21+
}
22+
23+
actual, err := ioutil.ReadAll(response.Body)
24+
response.Body.Close()
25+
26+
if err != nil || string(actual) != expected {
27+
t.Fatalf("Expected the response %q, got err:%v, response:%v, actual:%s", expected, err, response, string(actual))
28+
}
29+
}
30+
31+
func TestDownload400Errors(t *testing.T) {
32+
expectedError := "Got HTTP status code >= 400: 403 Forbidden"
33+
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
34+
// 403
35+
http.Error(w, "something failed (forbidden)", http.StatusForbidden)
36+
}))
37+
defer ts.Close()
38+
// Expected status code = 403
39+
if _, err := Download(ts.URL); err == nil || err.Error() != expectedError {
40+
t.Fatalf("Expected the the error %q, got %v", expectedError, err)
1041
}
42+
}
1143

12-
// Expected status code = 404
13-
if _, err = Download("http://docker.com/abc1234567"); err == nil {
14-
t.Fatalf("Expected error to exist when Download(http://docker.com/abc1234567)")
44+
func TestDownloadOtherErrors(t *testing.T) {
45+
if _, err := Download("I'm not an url.."); err == nil || !strings.Contains(err.Error(), "unsupported protocol scheme") {
46+
t.Fatalf("Expected an error with 'unsupported protocol scheme', got %v", err)
1547
}
1648
}
1749

1850
func TestNewHTTPRequestError(t *testing.T) {
1951
errorMessage := "Some error message"
20-
httpResponse, _ := Download("http://docker.com")
52+
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
53+
// 403
54+
http.Error(w, errorMessage, http.StatusForbidden)
55+
}))
56+
defer ts.Close()
57+
httpResponse, err := http.Get(ts.URL)
58+
if err != nil {
59+
t.Fatal(err)
60+
}
2161
if err := NewHTTPRequestError(errorMessage, httpResponse); err.Error() != errorMessage {
22-
t.Fatalf("Expected err to equal error Message")
62+
t.Fatalf("Expected err to be %q, got %v", errorMessage, err)
2363
}
2464
}
2565

‎pkg/httputils/resumablerequestreader_test.go‎

Lines changed: 224 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2,13 +2,237 @@ package httputils
22

33
import (
44
"fmt"
5+
"io"
56
"io/ioutil"
67
"net/http"
78
"net/http/httptest"
89
"strings"
910
"testing"
1011
)
1112

13+
func TestResumableRequestHeaderSimpleErrors(t *testing.T) {
14+
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
15+
fmt.Fprintln(w, "Hello, world !")
16+
}))
17+
defer ts.Close()
18+
19+
client := &http.Client{}
20+
21+
var req *http.Request
22+
req, err := http.NewRequest("GET", ts.URL, nil)
23+
if err != nil {
24+
t.Fatal(err)
25+
}
26+
27+
expectedError := "client and request can't be nil\n"
28+
resreq := &resumableRequestReader{}
29+
_, err = resreq.Read([]byte{})
30+
if err == nil || err.Error() != expectedError {
31+
t.Fatalf("Expected an error with '%s', got %v.", expectedError, err)
32+
}
33+
34+
resreq = &resumableRequestReader{
35+
client: client,
36+
request: req,
37+
totalSize: -1,
38+
}
39+
expectedError = "failed to auto detect content length"
40+
_, err = resreq.Read([]byte{})
41+
if err == nil || err.Error() != expectedError {
42+
t.Fatalf("Expected an error with '%s', got %v.", expectedError, err)
43+
}
44+
45+
}
46+
47+
// Not too much failures, bails out after some wait
48+
func TestResumableRequestHeaderNotTooMuchFailures(t *testing.T) {
49+
client := &http.Client{}
50+
51+
var badReq *http.Request
52+
badReq, err := http.NewRequest("GET", "I'm not an url", nil)
53+
if err != nil {
54+
t.Fatal(err)
55+
}
56+
57+
resreq := &resumableRequestReader{
58+
client: client,
59+
request: badReq,
60+
failures: 0,
61+
maxFailures: 2,
62+
}
63+
read, err := resreq.Read([]byte{})
64+
if err != nil || read != 0 {
65+
t.Fatalf("Expected no error and no byte read, got err:%v, read:%v.", err, read)
66+
}
67+
}
68+
69+
// Too much failures, returns the error
70+
func TestResumableRequestHeaderTooMuchFailures(t *testing.T) {
71+
client := &http.Client{}
72+
73+
var badReq *http.Request
74+
badReq, err := http.NewRequest("GET", "I'm not an url", nil)
75+
if err != nil {
76+
t.Fatal(err)
77+
}
78+
79+
resreq := &resumableRequestReader{
80+
client: client,
81+
request: badReq,
82+
failures: 0,
83+
maxFailures: 1,
84+
}
85+
defer resreq.Close()
86+
87+
expectedError := `Get I%27m%20not%20an%20url: unsupported protocol scheme ""`
88+
read, err := resreq.Read([]byte{})
89+
if err == nil || err.Error() != expectedError || read != 0 {
90+
t.Fatalf("Expected the error '%s', got err:%v, read:%v.", expectedError, err, read)
91+
}
92+
}
93+
94+
type errorReaderCloser struct{}
95+
96+
func (errorReaderCloser) Close() error { return nil }
97+
98+
func (errorReaderCloser) Read(p []byte) (n int, err error) {
99+
return 0, fmt.Errorf("A error occured")
100+
}
101+
102+
// If a an unknown error is encountered, return 0, nil and log it
103+
func TestResumableRequestReaderWithReadError(t *testing.T) {
104+
var req *http.Request
105+
req, err := http.NewRequest("GET", "", nil)
106+
if err != nil {
107+
t.Fatal(err)
108+
}
109+
110+
client := &http.Client{}
111+
112+
response := &http.Response{
113+
Status: "500 Internal Server",
114+
StatusCode: 500,
115+
ContentLength: 0,
116+
Close: true,
117+
Body: errorReaderCloser{},
118+
}
119+
120+
resreq := &resumableRequestReader{
121+
client: client,
122+
request: req,
123+
currentResponse: response,
124+
lastRange: 1,
125+
totalSize: 1,
126+
}
127+
defer resreq.Close()
128+
129+
buf := make([]byte, 1)
130+
read, err := resreq.Read(buf)
131+
if err != nil {
132+
t.Fatal(err)
133+
}
134+
135+
if read != 0 {
136+
t.Fatalf("Expected to have read nothing, but read %v", read)
137+
}
138+
}
139+
140+
func TestResumableRequestReaderWithEOFWith416Response(t *testing.T) {
141+
var req *http.Request
142+
req, err := http.NewRequest("GET", "", nil)
143+
if err != nil {
144+
t.Fatal(err)
145+
}
146+
147+
client := &http.Client{}
148+
149+
response := &http.Response{
150+
Status: "416 Requested Range Not Satisfiable",
151+
StatusCode: 416,
152+
ContentLength: 0,
153+
Close: true,
154+
Body: ioutil.NopCloser(strings.NewReader("")),
155+
}
156+
157+
resreq := &resumableRequestReader{
158+
client: client,
159+
request: req,
160+
currentResponse: response,
161+
lastRange: 1,
162+
totalSize: 1,
163+
}
164+
defer resreq.Close()
165+
166+
buf := make([]byte, 1)
167+
_, err = resreq.Read(buf)
168+
if err == nil || err != io.EOF {
169+
t.Fatalf("Expected an io.EOF error, got %v", err)
170+
}
171+
}
172+
173+
func TestResumableRequestReaderWithServerDoesntSupportByteRanges(t *testing.T) {
174+
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
175+
if r.Header.Get("Range") == "" {
176+
t.Fatalf("Expected a Range HTTP header, got nothing")
177+
}
178+
}))
179+
defer ts.Close()
180+
181+
var req *http.Request
182+
req, err := http.NewRequest("GET", ts.URL, nil)
183+
if err != nil {
184+
t.Fatal(err)
185+
}
186+
187+
client := &http.Client{}
188+
189+
resreq := &resumableRequestReader{
190+
client: client,
191+
request: req,
192+
lastRange: 1,
193+
}
194+
defer resreq.Close()
195+
196+
buf := make([]byte, 2)
197+
_, err = resreq.Read(buf)
198+
if err == nil || err.Error() != "the server doesn't support byte ranges" {
199+
t.Fatalf("Expected an error 'the server doesn't support byte ranges', got %v", err)
200+
}
201+
}
202+
203+
func TestResumableRequestReaderWithZeroTotalSize(t *testing.T) {
204+
205+
srvtxt := "some response text data"
206+
207+
ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
208+
fmt.Fprintln(w, srvtxt)
209+
}))
210+
defer ts.Close()
211+
212+
var req *http.Request
213+
req, err := http.NewRequest("GET", ts.URL, nil)
214+
if err != nil {
215+
t.Fatal(err)
216+
}
217+
218+
client := &http.Client{}
219+
retries := uint32(5)
220+
221+
resreq := ResumableRequestReader(client, req, retries, 0)
222+
defer resreq.Close()
223+
224+
data, err := ioutil.ReadAll(resreq)
225+
if err != nil {
226+
t.Fatal(err)
227+
}
228+
229+
resstr := strings.TrimSuffix(string(data), "\n")
230+
231+
if resstr != srvtxt {
232+
t.Errorf("resstr != srvtxt")
233+
}
234+
}
235+
12236
func TestResumableRequestReader(t *testing.T) {
13237

14238
srvtxt := "some response text data"

0 commit comments

Comments
 (0)