1 // Copyright 2021 gRPC authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "src/core/lib/matchers/matchers.h"
16
17 #include "absl/status/status.h"
18 #include "gtest/gtest.h"
19
20 namespace grpc_core {
21
TEST(StringMatcherTest,ExactMatchCaseSensitive)22 TEST(StringMatcherTest, ExactMatchCaseSensitive) {
23 auto string_matcher =
24 StringMatcher::Create(StringMatcher::Type::kExact,
25 /*matcher=*/"exact", /*case_sensitive=*/true);
26 ASSERT_TRUE(string_matcher.ok());
27 EXPECT_TRUE(string_matcher->Match("exact"));
28 EXPECT_FALSE(string_matcher->Match("Exact"));
29 EXPECT_FALSE(string_matcher->Match("exacz"));
30 }
31
TEST(StringMatcherTest,ExactMatchCaseInsensitive)32 TEST(StringMatcherTest, ExactMatchCaseInsensitive) {
33 auto string_matcher =
34 StringMatcher::Create(StringMatcher::Type::kExact,
35 /*matcher=*/"exact", /*case_sensitive=*/false);
36 ASSERT_TRUE(string_matcher.ok());
37 EXPECT_TRUE(string_matcher->Match("Exact"));
38 EXPECT_FALSE(string_matcher->Match("Exacz"));
39 }
40
TEST(StringMatcherTest,PrefixMatchCaseSensitive)41 TEST(StringMatcherTest, PrefixMatchCaseSensitive) {
42 auto string_matcher = StringMatcher::Create(StringMatcher::Type::kPrefix,
43 /*matcher=*/"prefix",
44 /*case_sensitive=*/true);
45 ASSERT_TRUE(string_matcher.ok());
46 EXPECT_TRUE(string_matcher->Match("prefix-test"));
47 EXPECT_FALSE(string_matcher->Match("xx-prefix-test"));
48 EXPECT_FALSE(string_matcher->Match("Prefix-test"));
49 EXPECT_FALSE(string_matcher->Match("pre-test"));
50 }
51
TEST(StringMatcherTest,PrefixMatchCaseInsensitive)52 TEST(StringMatcherTest, PrefixMatchCaseInsensitive) {
53 auto string_matcher = StringMatcher::Create(StringMatcher::Type::kPrefix,
54 /*matcher=*/"prefix",
55 /*case_sensitive=*/false);
56 ASSERT_TRUE(string_matcher.ok());
57 EXPECT_TRUE(string_matcher->Match("PREfix-test"));
58 EXPECT_FALSE(string_matcher->Match("xx-PREfix-test"));
59 EXPECT_FALSE(string_matcher->Match("PRE-test"));
60 }
61
TEST(StringMatcherTest,SuffixMatchCaseSensitive)62 TEST(StringMatcherTest, SuffixMatchCaseSensitive) {
63 auto string_matcher = StringMatcher::Create(StringMatcher::Type::kSuffix,
64 /*matcher=*/"suffix",
65 /*case_sensitive=*/true);
66 ASSERT_TRUE(string_matcher.ok());
67 EXPECT_TRUE(string_matcher->Match("test-suffix"));
68 EXPECT_FALSE(string_matcher->Match("test-Suffix"));
69 EXPECT_FALSE(string_matcher->Match("test-suffix-xx"));
70 EXPECT_FALSE(string_matcher->Match("test-suffiz"));
71 }
72
TEST(StringMatcherTest,SuffixMatchCaseInSensitive)73 TEST(StringMatcherTest, SuffixMatchCaseInSensitive) {
74 auto string_matcher = StringMatcher::Create(StringMatcher::Type::kSuffix,
75 /*matcher=*/"suffix",
76 /*case_sensitive=*/false);
77 ASSERT_TRUE(string_matcher.ok());
78 EXPECT_TRUE(string_matcher->Match("Test-SUFFIX"));
79 EXPECT_FALSE(string_matcher->Match("Test-SUFFIX-xx"));
80 EXPECT_FALSE(string_matcher->Match("Test-SUFFIZ"));
81 }
82
TEST(StringMatcherTest,InvalidRegex)83 TEST(StringMatcherTest, InvalidRegex) {
84 auto string_matcher = StringMatcher::Create(StringMatcher::Type::kSafeRegex,
85 /*matcher=*/"a[b-a]",
86 /*case_sensitive=*/true);
87 EXPECT_FALSE(string_matcher.ok());
88 EXPECT_EQ(string_matcher.status().code(), absl::StatusCode::kInvalidArgument);
89 EXPECT_EQ(string_matcher.status().message(),
90 "Invalid regex string specified in matcher: "
91 "invalid character class range: b-a")
92 << string_matcher.status();
93 }
94
TEST(StringMatcherTest,SafeRegexMatchCaseSensitive)95 TEST(StringMatcherTest, SafeRegexMatchCaseSensitive) {
96 auto string_matcher = StringMatcher::Create(StringMatcher::Type::kSafeRegex,
97 /*matcher=*/"regex.*");
98 ASSERT_TRUE(string_matcher.ok());
99 EXPECT_TRUE(string_matcher->Match("regex-test"));
100 EXPECT_FALSE(string_matcher->Match("xx-regex-test"));
101 EXPECT_FALSE(string_matcher->Match("Regex-test"));
102 EXPECT_FALSE(string_matcher->Match("test-regex"));
103 }
104
TEST(StringMatcherTest,PresenceMatchUsingSafeRegex)105 TEST(StringMatcherTest, PresenceMatchUsingSafeRegex) {
106 auto string_matcher = StringMatcher::Create(StringMatcher::Type::kSafeRegex,
107 /*matcher=*/".+");
108 ASSERT_TRUE(string_matcher.ok());
109 EXPECT_TRUE(string_matcher->Match("any-value"));
110 EXPECT_FALSE(string_matcher->Match(""));
111 }
112
TEST(StringMatcherTest,ContainsMatchCaseSensitive)113 TEST(StringMatcherTest, ContainsMatchCaseSensitive) {
114 auto string_matcher = StringMatcher::Create(StringMatcher::Type::kContains,
115 /*matcher=*/"contains",
116 /*case_sensitive=*/true);
117 ASSERT_TRUE(string_matcher.ok());
118 EXPECT_TRUE(string_matcher->Match("test-contains"));
119 EXPECT_TRUE(string_matcher->Match("test-contains-test"));
120 EXPECT_FALSE(string_matcher->Match("test-Contains"));
121 EXPECT_FALSE(string_matcher->Match("test-containz"));
122 }
123
TEST(StringMatcherTest,ContainsMatchCaseInSensitive)124 TEST(StringMatcherTest, ContainsMatchCaseInSensitive) {
125 auto string_matcher = StringMatcher::Create(StringMatcher::Type::kContains,
126 /*matcher=*/"contains",
127 /*case_sensitive=*/false);
128 ASSERT_TRUE(string_matcher.ok());
129 EXPECT_TRUE(string_matcher->Match("Test-Contains"));
130 EXPECT_TRUE(string_matcher->Match("Test-Contains-Test"));
131 EXPECT_FALSE(string_matcher->Match("Test-Containz"));
132 }
133
TEST(HeaderMatcherTest,StringMatcher)134 TEST(HeaderMatcherTest, StringMatcher) {
135 auto header_matcher =
136 HeaderMatcher::Create(/*name=*/"key", HeaderMatcher::Type::kExact,
137 /*matcher=*/"exact");
138 ASSERT_TRUE(header_matcher.ok());
139 EXPECT_TRUE(header_matcher->Match("exact"));
140 EXPECT_FALSE(header_matcher->Match("Exact"));
141 EXPECT_FALSE(header_matcher->Match("exacz"));
142 EXPECT_FALSE(header_matcher->Match(absl::nullopt));
143 }
144
TEST(HeaderMatcherTest,StringMatcherCaseInsensitive)145 TEST(HeaderMatcherTest, StringMatcherCaseInsensitive) {
146 auto header_matcher =
147 HeaderMatcher::Create(/*name=*/"key", HeaderMatcher::Type::kExact,
148 /*matcher=*/"exact", /*range_start=*/0,
149 /*range_end=*/0, /*present_match=*/false,
150 /*invert_match=*/false, /*case_sensitive=*/false);
151 ASSERT_TRUE(header_matcher.ok());
152 EXPECT_TRUE(header_matcher->Match("exact"));
153 EXPECT_TRUE(header_matcher->Match("Exact"));
154 EXPECT_FALSE(header_matcher->Match("exacz"));
155 EXPECT_FALSE(header_matcher->Match(absl::nullopt));
156 }
157
TEST(HeaderMatcherTest,StringMatcherWithInvertMatch)158 TEST(HeaderMatcherTest, StringMatcherWithInvertMatch) {
159 auto header_matcher =
160 HeaderMatcher::Create(/*name=*/"key", HeaderMatcher::Type::kExact,
161 /*matcher=*/"exact",
162 /*range_start=*/0, /*range_end=*/0,
163 /*present_match=*/false, /*invert_match=*/true);
164 ASSERT_TRUE(header_matcher.ok());
165 EXPECT_FALSE(header_matcher->Match("exact"));
166 EXPECT_TRUE(header_matcher->Match("Exact"));
167 EXPECT_TRUE(header_matcher->Match("exacz"));
168 EXPECT_FALSE(header_matcher->Match(absl::nullopt));
169 }
170
TEST(HeaderMatcherTest,InvalidRegex)171 TEST(HeaderMatcherTest, InvalidRegex) {
172 auto header_matcher =
173 HeaderMatcher::Create(/*name=*/"key", HeaderMatcher::Type::kSafeRegex,
174 /*matcher=*/"a[b-a]",
175 /*range_start=*/0, /*range_end=*/0,
176 /*present_match=*/false, /*invert_match=*/true);
177 EXPECT_FALSE(header_matcher.ok());
178 EXPECT_EQ(header_matcher.status().code(), absl::StatusCode::kInvalidArgument);
179 EXPECT_EQ(header_matcher.status().message(),
180 "Invalid regex string specified in matcher: "
181 "invalid character class range: b-a")
182 << header_matcher.status();
183 }
184
TEST(HeaderMatcherTest,RangeMatcherValidRange)185 TEST(HeaderMatcherTest, RangeMatcherValidRange) {
186 auto header_matcher =
187 HeaderMatcher::Create(/*name=*/"key", HeaderMatcher::Type::kRange,
188 /*matcher=*/"", /*range_start=*/10,
189 /*range_end*/ 20);
190 ASSERT_TRUE(header_matcher.ok());
191 EXPECT_TRUE(header_matcher->Match("16"));
192 EXPECT_TRUE(header_matcher->Match("10"));
193 EXPECT_FALSE(header_matcher->Match("3"));
194 EXPECT_FALSE(header_matcher->Match("20"));
195 EXPECT_FALSE(header_matcher->Match(absl::nullopt));
196 }
197
TEST(HeaderMatcherTest,RangeMatcherValidRangeWithInvertMatch)198 TEST(HeaderMatcherTest, RangeMatcherValidRangeWithInvertMatch) {
199 auto header_matcher = HeaderMatcher::Create(
200 /*name=*/"key", HeaderMatcher::Type::kRange,
201 /*matcher=*/"", /*range_start=*/10,
202 /*range_end=*/20, /*present_match=*/false, /*invert_match=*/true);
203 ASSERT_TRUE(header_matcher.ok());
204 EXPECT_FALSE(header_matcher->Match("16"));
205 EXPECT_FALSE(header_matcher->Match("10"));
206 EXPECT_TRUE(header_matcher->Match("3"));
207 EXPECT_TRUE(header_matcher->Match("20"));
208 EXPECT_FALSE(header_matcher->Match(absl::nullopt));
209 }
210
TEST(HeaderMatcherTest,RangeMatcherInvalidRange)211 TEST(HeaderMatcherTest, RangeMatcherInvalidRange) {
212 auto header_matcher =
213 HeaderMatcher::Create(/*name=*/"key", HeaderMatcher::Type::kRange,
214 /*matcher=*/"", /*range_start=*/20,
215 /*range_end=*/10);
216 EXPECT_FALSE(header_matcher.ok());
217 EXPECT_EQ(header_matcher.status().code(), absl::StatusCode::kInvalidArgument);
218 EXPECT_EQ(
219 header_matcher.status().message(),
220 "Invalid range specifier specified: end cannot be smaller than start.");
221 }
222
TEST(HeaderMatcherTest,PresentMatcherTrue)223 TEST(HeaderMatcherTest, PresentMatcherTrue) {
224 auto header_matcher =
225 HeaderMatcher::Create(/*name=*/"key", HeaderMatcher::Type::kPresent,
226 /*matcher=*/"", /*range_start=*/0,
227 /*range_end=*/0, /*present_match=*/true);
228 ASSERT_TRUE(header_matcher.ok());
229 EXPECT_TRUE(header_matcher->Match("any_value"));
230 EXPECT_FALSE(header_matcher->Match(absl::nullopt));
231 }
232
TEST(HeaderMatcherTest,PresentMatcherTrueWithInvertMatch)233 TEST(HeaderMatcherTest, PresentMatcherTrueWithInvertMatch) {
234 auto header_matcher = HeaderMatcher::Create(
235 /*name=*/"key", HeaderMatcher::Type::kPresent,
236 /*matcher=*/"", /*range_start=*/0,
237 /*range_end=*/0, /*present_match=*/true, /*invert_match=*/true);
238 ASSERT_TRUE(header_matcher.ok());
239 EXPECT_FALSE(header_matcher->Match("any_value"));
240 EXPECT_TRUE(header_matcher->Match(absl::nullopt));
241 }
242
TEST(HeaderMatcherTest,PresentMatcherFalse)243 TEST(HeaderMatcherTest, PresentMatcherFalse) {
244 auto header_matcher =
245 HeaderMatcher::Create(/*name=*/"key", HeaderMatcher::Type::kPresent,
246 /*matcher=*/"", /*range_start=*/0,
247 /*range_end=*/0, /*present_match=*/false);
248 ASSERT_TRUE(header_matcher.ok());
249 EXPECT_FALSE(header_matcher->Match("any_value"));
250 EXPECT_TRUE(header_matcher->Match(absl::nullopt));
251 }
252
TEST(HeaderMatcherTest,PresentMatcherFalseWithInvertMatch)253 TEST(HeaderMatcherTest, PresentMatcherFalseWithInvertMatch) {
254 auto header_matcher = HeaderMatcher::Create(
255 /*name=*/"key", HeaderMatcher::Type::kPresent,
256 /*matcher=*/"", /*range_start=*/0,
257 /*range_end=*/0, /*present_match=*/false, /*invert_match=*/true);
258 ASSERT_TRUE(header_matcher.ok());
259 EXPECT_TRUE(header_matcher->Match("any_value"));
260 EXPECT_FALSE(header_matcher->Match(absl::nullopt));
261 }
262
263 } // namespace grpc_core
264
main(int argc,char ** argv)265 int main(int argc, char** argv) {
266 ::testing::InitGoogleTest(&argc, argv);
267 return RUN_ALL_TESTS();
268 }
269