transfer and adapt code from internal repo

Author: junedev

.gitignore

@@ -0,0 +1,18 @@
+# Binaries for programs and plugins
+*.exe
+*.exe~
+*.dll
+*.so
+*.dylib
+
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# External dependencies
+vendor
+
+# Debugger files
+debug

.travis.yml

@@ -0,0 +1,17 @@
+language: go
+
+go:
+  - 1.11.x
+
+before_install:
+  - go get -u github.com/golang/dep/cmd/dep
+  - dep ensure
+  - go get -u gopkg.in/alecthomas/gometalinter.v2
+  - gometalinter.v2 --install
+
+script:
+  - go test -race -cover ./...
+  - gometalinter.v2 --vendor --deadline=300s ./...
+
+notifications:
+  email: false

Gopkg.lock

@@ -0,0 +1,15 @@
+# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
+# for detailed Gopkg.toml documentation.
+
+[[constraint]]
+  name = "github.com/fastbill/go-httperrors"
+  version = "^1.0.0"
+  source = "[email protected]:fastbill/go-httperrors.git"
+
+[[constraint]]
+  name = "github.com/pkg/errors"
+  version = "^0.8.0"
+
+[[constraint]]
+  name = "github.com/stretchr/testify"
+  version = "^1.3.0"

Gopkg.toml

@@ -1,2 +1,50 @@
-# go-request
-Simple but opinionated HTTP request client for Go
+# Request [![Build Status](https://travis-ci.com/fastbill/go-request.svg?branch=master)](https://travis-ci.com/fastbill/go-request) [![Go Report Card](https://goreportcard.com/badge/github.com/fastbill/go-request)](https://goreportcard.com/report/github.com/fastbill/go-request) [![GoDoc](https://godoc.org/github.com/fastbill/go-request?status.svg)](https://godoc.org/github.com/fastbill/go-request)
+
+> An opinionated but extremely easy to use HTTP request client for Go to make JSON request and retrieve the results
+
+## Description
+With this request package you just need to define the structs that correspond to the JSON request and response body. Together with the parameters like URL, method and headers you can directly execute a request with `Do`. If the request body is not of type `io.Reader` already it will be encoded as JSON. Also the response will be decoded back into the struct you provided for the result. Request and reponse body are optional which means they can be `nil`.  
+If the request could be made but the response status code was not `2xx` an error of the type `HTTPError` from the package [httperrors](https://github.com/fastbill/go-httperrors) will be returned.
+
+## Example
+```go
+import "github.com/fastbill/go-request"
+
+type Input struct {
+	RequestValue string `json:"requestValue"`
+}
+
+type Output struct {
+	ResponseValue string `json:"responseValue"`
+}
+
+params := Params{
+    URL:    "https://example.com",
+    Method: "POST",
+    Headers: map[string]string{"my-header":"value", "another-header":"value2"}
+    Body:   Input{RequestValue: "someValueIn"},
+    Query: map[string]string{"key": "value"},
+}
+
+result := &Output{}
+err := request.Do(params, result)
+```
+
+## Convenience wrappers
+```go
+err := request.Get("http://example.com", result)
+
+err := request.Post("http://example.com", Input{RequestValue: "someValueIn"}, result)
+```
+
+## Defaults
+* All `2xx` response codes are treated as success, all other codes lead to an error being returned
+* 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
+* `Accept` and `Content-Type` request header are set to `application/json` and can be overwritten via the Headers parameter
+
+## Streaming
+The package allows the request body (`Body` property of `Params`) to be of type `io.Reader`. That way you can pass on request bodies to other services without parsing them.
+

README.md

@@ -0,0 +1,152 @@
+package request
+
+import (
+	"bytes"
+	"encoding/json"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"time"
+
+	"github.com/fastbill/go-httperrors"
+	"github.com/pkg/errors"
+)
+
+// client is the global client instance.
+var client *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()
+	}
+
+	return client
+}
+
+// GetClient returns an http client that does not follow redirects and has a timeout of defaultTimeout.
+func GetClient() *http.Client {
+	return &http.Client{
+		CheckRedirect: func(req *http.Request, via []*http.Request) error {
+			return http.ErrUseLastResponse
+		},
+		Timeout: defaultTimeout,
+	}
+}
+
+// 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
+}
+
+// Do executes the request as specified in the request params
+// The reponse body will be parsed into the provided struct
+func Do(params Params, responseBody interface{}) (returnErr error) {
+	req, err := createRequest(params)
+	if err != nil {
+		return err
+	}
+
+	var client *http.Client
+	if params.Timeout != 0 {
+		client = GetClient()
+		client.Timeout = params.Timeout
+	} else {
+		client = getCachedClient()
+	}
+
+	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
+		}
+	}()
+
+	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))
+	}
+
+	if responseBody == nil {
+		return nil
+	}
+
+	return json.NewDecoder(res.Body).Decode(responseBody)
+}
+
+func createRequest(params Params) (*http.Request, error) {
+	reader, err := convertToReader(params.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest(params.Method, params.URL, reader)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to create request")
+	}
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Content-Type", "application/json")
+	for key, value := range params.Headers {
+		req.Header.Set(key, value)
+	}
+
+	if len(params.Query) > 0 {
+		q := req.URL.Query()
+		for key, value := range params.Query {
+			q.Add(key, value)
+		}
+		req.URL.RawQuery = q.Encode()
+	}
+
+	return req, nil
+}
+
+// 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)
+}
+
+// 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
+}
+
+func convertToReader(body interface{}) (io.Reader, error) {
+	if body == nil {
+		return nil, nil
+	}
+
+	reader, ok := body.(io.Reader)
+	if ok {
+		return reader, nil
+	}
+
+	buffer := &bytes.Buffer{}
+	err := json.NewEncoder(buffer).Encode(body)
+	if err != nil {
+		return nil, errors.Wrap(err, "failed to parse request body to json")
+	}
+
+	return buffer, nil
+}