Merge pull request #4 from fastbill/string-response-and-expected-status

add DoWithStringResponse function and ExpectedResponseCode parameter

Author: junedev

.golangci.yml

@@ -11,15 +11,28 @@ linters:
 
 run:
   deadline: 10m
+  modules-download-mode: vendor
 
 issues:
+  exclude-use-default: false
   exclude-rules:
     - path: _test\.go
       linters:
         - dupl
         - goconst
         - gosec
+    - linters:
+        - govet
+      text: 'shadow: declaration of "err" shadows declaration'
+    - linters:
+        - golint
+      text: 'in another file for this package'
 
 linters-settings:
   gocyclo:
     min-complexity: 10
+  golint:
+    min-confidence: 0
+  govet:
+    check-shadowing: true
+

README.md

@@ -8,7 +8,10 @@ If the request could be made but the response status code was not `2xx` an error
 
 ## Example
 ```go
-import "github.com/fastbill/go-request/v2"
+import (
+    "net/http"
+    "github.com/fastbill/go-request/v2"
+)
 
 type Input struct {
 	RequestValue string `json:"requestValue"`
@@ -20,15 +23,23 @@ type Output struct {
 
 params := request.Params{
     URL:    "https://example.com",
-    Method: "POST",
+    Method: http.MethodPost,
     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 +49,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
@@ -72,7 +83,7 @@ if err != nil {
     return err
 }
 
-req, err := http.NewRequest("POST", url, buf)
+req, err := http.NewRequest(http.MethodPost, url, buf)
 if err != nil {
     return err
 }
@@ -98,7 +109,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"
@@ -12,20 +13,20 @@ import (
 	"github.com/pkg/errors"
 )
 
-// client is the global client instance.
-var client *http.Client
+// cachedClient is the global client instance.
+var cachedClient *http.Client
 
 // defaultTimeout is the timeout applied if there is none provided.
 var defaultTimeout = 30 * time.Second
 
 // getCachedClient returns the client instance or creates it if it did not exist.
 // The client does not follow redirects and has a timeout of defaultTimeout.
 func getCachedClient() *http.Client {
-	if client == nil {
-		client = GetClient()
+	if cachedClient == nil {
+		cachedClient = GetClient()
 	}
 
-	return client
+	return cachedClient
 }
 
 // GetClient returns an http client that does not follow redirects and has a timeout of defaultTimeout.
@@ -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 := selectClient(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 := selectClient(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 {
@@ -120,16 +144,12 @@ func createRequest(params Params) (*http.Request, error) {
 
 // Get is a convience wrapper for "Do" to execute GET requests
 func Get(url string, responseBody interface{}) error {
-	return Do(Params{Method: "GET", URL: url}, responseBody)
+	return Do(Params{Method: http.MethodGet, URL: url}, responseBody)
 }
 
 // Post is a convience wrapper for "Do" to execute POST requests
 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
+	return Do(Params{Method: http.MethodPost, URL: url, Body: requestBody}, responseBody)
 }
 
 func convertToReader(body interface{}) (io.Reader, error) {
@@ -150,3 +170,34 @@ func convertToReader(body interface{}) (io.Reader, error) {
 
 	return buffer, nil
 }
+
+func selectClient(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
+}