add DoWithStringResponse function

Author: junedev

README.md

@@ -24,11 +24,19 @@ params := request.Params{
     Headers: map[string]string{"my-header":"value", "another-header":"value2"},
     Body:   Input{RequestValue: "someValueIn"},
     Query: map[string]string{"key": "value"},
+    Timeout: 10 * time.Second,
+    ExpectedResponseCode: 201,
 }
 
 result := &Output{}
 err := request.Do(params, result)
 ```
+All parameters besides the `URL` and the `Method` are optional and can be omitted.
+
+If you want to retrieve the response body as a string, e.g. for debugging or testing purposes, you can use `DoWithStringResponse` instead.
+```go
+result, err := request.DoWithStringResponse(params)
+```
 
 ## Convenience wrappers
 ```go
@@ -38,11 +46,11 @@ err := request.Post("http://example.com", Input{RequestValue: "someValueIn"}, re
 ```
 
 ## Defaults
-* All `2xx` response codes are treated as success, all other codes lead to an error being returned
+* All `2xx` response codes are treated as success, all other codes lead to an error being returned, if you want to check for a specific response code set `ExpectedResponseCode` in the parameters
 * If an HTTPError is returned it contains the response body as message if there was one
 * The request package takes care of closing the response body after sending the request
 * The http client does not follow redirects
-* The http client timeout is set to 30 seconds
+* The http client timeout is set to 30 seconds, use the `Timeout` parameter in case you want to define a different timeout for one of the requests
 * `Accept` and `Content-Type` request header are set to `application/json` and can be overwritten via the Headers parameter
 
 ## Streaming
@@ -98,7 +106,8 @@ if err != nil {
     return err
 }
 defer func() {
-    res.Body.Close()
+    err = res.Body.Close()
+    // handle err somehow
 }()
 
 result := &Output{}

go.sum

@@ -7,6 +7,7 @@ github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
 github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0 h1:4G4v2dO3VZwixGIRoQ5Lfboy6nUhCyYzaqnIAPPhYs4=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/testify v1.1.4/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
 github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=

request.go

@@ -3,6 +3,7 @@ package request
 import (
 	"bytes"
 	"encoding/json"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"net/http"
@@ -40,12 +41,13 @@ func GetClient() *http.Client {
 
 // Params holds all information necessary to set up the request instance.
 type Params struct {
-	Method  string
-	URL     string
-	Headers map[string]string
-	Body    interface{}
-	Query   map[string]string
-	Timeout time.Duration
+	URL                  string
+	Method               string
+	Headers              map[string]string
+	Body                 interface{}
+	Query                map[string]string
+	Timeout              time.Duration
+	ExpectedResponseCode int
 }
 
 // Do executes the request as specified in the request params
@@ -56,14 +58,7 @@ func Do(params Params, responseBody interface{}) (returnErr error) {
 		return err
 	}
 
-	var client *http.Client
-	if params.Timeout != 0 {
-		client = GetClient()
-		client.Timeout = params.Timeout
-	} else {
-		client = getCachedClient()
-	}
-
+	client := getClient(params.Timeout)
 	res, err := client.Do(req)
 	if err != nil {
 		return errors.Wrap(err, "failed to send request")
@@ -75,13 +70,9 @@ func Do(params Params, responseBody interface{}) (returnErr error) {
 		}
 	}()
 
-	if !isSuccessCode(res.StatusCode) {
-		bodyBytes, err := ioutil.ReadAll(res.Body)
-		if err != nil || len(bodyBytes) == 0 {
-			return httperrors.New(res.StatusCode, nil)
-		}
-
-		return httperrors.New(res.StatusCode, string(bodyBytes))
+	err = checkResponseCode(res, params.ExpectedResponseCode)
+	if err != nil {
+		return err
 	}
 
 	if responseBody == nil {
@@ -91,6 +82,39 @@ func Do(params Params, responseBody interface{}) (returnErr error) {
 	return json.NewDecoder(res.Body).Decode(responseBody)
 }
 
+// DoWithStringResponse is the same as Do but the response body is returned as string
+// instead of being parsed into the provided struct.
+func DoWithStringResponse(params Params) (result string, returnErr error) {
+	req, err := createRequest(params)
+	if err != nil {
+		return "", err
+	}
+
+	client := getClient(params.Timeout)
+	res, err := client.Do(req)
+	if err != nil {
+		return "", errors.Wrap(err, "failed to send request")
+	}
+
+	defer func() {
+		if cErr := res.Body.Close(); cErr != nil && returnErr == nil {
+			returnErr = cErr
+		}
+	}()
+
+	err = checkResponseCode(res, params.ExpectedResponseCode)
+	if err != nil {
+		return "", err
+	}
+
+	bodyBytes, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return "", fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	return string(bodyBytes), nil
+}
+
 func createRequest(params Params) (*http.Request, error) {
 	reader, err := convertToReader(params.Body)
 	if err != nil {
@@ -128,10 +152,6 @@ func Post(url string, requestBody interface{}, responseBody interface{}) error {
 	return Do(Params{Method: "POST", URL: url, Body: requestBody}, responseBody)
 }
 
-func isSuccessCode(statusCode int) bool {
-	return 200 <= statusCode && statusCode <= 299
-}
-
 func convertToReader(body interface{}) (io.Reader, error) {
 	if body == nil {
 		return nil, nil
@@ -150,3 +170,34 @@ func convertToReader(body interface{}) (io.Reader, error) {
 
 	return buffer, nil
 }
+
+func getClient(timeout time.Duration) *http.Client {
+	if timeout != 0 {
+		client = GetClient()
+		client.Timeout = timeout
+		return client
+	}
+
+	return getCachedClient()
+}
+
+func checkResponseCode(res *http.Response, expectedResponseCode int) error {
+	if expectedResponseCode != 0 && res.StatusCode != expectedResponseCode {
+		return fmt.Errorf("expected response code %d but got %d", expectedResponseCode, res.StatusCode)
+	}
+
+	if !isSuccessCode(res.StatusCode) {
+		bodyBytes, err := ioutil.ReadAll(res.Body)
+		if err != nil || len(bodyBytes) == 0 {
+			return httperrors.New(res.StatusCode, nil)
+		}
+
+		return httperrors.New(res.StatusCode, string(bodyBytes))
+	}
+
+	return nil
+}
+
+func isSuccessCode(statusCode int) bool {
+	return 200 <= statusCode && statusCode <= 299
+}

request_test.go

@@ -63,15 +63,17 @@ func TestDoSuccessful(t *testing.T) {
 			body, _ := ioutil.ReadAll(r.Body)
 			assert.Equal(t, `{"requestValue":"someValueIn"}`+"\n", string(body))
 			assert.Equal(t, r.Method, "POST")
+			w.WriteHeader(http.StatusCreated)
 			_, err := w.Write([]byte(`{"responseValue":"someValueOut"}`))
 			assert.NoError(t, err)
 		}))
 		defer ts.Close()
 
 		params := Params{
-			URL:    ts.URL,
-			Method: "POST",
-			Body:   Input{RequestValue: "someValueIn"},
+			URL:                  ts.URL,
+			Method:               "POST",
+			Body:                 Input{RequestValue: "someValueIn"},
+			ExpectedResponseCode: http.StatusCreated,
 		}
 
 		result := &Output{}
@@ -279,6 +281,41 @@ func TestDoOtherErrors(t *testing.T) {
 			assert.Contains(t, err.Error(), "failed to send request")
 		}
 	})
+
+	t.Run("wrong response code", func(t *testing.T) {
+		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			w.WriteHeader(http.StatusCreated)
+		}))
+		defer ts.Close()
+
+		params := Params{
+			URL:                  ts.URL,
+			ExpectedResponseCode: http.StatusOK,
+		}
+
+		err := Do(params, nil)
+		assert.Error(t, err)
+		assert.EqualError(t, err, "expected response code 200 but got 201")
+	})
+}
+
+func TestDoWithStringResponse(t *testing.T) {
+	t.Run("success", func(t *testing.T) {
+		response := `{"responseValue":"someValueOut"}`
+		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			_, err := w.Write([]byte(response))
+			assert.NoError(t, err)
+		}))
+		defer ts.Close()
+
+		params := Params{
+			URL: ts.URL,
+		}
+
+		result, err := DoWithStringResponse(params)
+		assert.NoError(t, err)
+		assert.Equal(t, response, result)
+	})
 }
 
 func TestGet(t *testing.T) {
@@ -337,3 +374,24 @@ func ExampleDo() {
 	//
 	// someValueOut <nil>
 }
+
+func ExampleDoWithStringResponse() {
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, err := w.Write([]byte(`{"responseValue":"someValueOut"}`))
+		if err != nil {
+			panic(err)
+		}
+	}))
+	defer ts.Close()
+
+	params := Params{
+		URL:    ts.URL,
+		Method: "POST",
+	}
+
+	result, err := DoWithStringResponse(params)
+
+	fmt.Println(result, err)
+	// Output:
+	// {"responseValue":"someValueOut"} <nil>
+}