1 package exprs
2
3 import (
4 "testing"
5
6 "go.einride.tech/aip/filtering"
7 expr "google.golang.org/genproto/googleapis/api/expr/v1alpha1"
8 "google.golang.org/protobuf/testing/protocmp"
9 "gotest.tools/v3/assert"
10 )
11
12 func TestMatch(t *testing.T) {
13 t.Parallel()
14 for _, tt := range []struct {
15 name string
16 expr *expr.Expr
17 matcher Matcher
18 expected bool
19 }{
20 {
21 name: "string: match",
22 matcher: MatchString("string"),
23 expr: filtering.String("string"),
24 expected: true,
25 },
26 {
27 name: "string: another expr",
28 matcher: MatchString("string"),
29 expr: filtering.Text("state"),
30 },
31 {
32 name: "string: wrong string",
33 matcher: MatchString("string"),
34 expr: filtering.String("another string"),
35 },
36 {
37 name: "float: match",
38 matcher: MatchFloat(3.14),
39 expr: filtering.Float(3.14),
40 expected: true,
41 },
42 {
43 name: "float: another expr",
44 matcher: MatchFloat(3.14),
45 expr: filtering.Text("state"),
46 },
47 {
48 name: "float: wrong float",
49 matcher: MatchFloat(3.14),
50 expr: filtering.Float(1.23),
51 },
52 {
53 name: "int: match",
54 matcher: MatchInt(3),
55 expr: filtering.Int(3),
56 expected: true,
57 },
58 {
59 name: "int: another expr",
60 matcher: MatchInt(3),
61 expr: filtering.Text("state"),
62 },
63 {
64 name: "int: wrong int",
65 matcher: MatchInt(3),
66 expr: filtering.Int(1),
67 },
68 {
69 name: "text: match",
70 matcher: MatchText("text"),
71 expr: filtering.Text("text"),
72 expected: true,
73 },
74 {
75 name: "text: another expr",
76 matcher: MatchText("text"),
77 expr: filtering.Text("state"),
78 },
79 {
80 name: "text: wrong text",
81 matcher: MatchText("text"),
82 expr: filtering.Text("another_text"),
83 },
84 {
85 name: "member: match",
86 matcher: MatchMember(MatchText("operand"), "field"),
87 expr: filtering.Member(filtering.Text("operand"), "field"),
88 expected: true,
89 },
90 {
91 name: "member: another expr",
92 matcher: MatchMember(MatchText("operand"), "field"),
93 expr: filtering.Text("state"),
94 },
95 {
96 name: "member: wrong field",
97 matcher: MatchMember(MatchText("operand"), "field"),
98 expr: filtering.Member(filtering.Text("operand"), "another_field"),
99 },
100 {
101 name: "function: match",
102 matcher: MatchFunction(
103 "=",
104 MatchString("lhs"),
105 MatchString("rhs"),
106 ),
107 expr: filtering.Function(
108 "=",
109 filtering.String("lhs"),
110 filtering.String("rhs"),
111 ),
112 expected: true,
113 },
114 {
115 name: "function: another expr",
116 matcher: MatchFunction(
117 "=",
118 MatchString("lhs"),
119 MatchString("rhs"),
120 ),
121 expr: filtering.Text("state"),
122 },
123 {
124 name: "function: wrong number of args",
125 matcher: MatchFunction(
126 "=",
127 MatchString("lhs"),
128 MatchString("rhs"),
129 ),
130 expr: filtering.Function(
131 "=",
132 filtering.String("lhs"),
133 ),
134 },
135 {
136 name: "function: wrong name",
137 matcher: MatchFunction(
138 "=",
139 MatchString("lhs"),
140 MatchString("rhs"),
141 ),
142 expr: filtering.Function(
143 "*",
144 filtering.String("lhs"),
145 filtering.String("rhs"),
146 ),
147 },
148 {
149 name: "function: wrong number of args",
150 matcher: MatchFunction(
151 "=",
152 MatchString("lhs"),
153 MatchString("rhs"),
154 ),
155 expr: filtering.Function(
156 "=",
157 filtering.String("lhs"),
158 ),
159 },
160 } {
161 tt := tt
162 t.Run(tt.name, func(t *testing.T) {
163 t.Parallel()
164 got := tt.matcher(tt.expr)
165 assert.Equal(t, tt.expected, got)
166 })
167 }
168 }
169
170 func TestMatchAny(t *testing.T) {
171 t.Parallel()
172 t.Run("String", func(t *testing.T) {
173 t.Parallel()
174 var val string
175 matcher := MatchAnyString(&val)
176 exp := filtering.String("x")
177
178 assert.Check(t, matcher(exp))
179 assert.Equal(t, "x", val)
180 })
181 t.Run("Float", func(t *testing.T) {
182 t.Parallel()
183 var val float64
184 matcher := MatchAnyFloat(&val)
185 exp := filtering.Float(3.14)
186
187 assert.Check(t, matcher(exp))
188 assert.Equal(t, 3.14, val)
189 })
190 t.Run("Int", func(t *testing.T) {
191 t.Parallel()
192 var val int64
193 matcher := MatchAnyInt(&val)
194 exp := filtering.Int(3)
195
196 assert.Check(t, matcher(exp))
197 assert.Equal(t, int64(3), val)
198 })
199 t.Run("Text", func(t *testing.T) {
200 t.Parallel()
201 var val string
202 matcher := MatchAnyText(&val)
203 exp := filtering.Text("x")
204
205 assert.Check(t, matcher(exp))
206 assert.Equal(t, "x", val)
207 })
208 t.Run("Member", func(t *testing.T) {
209 t.Parallel()
210 var operand, field string
211 matcher := MatchAnyMember(MatchAnyText(&operand), &field)
212 exp := filtering.Member(filtering.Text("operand"), "field")
213
214 assert.Check(t, matcher(exp))
215 assert.Equal(t, "operand", operand)
216 assert.Equal(t, "field", field)
217 })
218 t.Run("Function", func(t *testing.T) {
219 t.Parallel()
220 var fn, lhs, rhs string
221 matcher := MatchAnyFunction(&fn, MatchAnyString(&lhs), MatchAnyString(&rhs))
222 exp := filtering.Function("=", filtering.String("lhs"), filtering.String("rhs"))
223
224 assert.Check(t, matcher(exp))
225 assert.Equal(t, "=", fn)
226 assert.Equal(t, "lhs", lhs)
227 assert.Equal(t, "rhs", rhs)
228 })
229 t.Run("Any", func(t *testing.T) {
230 t.Parallel()
231 ex := &expr.Expr{}
232 matcher := MatchAny(&ex)
233 exp := filtering.Function("=", filtering.String("lhs"), filtering.String("rhs"))
234
235 assert.Check(t, matcher(exp))
236 assert.DeepEqual(t, exp, ex, protocmp.Transform())
237 })
238 }
239
View as plain text