Isolate: Use generators instead of seekers

client/internal/lhttp/client_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package lhttp
 
 import (
         "bytes"
         "encoding/json"
         "errors"
         "fmt"
         "io"
         "io/ioutil"
         "net/http"
         "net/http/httptest"
         "testing"
         "time"
 
         "github.com/luci/luci-go/client/internal/retry"
         "github.com/maruel/ut"
 )
 
+func httpReqGen(method, url string, body []byte) RequestGen {
+        return func() (*http.Request, error) {
+                var bodyReader io.Reader
+                if body != nil {
+                        bodyReader = bytes.NewReader(body)
+                }
+                return http.NewRequest("GET", url, bodyReader)
+        }
+}
+
 func TestNewRequestGET(t *testing.T) {
         // First call returns HTTP 500, second succeeds.
         serverCalls := 0
         ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
                 serverCalls++
                 content, err := ioutil.ReadAll(r.Body)
                 ut.ExpectEqual(t, nil, err)
                 ut.ExpectEqual(t, []byte{}, content)
                 if serverCalls == 1 {
                         w.WriteHeader(500)
                 } else {
                         fmt.Fprintf(w, "Hello, client\n")
                 }
         }))
         defer ts.Close()
 
-        httpReq, err := http.NewRequest("GET", ts.URL, nil)
-        ut.AssertEqual(t, nil, err)
+        httpReq := httpReqGen("GET", ts.URL, nil)
 
         clientCalls := 0
-        clientReq, err := NewRequest(http.DefaultClient, httpReq, func(resp *http.Response) error {
+        clientReq := NewRequest(http.DefaultClient, httpReq, func(resp *http.Response) error {
                 clientCalls++
                 content, err := ioutil.ReadAll(resp.Body)
                 ut.AssertEqual(t, nil, err)
                 ut.AssertEqual(t, "Hello, client\n", string(content))
                 ut.AssertEqual(t, nil, resp.Body.Close())
                 return nil
         })
-        ut.AssertEqual(t, nil, err)
 
         ut.AssertEqual(t, nil, fast.Do(clientReq))
         ut.AssertEqual(t, 200, clientReq.Status())
         ut.AssertEqual(t, 2, serverCalls)
         ut.AssertEqual(t, 1, clientCalls)
 }
 
 func TestNewRequestPOST(t *testing.T) {
         // First call returns HTTP 500, second succeeds.
         serverCalls := 0
         ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
                 serverCalls++
                 content, err := ioutil.ReadAll(r.Body)
                 ut.ExpectEqual(t, nil, err)
                 // The same data is sent twice.
                 ut.ExpectEqual(t, "foo bar", string(content))
                 if serverCalls == 1 {
                         w.WriteHeader(500)
                 } else {
                         fmt.Fprintf(w, "Hello, client\n")
                 }
         }))
         defer ts.Close()
 
-        httpReq, err := http.NewRequest("POST", ts.URL, newReader([]byte("foo bar")))
-        ut.AssertEqual(t, nil, err)
+        httpReq := httpReqGen("POST", ts.URL, []byte("foo bar"))
 
         clientCalls := 0
-        clientReq, err := NewRequest(http.DefaultClient, httpReq, func(resp *http.Response) error {
+        clientReq := NewRequest(http.DefaultClient, httpReq, func(resp *http.Response) error {
                 clientCalls++
                 content, err := ioutil.ReadAll(resp.Body)
                 ut.AssertEqual(t, nil, err)
                 ut.AssertEqual(t, "Hello, client\n", string(content))
                 ut.AssertEqual(t, nil, resp.Body.Close())
                 return nil
         })
-        ut.AssertEqual(t, nil, err)
 
         ut.AssertEqual(t, nil, fast.Do(clientReq))
         ut.AssertEqual(t, 200, clientReq.Status())
         ut.AssertEqual(t, 2, serverCalls)
         ut.AssertEqual(t, 1, clientCalls)
 }
 
-func TestNewRequestNotSeeker(t *testing.T) {
-        // bytes.NewReader() doesn't implement io.Seeker.
-        ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-                t.Fail()
-        }))
-        defer ts.Close()
-        httpReq, err := http.NewRequest("POST", ts.URL, bytes.NewReader([]byte("foo bar")))
-        ut.AssertEqual(t, nil, err)
-
-        clientReq, err := NewRequest(http.DefaultClient, httpReq, func(resp *http.Response) error {
-                t.Fail()
-                return nil
-        })
-
-        ut.AssertEqual(t, nil, clientReq)
-        ut.AssertEqual(t, errors.New("req.Body must implement io.Seeker"), err)
-}
-
-func TestNewRequestBadURL(t *testing.T) {
-        httpReq, err := http.NewRequest("GET", "invalid url", nil)
-        ut.AssertEqual(t, nil, err)
-
-        clientReq, err := NewRequest(http.DefaultClient, httpReq, func(resp *http.Response) error {
-                t.Fail()
-                return nil
-        })
-        ut.AssertEqual(t, errors.New("unsupported protocol scheme \"\""), err)
-        ut.AssertEqual(t, nil, clientReq)
-}
-
 func TestNewRequestGETFail(t *testing.T) {
         serverCalls := 0
         ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
                 serverCalls++
                 w.WriteHeader(500)
         }))
         defer ts.Close()
 
-        httpReq, err := http.NewRequest("GET", ts.URL, nil)
-        ut.AssertEqual(t, nil, err)
+        httpReq := httpReqGen("GET", ts.URL, nil)
 
-        clientReq, err := NewRequest(http.DefaultClient, httpReq, func(resp *http.Response) error {
+        clientReq := NewRequest(http.DefaultClient, httpReq, func(resp *http.Response) error {
                 t.Fail()
                 return nil
         })
 
         ut.AssertEqual(t, retry.Error{errors.New("http request failed: Internal Server Error (HTTP 500)")}, fast.Do(clientReq))
         ut.AssertEqual(t, 500, clientReq.Status())
         ut.AssertEqual(t, fast.MaxTries, serverCalls)
 }
 
-func TestNewRequestJSONBadURL(t *testing.T) {
-        clientReq, err := NewRequestJSON(http.DefaultClient, "GET", "invalid url", nil, nil, nil)
-        if err == nil {
-                t.Fatalf("NewRequestJSON should have failed, but it didn't")
-        }
-        ut.AssertEqual(t, nil, clientReq)
-}
-
 func TestGetJSON(t *testing.T) {
         // First call returns HTTP 500, second succeeds.
         serverCalls := 0
         ts := httptest.NewServer(handlerJSON(t, func(body io.Reader) interface{} {
                 serverCalls++
                 content, err := ioutil.ReadAll(body)
                 ut.ExpectEqual(t, nil, err)
                 ut.ExpectEqual(t, []byte{}, content)
                 if serverCalls == 1 {
                         return nil
@@ skipping 121 matching lines @@
                 defer r.Body.Close()
                 out := handler(r.Body)
                 if out == nil {
                         w.WriteHeader(500)
                 } else {
                         w.Header().Set("Content-Type", jsonContentType)
                         ut.ExpectEqual(t, nil, json.NewEncoder(w).Encode(out))
                 }
         })
 }