1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
|
package gstruct_test
import (
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
. "github.com/onsi/gomega/gstruct"
)
var _ = Describe("Slice", func() {
allElements := []string{"a", "b"}
missingElements := []string{"a"}
extraElements := []string{"a", "b", "c"}
duplicateElements := []string{"a", "a", "b"}
empty := []string{}
var nils []string
It("should strictly match all elements", func() {
m := MatchAllElements(id, Elements{
"b": Equal("b"),
"a": Equal("a"),
})
Ω(allElements).Should(m, "should match all elements")
Ω(missingElements).ShouldNot(m, "should fail with missing elements")
Ω(extraElements).ShouldNot(m, "should fail with extra elements")
Ω(duplicateElements).ShouldNot(m, "should fail with duplicate elements")
Ω(nils).ShouldNot(m, "should fail with an uninitialized slice")
m = MatchAllElements(id, Elements{
"a": Equal("a"),
"b": Equal("fail"),
})
Ω(allElements).ShouldNot(m, "should run nested matchers")
m = MatchAllElements(id, Elements{})
Ω(empty).Should(m, "should handle empty slices")
Ω(allElements).ShouldNot(m, "should handle only empty slices")
Ω(nils).Should(m, "should handle nil slices")
})
It("should ignore extra elements", func() {
m := MatchElements(id, IgnoreExtras, Elements{
"b": Equal("b"),
"a": Equal("a"),
})
Ω(allElements).Should(m, "should match all elements")
Ω(missingElements).ShouldNot(m, "should fail with missing elements")
Ω(extraElements).Should(m, "should ignore extra elements")
Ω(duplicateElements).ShouldNot(m, "should fail with duplicate elements")
Ω(nils).ShouldNot(m, "should fail with an uninitialized slice")
})
It("should ignore missing elements", func() {
m := MatchElements(id, IgnoreMissing, Elements{
"a": Equal("a"),
"b": Equal("b"),
})
Ω(allElements).Should(m, "should match all elements")
Ω(missingElements).Should(m, "should ignore missing elements")
Ω(extraElements).ShouldNot(m, "should fail with extra elements")
Ω(duplicateElements).ShouldNot(m, "should fail with duplicate elements")
Ω(nils).Should(m, "should ignore an uninitialized slice")
})
It("should ignore missing and extra elements", func() {
m := MatchElements(id, IgnoreMissing|IgnoreExtras, Elements{
"a": Equal("a"),
"b": Equal("b"),
})
Ω(allElements).Should(m, "should match all elements")
Ω(missingElements).Should(m, "should ignore missing elements")
Ω(extraElements).Should(m, "should ignore extra elements")
Ω(duplicateElements).ShouldNot(m, "should fail with duplicate elements")
Ω(nils).Should(m, "should ignore an uninitialized slice")
m = MatchElements(id, IgnoreExtras|IgnoreMissing, Elements{
"a": Equal("a"),
"b": Equal("fail"),
})
Ω(allElements).ShouldNot(m, "should run nested matchers")
})
Context("with elements that share a key", func() {
nonUniqueID := func(element interface{}) string {
return element.(string)[0:1]
}
allElements := []string{"a123", "a213", "b321"}
includingBadElements := []string{"a123", "b123", "b5555"}
extraElements := []string{"a123", "b1234", "c345"}
missingElements := []string{"b123", "b1234", "b1345"}
It("should strictly allow multiple matches", func() {
m := MatchElements(nonUniqueID, AllowDuplicates, Elements{
"a": ContainSubstring("1"),
"b": ContainSubstring("1"),
})
Ω(allElements).Should(m, "should match all elements")
Ω(includingBadElements).ShouldNot(m, "should reject if a member fails the matcher")
Ω(extraElements).ShouldNot(m, "should reject with extra keys")
Ω(missingElements).ShouldNot(m, "should reject with missing keys")
Ω(nils).ShouldNot(m, "should fail with an uninitialized slice")
})
It("should ignore missing", func() {
m := MatchElements(nonUniqueID, AllowDuplicates|IgnoreMissing, Elements{
"a": ContainSubstring("1"),
"b": ContainSubstring("1"),
})
Ω(allElements).Should(m, "should match all elements")
Ω(includingBadElements).ShouldNot(m, "should reject if a member fails the matcher")
Ω(extraElements).ShouldNot(m, "should reject with extra keys")
Ω(missingElements).Should(m, "should allow missing keys")
Ω(nils).Should(m, "should allow an uninitialized slice")
})
It("should ignore extras", func() {
m := MatchElements(nonUniqueID, AllowDuplicates|IgnoreExtras, Elements{
"a": ContainSubstring("1"),
"b": ContainSubstring("1"),
})
Ω(allElements).Should(m, "should match all elements")
Ω(includingBadElements).ShouldNot(m, "should reject if a member fails the matcher")
Ω(extraElements).Should(m, "should allow extra keys")
Ω(missingElements).ShouldNot(m, "should reject missing keys")
Ω(nils).ShouldNot(m, "should reject an uninitialized slice")
})
It("should ignore missing and extras", func() {
m := MatchElements(nonUniqueID, AllowDuplicates|IgnoreExtras|IgnoreMissing, Elements{
"a": ContainSubstring("1"),
"b": ContainSubstring("1"),
})
Ω(allElements).Should(m, "should match all elements")
Ω(includingBadElements).ShouldNot(m, "should reject if a member fails the matcher")
Ω(extraElements).Should(m, "should allow extra keys")
Ω(missingElements).Should(m, "should allow missing keys")
Ω(nils).Should(m, "should allow an uninitialized slice")
})
})
})
func id(element interface{}) string {
return element.(string)
}
|
