rebase: bump github.com/onsi/gomega from 1.13.0 to 1.16.0

Bumps [github.com/onsi/gomega](https://github.com/onsi/gomega) from 1.13.0 to 1.16.0.
- [Release notes](https://github.com/onsi/gomega/releases)
- [Changelog](https://github.com/onsi/gomega/blob/master/CHANGELOG.md)
- [Commits](https://github.com/onsi/gomega/compare/v1.13.0...v1.16.0)

---
updated-dependencies:
- dependency-name: github.com/onsi/gomega
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

vendor/github.com/onsi/gomega/matchers/and.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 
 	"github.com/onsi/gomega/format"
-	"github.com/onsi/gomega/internal/oraclematcher"
 	"github.com/onsi/gomega/types"
 )
 
@@ -52,12 +51,12 @@ func (m *AndMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
 	if m.firstFailedMatcher == nil {
 		// so all matchers succeeded.. Any one of them changing would change the result.
 		for _, matcher := range m.Matchers {
-			if oraclematcher.MatchMayChangeInTheFuture(matcher, actual) {
+			if types.MatchMayChangeInTheFuture(matcher, actual) {
 				return true
 			}
 		}
 		return false // none of were going to change
 	}
 	// one of the matchers failed.. it must be able to change in order to affect the result
-	return oraclematcher.MatchMayChangeInTheFuture(m.firstFailedMatcher, actual)
+	return types.MatchMayChangeInTheFuture(m.firstFailedMatcher, actual)
 }

vendor/github.com/onsi/gomega/matchers/have_http_body_matcher.go

@@ -0,0 +1,101 @@
+package matchers
+
+import (
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/http/httptest"
+
+	"github.com/onsi/gomega/format"
+	"github.com/onsi/gomega/types"
+)
+
+type HaveHTTPBodyMatcher struct {
+	Expected   interface{}
+	cachedBody []byte
+}
+
+func (matcher *HaveHTTPBodyMatcher) Match(actual interface{}) (bool, error) {
+	body, err := matcher.body(actual)
+	if err != nil {
+		return false, err
+	}
+
+	switch e := matcher.Expected.(type) {
+	case string:
+		return (&EqualMatcher{Expected: e}).Match(string(body))
+	case []byte:
+		return (&EqualMatcher{Expected: e}).Match(body)
+	case types.GomegaMatcher:
+		return e.Match(body)
+	default:
+		return false, fmt.Errorf("HaveHTTPBody matcher expects string, []byte, or GomegaMatcher. Got:\n%s", format.Object(matcher.Expected, 1))
+	}
+}
+
+func (matcher *HaveHTTPBodyMatcher) FailureMessage(actual interface{}) (message string) {
+	body, err := matcher.body(actual)
+	if err != nil {
+		return fmt.Sprintf("failed to read body: %s", err)
+	}
+
+	switch e := matcher.Expected.(type) {
+	case string:
+		return (&EqualMatcher{Expected: e}).FailureMessage(string(body))
+	case []byte:
+		return (&EqualMatcher{Expected: e}).FailureMessage(body)
+	case types.GomegaMatcher:
+		return e.FailureMessage(body)
+	default:
+		return fmt.Sprintf("HaveHTTPBody matcher expects string, []byte, or GomegaMatcher. Got:\n%s", format.Object(matcher.Expected, 1))
+	}
+}
+
+func (matcher *HaveHTTPBodyMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	body, err := matcher.body(actual)
+	if err != nil {
+		return fmt.Sprintf("failed to read body: %s", err)
+	}
+
+	switch e := matcher.Expected.(type) {
+	case string:
+		return (&EqualMatcher{Expected: e}).NegatedFailureMessage(string(body))
+	case []byte:
+		return (&EqualMatcher{Expected: e}).NegatedFailureMessage(body)
+	case types.GomegaMatcher:
+		return e.NegatedFailureMessage(body)
+	default:
+		return fmt.Sprintf("HaveHTTPBody matcher expects string, []byte, or GomegaMatcher. Got:\n%s", format.Object(matcher.Expected, 1))
+	}
+}
+
+// body returns the body. It is cached because once we read it in Match()
+// the Reader is closed and it is not readable again in FailureMessage()
+// or NegatedFailureMessage()
+func (matcher *HaveHTTPBodyMatcher) body(actual interface{}) ([]byte, error) {
+	if matcher.cachedBody != nil {
+		return matcher.cachedBody, nil
+	}
+
+	body := func(a *http.Response) ([]byte, error) {
+		if a.Body != nil {
+			defer a.Body.Close()
+			var err error
+			matcher.cachedBody, err = ioutil.ReadAll(a.Body)
+			if err != nil {
+				return nil, fmt.Errorf("error reading response body: %w", err)
+			}
+		}
+		return matcher.cachedBody, nil
+	}
+
+	switch a := actual.(type) {
+	case *http.Response:
+		return body(a)
+	case *httptest.ResponseRecorder:
+		return body(a.Result())
+	default:
+		return nil, fmt.Errorf("HaveHTTPBody matcher expects *http.Response or *httptest.ResponseRecorder. Got:\n%s", format.Object(actual, 1))
+	}
+
+}

vendor/github.com/onsi/gomega/matchers/have_http_header_with_value_matcher.go

@@ -0,0 +1,81 @@
+package matchers
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+
+	"github.com/onsi/gomega/format"
+	"github.com/onsi/gomega/types"
+)
+
+type HaveHTTPHeaderWithValueMatcher struct {
+	Header string
+	Value  interface{}
+}
+
+func (matcher *HaveHTTPHeaderWithValueMatcher) Match(actual interface{}) (success bool, err error) {
+	headerValue, err := matcher.extractHeader(actual)
+	if err != nil {
+		return false, err
+	}
+
+	headerMatcher, err := matcher.getSubMatcher()
+	if err != nil {
+		return false, err
+	}
+
+	return headerMatcher.Match(headerValue)
+}
+
+func (matcher *HaveHTTPHeaderWithValueMatcher) FailureMessage(actual interface{}) string {
+	headerValue, err := matcher.extractHeader(actual)
+	if err != nil {
+		panic(err) // protected by Match()
+	}
+
+	headerMatcher, err := matcher.getSubMatcher()
+	if err != nil {
+		panic(err) // protected by Match()
+	}
+
+	diff := format.IndentString(headerMatcher.FailureMessage(headerValue), 1)
+	return fmt.Sprintf("HTTP header %q:\n%s", matcher.Header, diff)
+}
+
+func (matcher *HaveHTTPHeaderWithValueMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	headerValue, err := matcher.extractHeader(actual)
+	if err != nil {
+		panic(err) // protected by Match()
+	}
+
+	headerMatcher, err := matcher.getSubMatcher()
+	if err != nil {
+		panic(err) // protected by Match()
+	}
+
+	diff := format.IndentString(headerMatcher.NegatedFailureMessage(headerValue), 1)
+	return fmt.Sprintf("HTTP header %q:\n%s", matcher.Header, diff)
+}
+
+func (matcher *HaveHTTPHeaderWithValueMatcher) getSubMatcher() (types.GomegaMatcher, error) {
+	switch m := matcher.Value.(type) {
+	case string:
+		return &EqualMatcher{Expected: matcher.Value}, nil
+	case types.GomegaMatcher:
+		return m, nil
+	default:
+		return nil, fmt.Errorf("HaveHTTPHeaderWithValue matcher must be passed a string or a GomegaMatcher. Got:\n%s", format.Object(matcher.Value, 1))
+	}
+}
+
+func (matcher *HaveHTTPHeaderWithValueMatcher) extractHeader(actual interface{}) (string, error) {
+	switch r := actual.(type) {
+	case *http.Response:
+		return r.Header.Get(matcher.Header), nil
+	case *httptest.ResponseRecorder:
+		return r.Result().Header.Get(matcher.Header), nil
+	default:
+		return "", fmt.Errorf("HaveHTTPHeaderWithValue matcher expects *http.Response or *httptest.ResponseRecorder. Got:\n%s", format.Object(actual, 1))
+	}
+}

vendor/github.com/onsi/gomega/matchers/have_http_status_matcher.go

@@ -2,14 +2,17 @@ package matchers
 
 import (
 	"fmt"
+	"io/ioutil"
 	"net/http"
 	"net/http/httptest"
+	"reflect"
+	"strings"
 
 	"github.com/onsi/gomega/format"
 )
 
 type HaveHTTPStatusMatcher struct {
-	Expected interface{}
+	Expected []interface{}
 }
 
 func (matcher *HaveHTTPStatusMatcher) Match(actual interface{}) (success bool, err error) {
@@ -23,20 +26,71 @@ func (matcher *HaveHTTPStatusMatcher) Match(actual interface{}) (success bool, e
 		return false, fmt.Errorf("HaveHTTPStatus matcher expects *http.Response or *httptest.ResponseRecorder. Got:\n%s", format.Object(actual, 1))
 	}
 
-	switch e := matcher.Expected.(type) {
-	case int:
-		return resp.StatusCode == e, nil
-	case string:
-		return resp.Status == e, nil
+	if len(matcher.Expected) == 0 {
+		return false, fmt.Errorf("HaveHTTPStatus matcher must be passed an int or a string. Got nothing")
 	}
 
-	return false, fmt.Errorf("HaveHTTPStatus matcher must be passed an int or a string. Got:\n%s", format.Object(matcher.Expected, 1))
+	for _, expected := range matcher.Expected {
+		switch e := expected.(type) {
+		case int:
+			if resp.StatusCode == e {
+				return true, nil
+			}
+		case string:
+			if resp.Status == e {
+				return true, nil
+			}
+		default:
+			return false, fmt.Errorf("HaveHTTPStatus matcher must be passed int or string types. Got:\n%s", format.Object(expected, 1))
+		}
+	}
+
+	return false, nil
 }
 
 func (matcher *HaveHTTPStatusMatcher) FailureMessage(actual interface{}) (message string) {
-	return format.Message(actual, "to have HTTP status", matcher.Expected)
+	return fmt.Sprintf("Expected\n%s\n%s\n%s", formatHttpResponse(actual), "to have HTTP status", matcher.expectedString())
 }
 
 func (matcher *HaveHTTPStatusMatcher) NegatedFailureMessage(actual interface{}) (message string) {
-	return format.Message(actual, "not to have HTTP status", matcher.Expected)
+	return fmt.Sprintf("Expected\n%s\n%s\n%s", formatHttpResponse(actual), "not to have HTTP status", matcher.expectedString())
+}
+
+func (matcher *HaveHTTPStatusMatcher) expectedString() string {
+	var lines []string
+	for _, expected := range matcher.Expected {
+		lines = append(lines, format.Object(expected, 1))
+	}
+	return strings.Join(lines, "\n")
+}
+
+func formatHttpResponse(input interface{}) string {
+	var resp *http.Response
+	switch r := input.(type) {
+	case *http.Response:
+		resp = r
+	case *httptest.ResponseRecorder:
+		resp = r.Result()
+	default:
+		return "cannot format invalid HTTP response"
+	}
+
+	body := "<nil>"
+	if resp.Body != nil {
+		defer resp.Body.Close()
+		data, err := ioutil.ReadAll(resp.Body)
+		if err != nil {
+			data = []byte("<error reading body>")
+		}
+		body = format.Object(string(data), 0)
+	}
+
+	var s strings.Builder
+	s.WriteString(fmt.Sprintf("%s<%s>: {\n", format.Indent, reflect.TypeOf(input)))
+	s.WriteString(fmt.Sprintf("%s%sStatus:     %s\n", format.Indent, format.Indent, format.Object(resp.Status, 0)))
+	s.WriteString(fmt.Sprintf("%s%sStatusCode: %s\n", format.Indent, format.Indent, format.Object(resp.StatusCode, 0)))
+	s.WriteString(fmt.Sprintf("%s%sBody:       %s\n", format.Indent, format.Indent, body))
+	s.WriteString(fmt.Sprintf("%s}", format.Indent))
+
+	return s.String()
 }

vendor/github.com/onsi/gomega/matchers/not.go

@@ -1,7 +1,6 @@
 package matchers
 
 import (
-	"github.com/onsi/gomega/internal/oraclematcher"
 	"github.com/onsi/gomega/types"
 )
 
@@ -26,5 +25,5 @@ func (m *NotMatcher) NegatedFailureMessage(actual interface{}) (message string)
 }
 
 func (m *NotMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
-	return oraclematcher.MatchMayChangeInTheFuture(m.Matcher, actual) // just return m.Matcher's value
+	return types.MatchMayChangeInTheFuture(m.Matcher, actual) // just return m.Matcher's value
 }

vendor/github.com/onsi/gomega/matchers/or.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 
 	"github.com/onsi/gomega/format"
-	"github.com/onsi/gomega/internal/oraclematcher"
 	"github.com/onsi/gomega/types"
 )
 
@@ -54,11 +53,11 @@ func (m *OrMatcher) MatchMayChangeInTheFuture(actual interface{}) bool {
 
 	if m.firstSuccessfulMatcher != nil {
 		// one of the matchers succeeded.. it must be able to change in order to affect the result
-		return oraclematcher.MatchMayChangeInTheFuture(m.firstSuccessfulMatcher, actual)
+		return types.MatchMayChangeInTheFuture(m.firstSuccessfulMatcher, actual)
 	} else {
 		// so all matchers failed.. Any one of them changing would change the result.
 		for _, matcher := range m.Matchers {
-			if oraclematcher.MatchMayChangeInTheFuture(matcher, actual) {
+			if types.MatchMayChangeInTheFuture(matcher, actual) {
 				return true
 			}
 		}

vendor/github.com/onsi/gomega/matchers/with_transform.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"reflect"
 
-	"github.com/onsi/gomega/internal/oraclematcher"
 	"github.com/onsi/gomega/types"
 )
 
@@ -77,5 +76,5 @@ func (m *WithTransformMatcher) MatchMayChangeInTheFuture(_ interface{}) bool {
 	// Querying the next matcher is fine if the transformer always will return the same value.
 	// But if the transformer is non-deterministic and returns a different value each time, then there
 	// is no point in querying the next matcher, since it can only comment on the last transformed value.
-	return oraclematcher.MatchMayChangeInTheFuture(m.Matcher, m.transformedValue)
+	return types.MatchMayChangeInTheFuture(m.Matcher, m.transformedValue)
 }