Merge pull request #7 from fastbill/add-reformat-map-helper

Add ReformatMap helper

Author: junedev

README.md

@@ -3,8 +3,9 @@
 > 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 response 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.
+With this request package you just need to define the structs or maps/slices 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 or map/slice you provided for the result. Request and response 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. The same happens if you specified an `ExpectedResponseCode` and that one was not matched by the actual response.
 
 ## Example
 ```go
@@ -55,6 +56,7 @@ err := request.Post("http://example.com", Input{RequestValue: "someValueIn"}, re
 * The http client does not follow redirects
 * 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
+* The parameters `Headers` and `Query` accept a simple `map[string]string`. If you want to pass `http.Header` or `url.Values` instead, wrap them in the provided `request.ReformatMap` helper function.
 
 ## 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.
@@ -116,4 +118,4 @@ defer func() {
 result := &Output{}
 err = json.NewDecoder(res.Body).Decode(result)
 ```
-This shows the request package saves a lot of boilerplate code. instead of around 35 lines we just write the 9 lines shown in the example. That way the code is much easier to read and maintain.
+This shows the request package saves a lot of boilerplate code. Instead of around 35 lines we just write the 9 lines shown in the example. That way the code is much easier to read and maintain.

request.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"io/ioutil"
 	"net/http"
+	"strings"
 	"time"
 
 	"github.com/fastbill/go-httperrors/v2"
@@ -182,6 +183,18 @@ func Post(url string, requestBody interface{}, responseBody interface{}) error {
 	return Do(Params{Method: http.MethodPost, URL: url, Body: requestBody}, responseBody)
 }
 
+// ReformatMap converts map[string][]string to map[string]string by
+// converting the values to comma-separated strings.
+// The function can be used to make http.Header or url.Values compatible
+// with the request parameters.
+func ReformatMap(inputMap map[string][]string) map[string]string {
+	result := map[string]string{}
+	for key, values := range inputMap {
+		result[key] = strings.Join(values, ",")
+	}
+	return result
+}
+
 func convertToReader(body interface{}) (io.Reader, error) {
 	if body == nil {
 		return nil, nil

request_test.go

@@ -85,6 +85,58 @@ func TestDoSuccessful(t *testing.T) {
 		assert.Equal(t, "someValueOut", result.ResponseValue)
 	})
 
+	t.Run("map as request and response", func(t *testing.T) {
+		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			body, _ := ioutil.ReadAll(r.Body)
+			assert.Equal(t, `{"requestValue":"someValueIn"}`+"\n", string(body))
+			assert.Equal(t, r.Method, http.MethodPost)
+			w.WriteHeader(http.StatusCreated)
+			_, err := w.Write([]byte(`{"responseValue":"someValueOut"}`))
+			assert.NoError(t, err)
+		}))
+		defer ts.Close()
+
+		params := Params{
+			URL:                  ts.URL,
+			Method:               http.MethodPost,
+			Body:                 map[string]string{"requestValue": "someValueIn"},
+			ExpectedResponseCode: http.StatusCreated,
+		}
+
+		result := map[string]string{}
+		err := Do(params, &result)
+		assert.NoError(t, err)
+		assert.Equal(t, map[string]string{"responseValue": "someValueOut"}, result)
+	})
+
+	t.Run("slice as request and response", func(t *testing.T) {
+		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			body, _ := ioutil.ReadAll(r.Body)
+			assert.Equal(t, `[{"requestValue":"someValueIn"}]`+"\n", string(body))
+			assert.Equal(t, r.Method, http.MethodPost)
+			w.WriteHeader(http.StatusCreated)
+			_, err := w.Write([]byte(`[{"key1": "value1"}, {"key2": "value2"}]`))
+			assert.NoError(t, err)
+		}))
+		defer ts.Close()
+
+		params := Params{
+			URL:                  ts.URL,
+			Method:               http.MethodPost,
+			Body:                 []map[string]interface{}{{"requestValue": "someValueIn"}},
+			ExpectedResponseCode: http.StatusCreated,
+		}
+
+		result := []map[string]interface{}{}
+		err := Do(params, &result)
+		assert.NoError(t, err)
+		expected := []map[string]interface{}{
+			{"key1": "value1"},
+			{"key2": "value2"},
+		}
+		assert.Equal(t, expected, result)
+	})
+
 	t.Run("with query", func(t *testing.T) {
 		ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 			assert.Equal(t, r.URL.RawQuery, `beenhere=before&testKey=testValue&%C3%B6%C3%A4=%25%26%2F`)
@@ -374,6 +426,42 @@ func TestPost(t *testing.T) {
 	assert.Equal(t, "someValueOut", result.ResponseValue)
 }
 
+func TestReformatMap(t *testing.T) {
+	called := false
+	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		called = true
+
+		queryString := r.URL.RawQuery
+		actual := strings.SplitN(queryString, "&", -1)
+		expected := []string{"queryParam1=valueA%2CvalueB%2CvalueC", "queryParam2=value%C3%9C%C3%84%C3%96"}
+		assert.ElementsMatch(t, expected, actual)
+
+		assert.Equal(t, "valueD,value/-Ä", r.Header.Get("header1"))
+		assert.Equal(t, "valueE", r.Header.Get("header2"))
+	}))
+	defer ts.Close()
+
+	query := url.Values{
+		"queryParam1": []string{"valueA", "valueB", "valueC"},
+		"queryParam2": []string{"valueÜÄÖ"},
+	}
+
+	headers := http.Header{
+		"header1": []string{"valueD", "value/-Ä"},
+		"header2": []string{"valueE"},
+	}
+
+	params := Params{
+		URL:     ts.URL,
+		Headers: ReformatMap(headers),
+		Query:   ReformatMap(query),
+	}
+
+	err := Do(params, nil)
+	assert.NoError(t, err)
+	assert.True(t, called)
+}
+
 func ExampleDo() {
 	ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		body, _ := ioutil.ReadAll(r.Body)