Deprecate ErrResponse error with ErrorResponse instance (#35)

Author: romanyx

balance.go

@@ -5,5 +5,5 @@ type Balance struct {
 	Payment string
 	Type    string
 	Amount  float32
-	Errors  []Error
+	Errors  []Error // Deprecated: errors now returned at ErrorResponse instance as error.
 }

balance_test.go

@@ -35,21 +35,22 @@ func TestBalance(t *testing.T) {
 
 func TestBalanceError(t *testing.T) {
 	SetServerResponse(405, accessKeyErrorObject)
+	_, err := mbClient.Balance()
 
-	balance, err := mbClient.Balance()
-	if err != ErrResponse {
-		t.Fatalf("Expected ErrResponse to be returned, instead I got %s", err)
+	errorResponse, ok := err.(ErrorResponse)
+	if !ok {
+		t.Fatalf("Expected ErrorResponse to be returned, instead I got %s", err)
 	}
 
-	if len(balance.Errors) != 1 {
-		t.Fatalf("Unexpected number of errors: %d", len(balance.Errors))
+	if len(errorResponse.Errors) != 1 {
+		t.Fatalf("Unexpected number of errors: %d, expected: 1", len(errorResponse.Errors))
 	}
 
-	if balance.Errors[0].Code != 2 {
-		t.Errorf("Unexpected error code: %d", balance.Errors[0].Code)
+	if errorResponse.Errors[0].Code != 2 {
+		t.Errorf("Unexpected error code: %d, expected: 2", errorResponse.Errors[0].Code)
 	}
 
-	if balance.Errors[0].Parameter != "access_key" {
-		t.Errorf("Unexpected error parameter: %s", balance.Errors[0].Parameter)
+	if errorResponse.Errors[0].Parameter != "access_key" {
+		t.Errorf("Unexpected error parameter: %s, expected: access_key", errorResponse.Errors[0].Parameter)
 	}
 }

client.go

@@ -63,20 +63,44 @@ type Client struct {
 	AccessKey  string       // The API access key
 	HTTPClient *http.Client // The HTTP client to send requests on
 	DebugLog   *log.Logger  // Optional logger for debugging purposes
+	request    func(c *Client, v interface{}, method, path string, data interface{}) error
+}
+
+// NewV2 creates a new MessageBird client object.
+// If the request to MessageBird API will return an
+// error, it will be returned as ErrorResponse instance
+// typed as the error, containing all codes,
+// descriptions and properies.
+func NewV2(accessKey string) *Client {
+	return &Client{
+		AccessKey: accessKey,
+		HTTPClient: &http.Client{
+			Timeout: httpClientTimeout,
+		},
+		request: requestV2,
+	}
 }
 
 // New creates a new MessageBird client object.
+// If the request to MessageBird API will return
+// and error, it will simply return ErrResponse.
+// Deprecated: use NewV2 until v2 release.
 func New(accessKey string) *Client {
 	return &Client{
 		AccessKey: accessKey,
 		HTTPClient: &http.Client{
 			Timeout: httpClientTimeout,
 		},
+		request: requestV1,
 	}
 }
 
 // Request is for internal use only and unstable.
 func (c *Client) Request(v interface{}, method, path string, data interface{}) error {
+	return c.request(c, v, method, path, data)
+}
+
+func requestV1(c *Client, v interface{}, method, path string, data interface{}) error {
 	if !strings.HasPrefix(path, "https://") && !strings.HasPrefix(path, "http://") {
 		path = fmt.Sprintf("%s/%s", Endpoint, path)
 	}
@@ -150,6 +174,80 @@ func (c *Client) Request(v interface{}, method, path string, data interface{}) e
 	return ErrResponse
 }
 
+func requestV2(c *Client, v interface{}, method, path string, data interface{}) error {
+	if !strings.HasPrefix(path, "https://") && !strings.HasPrefix(path, "http://") {
+		path = fmt.Sprintf("%s/%s", Endpoint, path)
+	}
+	uri, err := url.Parse(path)
+	if err != nil {
+		return err
+	}
+
+	var jsonEncoded []byte
+	if data != nil {
+		jsonEncoded, err = json.Marshal(data)
+		if err != nil {
+			return err
+		}
+	}
+
+	request, err := http.NewRequest(method, uri.String(), bytes.NewBuffer(jsonEncoded))
+	if err != nil {
+		return err
+	}
+
+	request.Header.Set("Content-Type", "application/json")
+	request.Header.Set("Accept", "application/json")
+	request.Header.Set("Authorization", "AccessKey "+c.AccessKey)
+	request.Header.Set("User-Agent", "MessageBird/ApiClient/"+ClientVersion+" Go/"+runtime.Version())
+
+	if c.DebugLog != nil {
+		if data != nil {
+			c.DebugLog.Printf("HTTP REQUEST: %s %s %s", method, uri.String(), jsonEncoded)
+		} else {
+			c.DebugLog.Printf("HTTP REQUEST: %s %s", method, uri.String())
+		}
+	}
+
+	response, err := c.HTTPClient.Do(request)
+	if err != nil {
+		return err
+	}
+
+	defer response.Body.Close()
+
+	responseBody, err := ioutil.ReadAll(response.Body)
+	if err != nil {
+		return err
+	}
+
+	if c.DebugLog != nil {
+		c.DebugLog.Printf("HTTP RESPONSE: %s", string(responseBody))
+	}
+
+	// Status code 500 is a server error and means nothing can be done at this
+	// point.
+	if response.StatusCode == 500 {
+		return ErrUnexpectedResponse
+	}
+	// Status codes 200 and 201 are indicative of being able to convert the
+	// response body to the struct that was specified.
+	if response.StatusCode == 200 || response.StatusCode == 201 {
+		if err := json.Unmarshal(responseBody, &v); err != nil {
+			return fmt.Errorf("could not decode response JSON, %s: %v", string(responseBody), err)
+		}
+		return nil
+	}
+
+	// Anything else than a 200/201/500 should be a JSON error.
+	var errorResponse ErrorResponse
+	if err := json.Unmarshal(responseBody, &errorResponse); err != nil {
+		return err
+	}
+
+	return errorResponse
+}
+
 // Balance returns the balance information for the account that is associated
 // with the access key.
 func (c *Client) Balance() (*Balance, error) {
@@ -398,7 +496,6 @@ func (c *Client) Lookup(phoneNumber string, params *LookupParams) (*Lookup, erro
 		if err == ErrResponse {
 			return lookup, err
 		}
-
 		return nil, err
 	}
 

error.go

@@ -1,8 +1,28 @@
 package messagebird
 
+import "fmt"
+
 // Error holds details including error code, human readable description and optional parameter that is related to the error.
 type Error struct {
 	Code        int
 	Description string
 	Parameter   string
 }
+
+// ErrorResponse represents errored API response.
+type ErrorResponse struct {
+	Errors []Error `json:"errors"`
+}
+
+// Error implements error interface.
+func (r ErrorResponse) Error() string {
+	eString := "API returned an error: "
+	for i, e := range r.Errors {
+		eString = eString + fmt.Sprintf("code: %d, description: %s, parameter: %s", e.Code, e.Description, e.Parameter)
+		if i < len(r.Errors)-1 {
+			eString = eString + ", "
+		}
+	}
+
+	return eString
+}

error_test.go

@@ -0,0 +1,48 @@
+package messagebird
+
+import "testing"
+
+func TestErrorResponseError(t *testing.T) {
+	tests := []struct {
+		name   string
+		errors []Error
+		expect string
+	}{
+		{
+			name: "single error",
+			errors: []Error{
+				Error{
+					Code:        2,
+					Description: "Request not allowed (incorrect access_key)",
+					Parameter:   "access_key",
+				},
+			},
+			expect: "API returned an error: code: 2, description: Request not allowed (incorrect access_key), parameter: access_key",
+		},
+		{
+			name: "multiple errors",
+			errors: []Error{
+				Error{
+					Code:        2,
+					Description: "Request not allowed (incorrect access_key)",
+					Parameter:   "access_key",
+				},
+				Error{
+					Code:        2,
+					Description: "Request not allowed (incorrect access_key)",
+					Parameter:   "access_key",
+				},
+			},
+			expect: "API returned an error: code: 2, description: Request not allowed (incorrect access_key), parameter: access_key, code: 2, description: Request not allowed (incorrect access_key), parameter: access_key",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			er := ErrorResponse{tt.errors}
+			if er.Error() != tt.expect {
+				t.Errorf("expected error message to be:\n%s\ngot:\n%s", tt.expect, er.Error())
+			}
+		})
+	}
+}

hlr.go

@@ -17,7 +17,7 @@ type HLR struct {
 	Details         map[string]interface{}
 	CreatedDatetime *time.Time
 	StatusDatetime  *time.Time
-	Errors          []Error
+	Errors          []Error // Deprecated: errors now returned at ErrorResponse instance as error.
 }
 
 // HLRList represents a list of HLR requests.

hlr_test.go

@@ -124,22 +124,23 @@ func TestNewHLR(t *testing.T) {
 
 func TestHLRError(t *testing.T) {
 	SetServerResponse(http.StatusMethodNotAllowed, accessKeyErrorObject)
+	_, err := mbClient.HLR("dummy_hlr_id")
 
-	hlr, err := mbClient.HLR("dummy_hlr_id")
-	if err != ErrResponse {
-		t.Fatalf("Expected ErrResponse to be returned, instead I got %s", err)
+	errorResponse, ok := err.(ErrorResponse)
+	if !ok {
+		t.Fatalf("Expected ErrorResponse to be returned, instead I got %s", err)
 	}
 
-	if len(hlr.Errors) != 1 {
-		t.Fatalf("Unexpected number of errors: %d, expected: 1", len(hlr.Errors))
+	if len(errorResponse.Errors) != 1 {
+		t.Fatalf("Unexpected number of errors: %d, expected: 1", len(errorResponse.Errors))
 	}
 
-	if hlr.Errors[0].Code != 2 {
-		t.Errorf("Unexpected error code: %d, expected: 2", hlr.Errors[0].Code)
+	if errorResponse.Errors[0].Code != 2 {
+		t.Errorf("Unexpected error code: %d, expected: 2", errorResponse.Errors[0].Code)
 	}
 
-	if hlr.Errors[0].Parameter != "access_key" {
-		t.Errorf("Unexpected error parameter: %s, expected: access_key", hlr.Errors[0].Parameter)
+	if errorResponse.Errors[0].Parameter != "access_key" {
+		t.Errorf("Unexpected error parameter: %s, expected: access_key", errorResponse.Errors[0].Parameter)
 	}
 }
 

main_test.go

@@ -45,10 +45,8 @@ func startFauxServer() {
 		},
 	}
 
-	mbClient = &Client{
-		AccessKey:  "test_gshuPaZoeEG6ovbc8M79w0QyM",
-		HTTPClient: &http.Client{Transport: transport},
-	}
+	mbClient = NewV2("test_gshuPaZoeEG6ovbc8M79w0QyM")
+	mbClient.HTTPClient = &http.Client{Transport: transport}
 
 	if testing.Verbose() {
 		mbClient.DebugLog = log.New(os.Stdout, "DEBUG", log.Lshortfile)

message.go

@@ -28,7 +28,7 @@ type Message struct {
 	ScheduledDatetime *time.Time
 	CreatedDatetime   *time.Time
 	Recipients        Recipients
-	Errors            []Error
+	Errors            []Error // Deprecated: errors now returned at ErrorResponse instance as error.
 }
 
 // MessageList represents a list of Messages.

message_test.go

@@ -114,10 +114,6 @@ func assertMessageObject(t *testing.T, message *Message) {
 	if message.Recipients.Items[0].StatusDatetime == nil || message.Recipients.Items[0].StatusDatetime.Format(time.RFC3339) != "2015-01-05T10:02:59Z" {
 		t.Errorf("Unexpected datetime status for message recipient: %s, expected: 2015-01-05T10:02:59Z", message.Recipients.Items[0].StatusDatetime.Format(time.RFC3339))
 	}
-
-	if len(message.Errors) != 0 {
-		t.Errorf("Unexpected number of errors in message: %d, expected: 0", len(message.Errors))
-	}
 }
 
 func TestNewMessage(t *testing.T) {
@@ -133,22 +129,23 @@ func TestNewMessage(t *testing.T) {
 
 func TestNewMessageError(t *testing.T) {
 	SetServerResponse(http.StatusMethodNotAllowed, accessKeyErrorObject)
+	_, err := mbClient.NewMessage("TestName", []string{"31612345678"}, "Hello World", nil)
 
-	message, err := mbClient.NewMessage("TestName", []string{"31612345678"}, "Hello World", nil)
-	if err != ErrResponse {
-		t.Fatalf("Expected ErrResponse to be returned, instead I got %s", err)
+	errorResponse, ok := err.(ErrorResponse)
+	if !ok {
+		t.Fatalf("Expected ErrorResponse to be returned, instead I got %s", err)
 	}
 
-	if len(message.Errors) != 1 {
-		t.Fatalf("Unexpected number of errors: %d, expected: 1", len(message.Errors))
+	if len(errorResponse.Errors) != 1 {
+		t.Fatalf("Unexpected number of errors: %d, expected: 1", len(errorResponse.Errors))
 	}
 
-	if message.Errors[0].Code != 2 {
-		t.Errorf("Unexpected error code: %d, expected: 2", message.Errors[0].Code)
+	if errorResponse.Errors[0].Code != 2 {
+		t.Errorf("Unexpected error code: %d, expected: 2", errorResponse.Errors[0].Code)
 	}
 
-	if message.Errors[0].Parameter != "access_key" {
-		t.Errorf("Unexpected error parameter: %s, expected: access_key", message.Errors[0].Parameter)
+	if errorResponse.Errors[0].Parameter != "access_key" {
+		t.Errorf("Unexpected error parameter: %s, expected: access_key", errorResponse.Errors[0].Parameter)
 	}
 }