-
Notifications
You must be signed in to change notification settings - Fork 38k
/
JsonPathRequestMatchers.java
303 lines (275 loc) · 10.3 KB
/
JsonPathRequestMatchers.java
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
/*
* Copyright 2002-2018 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.test.web.client.match;
import java.io.IOException;
import java.text.ParseException;
import com.jayway.jsonpath.JsonPath;
import org.hamcrest.Matcher;
import org.springframework.http.client.ClientHttpRequest;
import org.springframework.mock.http.client.MockClientHttpRequest;
import org.springframework.test.util.JsonPathExpectationsHelper;
import org.springframework.test.web.client.RequestMatcher;
/**
* Factory for assertions on the request content using
* <a href="https://github.com/jayway/JsonPath">JsonPath</a> expressions.
*
* <p>An instance of this class is typically accessed via
* {@link MockRestRequestMatchers#jsonPath(String, Matcher)} or
* {@link MockRestRequestMatchers#jsonPath(String, Object...)}.
*
* @author Rossen Stoyanchev
* @author Sam Brannen
* @since 3.2
*/
public class JsonPathRequestMatchers {
private final JsonPathExpectationsHelper jsonPathHelper;
/**
* Protected constructor.
* <p>Use {@link MockRestRequestMatchers#jsonPath(String, Matcher)} or
* {@link MockRestRequestMatchers#jsonPath(String, Object...)}.
* @param expression the {@link JsonPath} expression; never {@code null} or empty
* @param args arguments to parameterize the {@code JsonPath} expression with,
* using formatting specifiers defined in {@link String#format(String, Object...)}
*/
protected JsonPathRequestMatchers(String expression, Object ... args) {
this.jsonPathHelper = new JsonPathExpectationsHelper(expression, args);
}
/**
* Evaluate the JSON path expression against the request content and
* assert the resulting value with the given Hamcrest {@link Matcher}.
*/
public <T> RequestMatcher value(final Matcher<T> matcher) {
return new AbstractJsonPathRequestMatcher() {
@Override
protected void matchInternal(MockClientHttpRequest request) throws IOException, ParseException {
JsonPathRequestMatchers.this.jsonPathHelper.assertValue(request.getBodyAsString(), matcher);
}
};
}
/**
* An overloaded variant of {@link #value(Matcher)} that also accepts a
* target type for the resulting value that the matcher can work reliably
* against.
* <p>This can be useful for matching numbers reliably — for example,
* to coerce an integer into a double.
* @since 4.3.3
*/
public <T> RequestMatcher value(final Matcher<T> matcher, final Class<T> targetType) {
return new AbstractJsonPathRequestMatcher() {
@Override
protected void matchInternal(MockClientHttpRequest request) throws IOException, ParseException {
String body = request.getBodyAsString();
JsonPathRequestMatchers.this.jsonPathHelper.assertValue(body, matcher, targetType);
}
};
}
/**
* Evaluate the JSON path expression against the request content and
* assert that the result is equal to the supplied value.
*/
public RequestMatcher value(final Object expectedValue) {
return new AbstractJsonPathRequestMatcher() {
@Override
protected void matchInternal(MockClientHttpRequest request) throws IOException, ParseException {
JsonPathRequestMatchers.this.jsonPathHelper.assertValue(request.getBodyAsString(), expectedValue);
}
};
}
/**
* Evaluate the JSON path expression against the request content and
* assert that a non-null value exists at the given path.
* <p>If the JSON path expression is not {@linkplain JsonPath#isDefinite
* definite}, this method asserts that the value at the given path is not
* <em>empty</em>.
*/
public RequestMatcher exists() {
return new AbstractJsonPathRequestMatcher() {
@Override
protected void matchInternal(MockClientHttpRequest request) throws IOException, ParseException {
JsonPathRequestMatchers.this.jsonPathHelper.exists(request.getBodyAsString());
}
};
}
/**
* Evaluate the JSON path expression against the request content and
* assert that a value does not exist at the given path.
* <p>If the JSON path expression is not {@linkplain JsonPath#isDefinite
* definite}, this method asserts that the value at the given path is
* <em>empty</em>.
*/
public RequestMatcher doesNotExist() {
return new AbstractJsonPathRequestMatcher() {
@Override
protected void matchInternal(MockClientHttpRequest request) throws IOException, ParseException {
JsonPathRequestMatchers.this.jsonPathHelper.doesNotExist(request.getBodyAsString());
}
};
}
/**
* Evaluate the JSON path expression against the response content
* and assert that a value, possibly {@code null}, exists.
* <p>If the JSON path expression is not
* {@linkplain JsonPath#isDefinite() definite}, this method asserts
* that the list of values at the given path is not <em>empty</em>.
* @since 5.0.3
* @see #exists()
* @see #isNotEmpty()
*/
public RequestMatcher hasJsonPath() {
return new AbstractJsonPathRequestMatcher() {
@Override
protected void matchInternal(MockClientHttpRequest request) {
JsonPathRequestMatchers.this.jsonPathHelper.hasJsonPath(request.getBodyAsString());
}
};
}
/**
* Evaluate the JSON path expression against the supplied {@code content}
* and assert that a value, including {@code null} values, does not exist
* at the given path.
* <p>If the JSON path expression is not
* {@linkplain JsonPath#isDefinite() definite}, this method asserts
* that the list of values at the given path is <em>empty</em>.
* @since 5.0.3
* @see #doesNotExist()
* @see #isEmpty()
*/
public RequestMatcher doesNotHaveJsonPath() {
return new AbstractJsonPathRequestMatcher() {
@Override
protected void matchInternal(MockClientHttpRequest request) {
JsonPathRequestMatchers.this.jsonPathHelper.doesNotHaveJsonPath(request.getBodyAsString());
}
};
}
/**
* Evaluate the JSON path expression against the request content and
* assert that an empty value exists at the given path.
* <p>For the semantics of <em>empty</em>, consult the Javadoc for
* {@link org.springframework.util.ObjectUtils#isEmpty(Object)}.
* @since 4.2.1
* @see #isNotEmpty()
* @see #exists()
* @see #doesNotExist()
*/
public RequestMatcher isEmpty() {
return new AbstractJsonPathRequestMatcher() {
@Override
public void matchInternal(MockClientHttpRequest request) throws IOException, ParseException {
JsonPathRequestMatchers.this.jsonPathHelper.assertValueIsEmpty(request.getBodyAsString());
}
};
}
/**
* Evaluate the JSON path expression against the request content and
* assert that a non-empty value exists at the given path.
* <p>For the semantics of <em>empty</em>, consult the Javadoc for
* {@link org.springframework.util.ObjectUtils#isEmpty(Object)}.
* @since 4.2.1
* @see #isEmpty()
* @see #exists()
* @see #doesNotExist()
*/
public RequestMatcher isNotEmpty() {
return new AbstractJsonPathRequestMatcher() {
@Override
public void matchInternal(MockClientHttpRequest request) throws IOException, ParseException {
JsonPathRequestMatchers.this.jsonPathHelper.assertValueIsNotEmpty(request.getBodyAsString());
}
};
}
/**
* Evaluate the JSON path expression against the request content and
* assert that the result is a {@link String}.
* @since 4.2.1
*/
public RequestMatcher isString() {
return new AbstractJsonPathRequestMatcher() {
@Override
public void matchInternal(MockClientHttpRequest request) throws IOException, ParseException {
JsonPathRequestMatchers.this.jsonPathHelper.assertValueIsString(request.getBodyAsString());
}
};
}
/**
* Evaluate the JSON path expression against the request content and
* assert that the result is a {@link Boolean}.
* @since 4.2.1
*/
public RequestMatcher isBoolean() {
return new AbstractJsonPathRequestMatcher() {
@Override
public void matchInternal(MockClientHttpRequest request) throws IOException, ParseException {
JsonPathRequestMatchers.this.jsonPathHelper.assertValueIsBoolean(request.getBodyAsString());
}
};
}
/**
* Evaluate the JSON path expression against the request content and
* assert that the result is a {@link Number}.
* @since 4.2.1
*/
public RequestMatcher isNumber() {
return new AbstractJsonPathRequestMatcher() {
@Override
public void matchInternal(MockClientHttpRequest request) throws IOException, ParseException {
JsonPathRequestMatchers.this.jsonPathHelper.assertValueIsNumber(request.getBodyAsString());
}
};
}
/**
* Evaluate the JSON path expression against the request content and
* assert that the result is an array.
*/
public RequestMatcher isArray() {
return new AbstractJsonPathRequestMatcher() {
@Override
protected void matchInternal(MockClientHttpRequest request) throws IOException, ParseException {
JsonPathRequestMatchers.this.jsonPathHelper.assertValueIsArray(request.getBodyAsString());
}
};
}
/**
* Evaluate the JSON path expression against the request content and
* assert that the result is a {@link java.util.Map}.
* @since 4.2.1
*/
public RequestMatcher isMap() {
return new AbstractJsonPathRequestMatcher() {
@Override
public void matchInternal(MockClientHttpRequest request) throws IOException, ParseException {
JsonPathRequestMatchers.this.jsonPathHelper.assertValueIsMap(request.getBodyAsString());
}
};
}
/**
* Abstract base class for {@code JsonPath}-based {@link RequestMatcher}s.
* @see #matchInternal
*/
private abstract static class AbstractJsonPathRequestMatcher implements RequestMatcher {
@Override
public final void match(ClientHttpRequest request) throws IOException, AssertionError {
try {
MockClientHttpRequest mockRequest = (MockClientHttpRequest) request;
matchInternal(mockRequest);
}
catch (ParseException ex) {
throw new AssertionError("Failed to parse JSON request content", ex);
}
}
abstract void matchInternal(MockClientHttpRequest request) throws IOException, ParseException;
}
}