Implement errors.Unwrap() on unexpected status code errors

With this patch, we add a method with signature `Unwrap() error` to all
errors signaling an unexpected status code. All of them contain a value
of type `gophercloud.ErrUnexpectedStatusCode` that exposes, among other
useful values, the body of the response sent by the server.

To access the response body of a request that resulted in an unexpected
response code, try to unwrap the returned error to
`gophercloud.ErrUnexpectedStatusCode`:

```Go
pages, err := containers.List(client, nil).AllPages()
if err != nil {
	var responseCodeError gophercloud.ErrUnexpectedResponseCode
	if errors.As(err, &responseCodeError) {
		log.Printf("unexpected response code. Response body:\n---\n%s\n---", responseCodeError.Body)
	} else {
		log.Printf("unknown error")
	}
}
```

Author: pierreprinetti

errors.go

@@ -116,61 +116,109 @@ type ErrDefault400 struct {
 	ErrUnexpectedResponseCode
 }
 
+func (e ErrDefault400) Unwrap() error {
+	return e.ErrUnexpectedResponseCode
+}
+
 // ErrDefault401 is the default error type returned on a 401 HTTP response code.
 type ErrDefault401 struct {
 	ErrUnexpectedResponseCode
 }
 
+func (e ErrDefault401) Unwrap() error {
+	return e.ErrUnexpectedResponseCode
+}
+
 // ErrDefault403 is the default error type returned on a 403 HTTP response code.
 type ErrDefault403 struct {
 	ErrUnexpectedResponseCode
 }
 
+func (e ErrDefault403) Unwrap() error {
+	return e.ErrUnexpectedResponseCode
+}
+
 // ErrDefault404 is the default error type returned on a 404 HTTP response code.
 type ErrDefault404 struct {
 	ErrUnexpectedResponseCode
 }
 
+func (e ErrDefault404) Unwrap() error {
+	return e.ErrUnexpectedResponseCode
+}
+
 // ErrDefault405 is the default error type returned on a 405 HTTP response code.
 type ErrDefault405 struct {
 	ErrUnexpectedResponseCode
 }
 
+func (e ErrDefault405) Unwrap() error {
+	return e.ErrUnexpectedResponseCode
+}
+
 // ErrDefault408 is the default error type returned on a 408 HTTP response code.
 type ErrDefault408 struct {
 	ErrUnexpectedResponseCode
 }
 
+func (e ErrDefault408) Unwrap() error {
+	return e.ErrUnexpectedResponseCode
+}
+
 // ErrDefault409 is the default error type returned on a 409 HTTP response code.
 type ErrDefault409 struct {
 	ErrUnexpectedResponseCode
 }
 
+func (e ErrDefault409) Unwrap() error {
+	return e.ErrUnexpectedResponseCode
+}
+
 // ErrDefault429 is the default error type returned on a 429 HTTP response code.
 type ErrDefault429 struct {
 	ErrUnexpectedResponseCode
 }
 
+func (e ErrDefault429) Unwrap() error {
+	return e.ErrUnexpectedResponseCode
+}
+
 // ErrDefault500 is the default error type returned on a 500 HTTP response code.
 type ErrDefault500 struct {
 	ErrUnexpectedResponseCode
 }
 
+func (e ErrDefault500) Unwrap() error {
+	return e.ErrUnexpectedResponseCode
+}
+
 // ErrDefault502 is the default error type returned on a 502 HTTP response code.
 type ErrDefault502 struct {
 	ErrUnexpectedResponseCode
 }
 
+func (e ErrDefault502) Unwrap() error {
+	return e.ErrUnexpectedResponseCode
+}
+
 // ErrDefault503 is the default error type returned on a 503 HTTP response code.
 type ErrDefault503 struct {
 	ErrUnexpectedResponseCode
 }
 
+func (e ErrDefault503) Unwrap() error {
+	return e.ErrUnexpectedResponseCode
+}
+
 // ErrDefault504 is the default error type returned on a 504 HTTP response code.
 type ErrDefault504 struct {
 	ErrUnexpectedResponseCode
 }
 
