podman

1
// untested sections: 6
2

3
package gstruct
4

5
import (
6
	"errors"
7
	"fmt"
8
	"reflect"
9
	"runtime/debug"
10
	"strings"
11

12
	"github.com/onsi/gomega/format"
13
	errorsutil "github.com/onsi/gomega/gstruct/errors"
14
	"github.com/onsi/gomega/types"
15
)
16

17
//MatchAllFields succeeds if every field of a struct matches the field matcher associated with
18
//it, and every element matcher is matched.
19
//    actual := struct{
20
//      A int
21
//      B []bool
22
//      C string
23
//    }{
24
//      A: 5,
25
//      B: []bool{true, false},
26
//      C: "foo",
27
//    }
28
//
29
//    Expect(actual).To(MatchAllFields(Fields{
30
//      "A": Equal(5),
31
//      "B": ConsistOf(true, false),
32
//      "C": Equal("foo"),
33
//    }))
34
func MatchAllFields(fields Fields) types.GomegaMatcher {
35
	return &FieldsMatcher{
36
		Fields: fields,
37
	}
38
}
39

40
//MatchFields succeeds if each element of a struct matches the field matcher associated with
41
//it. It can ignore extra fields and/or missing fields.
42
//    actual := struct{
43
//      A int
44
//      B []bool
45
//      C string
46
//    }{
47
//      A: 5,
48
//      B: []bool{true, false},
49
//      C: "foo",
50
//    }
51
//
52
//    Expect(actual).To(MatchFields(IgnoreExtras, Fields{
53
//      "A": Equal(5),
54
//      "B": ConsistOf(true, false),
55
//    }))
56
//    Expect(actual).To(MatchFields(IgnoreMissing, Fields{
57
//      "A": Equal(5),
58
//      "B": ConsistOf(true, false),
59
//      "C": Equal("foo"),
60
//      "D": Equal("extra"),
61
//    }))
62
func MatchFields(options Options, fields Fields) types.GomegaMatcher {
63
	return &FieldsMatcher{
64
		Fields:        fields,
65
		IgnoreExtras:  options&IgnoreExtras != 0,
66
		IgnoreMissing: options&IgnoreMissing != 0,
67
	}
68
}
69

70
type FieldsMatcher struct {
71
	// Matchers for each field.
72
	Fields Fields
73

74
	// Whether to ignore extra elements or consider it an error.
75
	IgnoreExtras bool
76
	// Whether to ignore missing elements or consider it an error.
77
	IgnoreMissing bool
78

79
	// State.
80
	failures []error
81
}
82

83
// Field name to matcher.
84
type Fields map[string]types.GomegaMatcher
85

86
func (m *FieldsMatcher) Match(actual interface{}) (success bool, err error) {
87
	if reflect.TypeOf(actual).Kind() != reflect.Struct {
88
		return false, fmt.Errorf("%v is type %T, expected struct", actual, actual)
89
	}
90

91
	m.failures = m.matchFields(actual)
92
	if len(m.failures) > 0 {
93
		return false, nil
94
	}
95
	return true, nil
96
}
97

98
func (m *FieldsMatcher) matchFields(actual interface{}) (errs []error) {
99
	val := reflect.ValueOf(actual)
100
	typ := val.Type()
101
	fields := map[string]bool{}
102
	for i := 0; i < val.NumField(); i++ {
103
		fieldName := typ.Field(i).Name
104
		fields[fieldName] = true
105

106
		err := func() (err error) {
107
			// This test relies heavily on reflect, which tends to panic.
108
			// Recover here to provide more useful error messages in that case.
109
			defer func() {
110
				if r := recover(); r != nil {
111
					err = fmt.Errorf("panic checking %+v: %v\n%s", actual, r, debug.Stack())
112
				}
113
			}()
114

115
			matcher, expected := m.Fields[fieldName]
116
			if !expected {
117
				if !m.IgnoreExtras {
118
					return fmt.Errorf("unexpected field %s: %+v", fieldName, actual)
119
				}
120
				return nil
121
			}
122

123
			field := val.Field(i).Interface()
124

125
			match, err := matcher.Match(field)
126
			if err != nil {
127
				return err
128
			} else if !match {
129
				if nesting, ok := matcher.(errorsutil.NestingMatcher); ok {
130
					return errorsutil.AggregateError(nesting.Failures())
131
				}
132
				return errors.New(matcher.FailureMessage(field))
133
			}
134
			return nil
135
		}()
136
		if err != nil {
137
			errs = append(errs, errorsutil.Nest("."+fieldName, err))
138
		}
139
	}
140

141
	for field := range m.Fields {
142
		if !fields[field] && !m.IgnoreMissing {
143
			errs = append(errs, fmt.Errorf("missing expected field %s", field))
144
		}
145
	}
146

147
	return errs
148
}
149

150
func (m *FieldsMatcher) FailureMessage(actual interface{}) (message string) {
151
	failures := make([]string, len(m.failures))
152
	for i := range m.failures {
153
		failures[i] = m.failures[i].Error()
154
	}
155
	return format.Message(reflect.TypeOf(actual).Name(),
156
		fmt.Sprintf("to match fields: {\n%v\n}\n", strings.Join(failures, "\n")))
157
}
158

159
func (m *FieldsMatcher) NegatedFailureMessage(actual interface{}) (message string) {
160
	return format.Message(actual, "not to match fields")
161
}
162

163
func (m *FieldsMatcher) Failures() []error {
164
	return m.failures
165
}
166