Introduce gitlabnet.ParseJSON to DRY

go/internal/gitlabnet/client.go

@@ -17,6 +17,10 @@ const (
 	secretHeaderName = "Gitlab-Shared-Secret"
 )
 
+var (
+	ParsingError = fmt.Errorf("Parsing failed")
+)
+
 type ErrorResponse struct {
 	Message string `json:"message"`
 }
@@ -120,3 +124,11 @@ func (c *GitlabClient) doRequest(method, path string, data interface{}) (*http.R
 
 	return response, nil
 }
+
+func ParseJSON(hr *http.Response, response interface{}) error {
+	if err := json.NewDecoder(hr.Body).Decode(response); err != nil {
+		return ParsingError
+	}
+
+	return nil
+}

go/internal/gitlabnet/discover/client.go

 package discover
 
 import (
-	"encoding/json"
 	"fmt"
 	"net/http"
 	"net/url"
@@ -32,56 +31,39 @@ func NewClient(config *config.Config) (*Client, error) {
 }
 
 func (c *Client) GetByCommandArgs(args *commandargs.CommandArgs) (*Response, error) {
-	if args.GitlabKeyId != "" {
-		return c.GetByKeyId(args.GitlabKeyId)
-	} else if args.GitlabUsername != "" {
-		return c.GetByUsername(args.GitlabUsername)
+	params := url.Values{}
+	if args.GitlabUsername != "" {
+		params.Add("username", args.GitlabUsername)
+	} else if args.GitlabKeyId != "" {
+		params.Add("key_id", args.GitlabKeyId)
 	} else {
 		// There was no 'who' information, this  matches the ruby error
 		// message.
 		return nil, fmt.Errorf("who='' is invalid")
 	}
-}
-
-func (c *Client) GetByKeyId(keyId string) (*Response, error) {
-	params := url.Values{}
-	params.Add("key_id", keyId)
-
-	return c.getResponse(params)
-}
-
-func (c *Client) GetByUsername(username string) (*Response, error) {
-	params := url.Values{}
-	params.Add("username", username)
 
 	return c.getResponse(params)
 }
 
-func (c *Client) parseResponse(resp *http.Response) (*Response, error) {
-	parsedResponse := &Response{}
-
-	if err := json.NewDecoder(resp.Body).Decode(parsedResponse); err != nil {
-		return nil, err
-	} else {
-		return parsedResponse, nil
-	}
-}
-
 func (c *Client) getResponse(params url.Values) (*Response, error) {
 	path := "/discover?" + params.Encode()
-	response, err := c.client.Get(path)
 
+	response, err := c.client.Get(path)
 	if err != nil {
 		return nil, err
 	}
-
 	defer response.Body.Close()
-	parsedResponse, err := c.parseResponse(response)
-	if err != nil {
-		return nil, fmt.Errorf("Parsing failed")
+
+	return parse(response)
+}
+
+func parse(hr *http.Response) (*Response, error) {
+	response := &Response{}
+	if err := gitlabnet.ParseJSON(hr, response); err != nil {
+		return nil, err
 	}
 
-	return parsedResponse, nil
+	return response, nil
 }
 
 func (r *Response) IsAnonymous() bool {

go/internal/gitlabnet/discover/client_test.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"net/http"
+	"net/url"
 	"testing"
 
 	"gitlab.com/gitlab-org/gitlab-shell/go/internal/config"
@@ -59,7 +60,9 @@ func TestGetByKeyId(t *testing.T) {
 	client, cleanup := setup(t)
 	defer cleanup()
 
-	result, err := client.GetByKeyId("1")
+	params := url.Values{}
+	params.Add("key_id", "1")
+	result, err := client.getResponse(params)
 	assert.NoError(t, err)
 	assert.Equal(t, &Response{UserId: 2, Username: "alex-doe", Name: "Alex Doe"}, result)
 }
@@ -68,7 +71,9 @@ func TestGetByUsername(t *testing.T) {
 	client, cleanup := setup(t)
 	defer cleanup()
 
-	result, err := client.GetByUsername("jane-doe")
+	params := url.Values{}
+	params.Add("username", "jane-doe")
+	result, err := client.getResponse(params)
 	assert.NoError(t, err)
 	assert.Equal(t, &Response{UserId: 1, Username: "jane-doe", Name: "Jane Doe"}, result)
 }
@@ -77,7 +82,9 @@ func TestMissingUser(t *testing.T) {
 	client, cleanup := setup(t)
 	defer cleanup()
 
-	result, err := client.GetByUsername("missing")
+	params := url.Values{}
+	params.Add("username", "missing")
+	result, err := client.getResponse(params)
 	assert.NoError(t, err)
 	assert.True(t, result.IsAnonymous())
 }
@@ -110,7 +117,9 @@ func TestErrorResponses(t *testing.T) {
 
 	for _, tc := range testCases {
 		t.Run(tc.desc, func(t *testing.T) {
-			resp, err := client.GetByUsername(tc.fakeUsername)
+			params := url.Values{}
+			params.Add("username", tc.fakeUsername)
+			resp, err := client.getResponse(params)
 
 			assert.EqualError(t, err, tc.expectedError)
 			assert.Nil(t, resp)

go/internal/gitlabnet/twofactorrecover/client.go

 package twofactorrecover
 
 import (
-	"encoding/json"
 	"errors"
 	"fmt"
-	"io/ioutil"
 	"net/http"
 
 	"gitlab.com/gitlab-org/gitlab-shell/go/internal/command/commandargs"
@@ -46,38 +44,25 @@ func (c *Client) GetRecoveryCodes(args *commandargs.CommandArgs) ([]string, erro
 	}
 
 	response, err := c.client.Post("/two_factor_recovery_codes", requestBody)
-
 	if err != nil {
 		return nil, err
 	}
-
 	defer response.Body.Close()
-	parsedResponse, err := c.parseResponse(response)
-
-	if err != nil {
-		return nil, fmt.Errorf("Parsing failed")
-	}
 
-	if parsedResponse.Success {
-		return parsedResponse.RecoveryCodes, nil
-	} else {
-		return nil, errors.New(parsedResponse.Message)
-	}
+	return parse(response)
 }
 
-func (c *Client) parseResponse(resp *http.Response) (*Response, error) {
-	parsedResponse := &Response{}
-	body, err := ioutil.ReadAll(resp.Body)
-
-	if err != nil {
+func parse(hr *http.Response) ([]string, error) {
+	response := &Response{}
+	if err := gitlabnet.ParseJSON(hr, response); err != nil {
 		return nil, err
 	}
 
-	if err := json.Unmarshal(body, parsedResponse); err != nil {
-		return nil, err
-	} else {
-		return parsedResponse, nil
+	if !response.Success {
+		return nil, errors.New(response.Message)
 	}
+
+	return response.RecoveryCodes, nil
 }
 
 func (c *Client) getRequestBody(args *commandargs.CommandArgs) (*RequestBody, error) {