+func (e ErrDefault504) Unwrap() error {
+	return e.ErrUnexpectedResponseCode
+}
+
 func (e ErrDefault400) Error() string {
 	e.DefaultErrString = fmt.Sprintf(
 		"Bad request with: [%s %s], error message: %s",

testing/errors_test.go

@@ -1,6 +1,7 @@
 package testing
 
 import (
+	"errors"
 	"testing"
 
 	"github.com/gophercloud/gophercloud"
@@ -13,7 +14,7 @@ func returnsUnexpectedResp(code int) gophercloud.ErrUnexpectedResponseCode {
 		Method:         "GET",
 		Expected:       []int{200},
 		Actual:         code,
-		Body:           nil,
+		Body:           []byte("the response body"),
 		ResponseHeader: nil,
 	}
 }
@@ -24,6 +25,17 @@ func TestGetResponseCode404(t *testing.T) {
 	err, ok := err404.(gophercloud.StatusCodeError)
 	th.AssertEquals(t, true, ok)
 	th.AssertEquals(t, err.GetStatusCode(), 404)
+
+	t.Run("wraps ErrUnexpectedResponseCode", func(t *testing.T) {
+		var unexpectedResponseCode gophercloud.ErrUnexpectedResponseCode
+		if errors.As(err, &unexpectedResponseCode) {
+			if want, have := "the response body", string(unexpectedResponseCode.Body); want != have {
+				t.Errorf("expected the wrapped error to contain the response body, found %q", have)
+			}
+		} else {
+			t.Errorf("err.Unwrap() didn't return ErrUnexpectedResponseCode")
+		}
+	})
 }
 
 func TestGetResponseCode502(t *testing.T) {
@@ -32,6 +44,17 @@ func TestGetResponseCode502(t *testing.T) {
 	err, ok := err502.(gophercloud.StatusCodeError)
 	th.AssertEquals(t, true, ok)
 	th.AssertEquals(t, err.GetStatusCode(), 502)
+
+	t.Run("wraps ErrUnexpectedResponseCode", func(t *testing.T) {
+		var unexpectedResponseCode gophercloud.ErrUnexpectedResponseCode
+		if errors.As(err, &unexpectedResponseCode) {
+			if want, have := "the response body", string(unexpectedResponseCode.Body); want != have {
+				t.Errorf("expected the wrapped error to contain the response body, found %q", have)
+			}
+		} else {
+			t.Errorf("err.Unwrap() didn't return ErrUnexpectedResponseCode")
+		}
+	})
 }
 
 func TestGetResponseCode504(t *testing.T) {
@@ -40,4 +63,34 @@ func TestGetResponseCode504(t *testing.T) {
 	err, ok := err504.(gophercloud.StatusCodeError)
 	th.AssertEquals(t, true, ok)
 	th.AssertEquals(t, err.GetStatusCode(), 504)
+
+	t.Run("wraps ErrUnexpectedResponseCode", func(t *testing.T) {
+		var unexpectedResponseCode gophercloud.ErrUnexpectedResponseCode
+		if errors.As(err, &unexpectedResponseCode) {
+			if want, have := "the response body", string(unexpectedResponseCode.Body); want != have {
+				t.Errorf("expected the wrapped error to contain the response body, found %q", have)
+			}
+		} else {
+			t.Errorf("err.Unwrap() didn't return ErrUnexpectedResponseCode")
+		}
+	})
 }
+
+// Compile-time check that all response-code errors implement `Unwrap()`
+type unwrapper interface {
+	Unwrap() error
+}
+
+var (
+	_ unwrapper = gophercloud.ErrDefault401{}
+	_ unwrapper = gophercloud.ErrDefault403{}
+	_ unwrapper = gophercloud.ErrDefault404{}
+	_ unwrapper = gophercloud.ErrDefault405{}
+	_ unwrapper = gophercloud.ErrDefault408{}
+	_ unwrapper = gophercloud.ErrDefault409{}
+	_ unwrapper = gophercloud.ErrDefault429{}
+	_ unwrapper = gophercloud.ErrDefault500{}
+	_ unwrapper = gophercloud.ErrDefault502{}
+	_ unwrapper = gophercloud.ErrDefault503{}
+	_ unwrapper = gophercloud.ErrDefault504{}
+)