build(deps): bump github.com/onsi/gomega from 1.15.0 to 1.24.2

Bumps [github.com/onsi/gomega](https://github.com/onsi/gomega) from 1.15.0 to 1.24.2.
- [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.15.0...v1.24.2)

---
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>

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Signed-off-by: Matthieu MOREL <matthieu.morel35@gmail.com>

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

@@ -0,0 +1,99 @@
+package matchers
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"github.com/onsi/gomega/format"
+)
+
+// missingFieldError represents a missing field extraction error that
+// HaveExistingFieldMatcher can ignore, as opposed to other, sever field
+// extraction errors, such as nil pointers, et cetera.
+type missingFieldError string
+
+func (e missingFieldError) Error() string {
+	return string(e)
+}
+
+func extractField(actual interface{}, field string, matchername string) (interface{}, error) {
+	fields := strings.SplitN(field, ".", 2)
+	actualValue := reflect.ValueOf(actual)
+
+	if actualValue.Kind() == reflect.Ptr {
+		actualValue = actualValue.Elem()
+	}
+	if actualValue == (reflect.Value{}) {
+		return nil, fmt.Errorf("%s encountered nil while dereferencing a pointer of type %T.", matchername, actual)
+	}
+
+	if actualValue.Kind() != reflect.Struct {
+		return nil, fmt.Errorf("%s encountered:\n%s\nWhich is not a struct.", matchername, format.Object(actual, 1))
+	}
+
+	var extractedValue reflect.Value
+
+	if strings.HasSuffix(fields[0], "()") {
+		extractedValue = actualValue.MethodByName(strings.TrimSuffix(fields[0], "()"))
+		if extractedValue == (reflect.Value{}) && actualValue.CanAddr() {
+			extractedValue = actualValue.Addr().MethodByName(strings.TrimSuffix(fields[0], "()"))
+		}
+		if extractedValue == (reflect.Value{}) {
+			return nil, missingFieldError(fmt.Sprintf("%s could not find method named '%s' in struct of type %T.", matchername, fields[0], actual))
+		}
+		t := extractedValue.Type()
+		if t.NumIn() != 0 || t.NumOut() != 1 {
+			return nil, fmt.Errorf("%s found an invalid method named '%s' in struct of type %T.\nMethods must take no arguments and return exactly one value.", matchername, fields[0], actual)
+		}
+		extractedValue = extractedValue.Call([]reflect.Value{})[0]
+	} else {
+		extractedValue = actualValue.FieldByName(fields[0])
+		if extractedValue == (reflect.Value{}) {
+			return nil, missingFieldError(fmt.Sprintf("%s could not find field named '%s' in struct:\n%s", matchername, fields[0], format.Object(actual, 1)))
+		}
+	}
+
+	if len(fields) == 1 {
+		return extractedValue.Interface(), nil
+	} else {
+		return extractField(extractedValue.Interface(), fields[1], matchername)
+	}
+}
+
+type HaveFieldMatcher struct {
+	Field    string
+	Expected interface{}
+
+	extractedField  interface{}
+	expectedMatcher omegaMatcher
+}
+
+func (matcher *HaveFieldMatcher) Match(actual interface{}) (success bool, err error) {
+	matcher.extractedField, err = extractField(actual, matcher.Field, "HaveField")
+	if err != nil {
+		return false, err
+	}
+
+	var isMatcher bool
+	matcher.expectedMatcher, isMatcher = matcher.Expected.(omegaMatcher)
+	if !isMatcher {
+		matcher.expectedMatcher = &EqualMatcher{Expected: matcher.Expected}
+	}
+
+	return matcher.expectedMatcher.Match(matcher.extractedField)
+}
+
+func (matcher *HaveFieldMatcher) FailureMessage(actual interface{}) (message string) {
+	message = fmt.Sprintf("Value for field '%s' failed to satisfy matcher.\n", matcher.Field)
+	message += matcher.expectedMatcher.FailureMessage(matcher.extractedField)
+
+	return message
+}
+
+func (matcher *HaveFieldMatcher) NegatedFailureMessage(actual interface{}) (message string) {
+	message = fmt.Sprintf("Value for field '%s' satisfied matcher, but should not have.\n", matcher.Field)
+	message += matcher.expectedMatcher.NegatedFailureMessage(matcher.extractedField)
+
+	return message
+}