This is an automated email from the ASF dual-hosted git repository.
jamesbognar pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/juneau.git
The following commit(s) were added to refs/heads/master by this push:
new 6a15bfc REST refactoring.
6a15bfc is described below
commit 6a15bfc9b37a336b9155680d7f6f5d335e5ac5b9
Author: JamesBognar <[email protected]>
AuthorDate: Wed Feb 10 12:42:14 2021 -0500
REST refactoring.
---
.../{RestResponseBody.java => ResponseBody.java} | 32 ++---
...RestResponseHeader.java => ResponseHeader.java} | 8 +-
...rtion.java => ResponseStatusLineAssertion.java} | 4 +-
.../org/apache/juneau/rest/client/RestClient.java | 130 ++++++++++-----------
.../juneau/rest/client/RestClientBuilder.java | 4 +-
.../org/apache/juneau/rest/client/RestRequest.java | 4 +-
.../apache/juneau/rest/client/RestResponse.java | 68 +++++------
.../java/org/apache/juneau/rest/RestRequest.java | 14 ++-
.../rest/annotation/ResponseHeader_Test.java | 2 +-
.../client/RestClient_Config_BeanContext_Test.java | 28 ++---
.../client/RestClient_Config_RestClient_Test.java | 10 +-
.../juneau/rest/client/RestClient_Paths_Test.java | 24 ++--
.../rest/client/RestClient_Response_Body_Test.java | 10 +-
.../client/RestClient_Response_Headers_Test.java | 118 +++++++++----------
.../rest/client/RestClient_Response_Test.java | 2 +-
.../apache/juneau/rest/client/RestClient_Test.java | 4 +-
16 files changed, 234 insertions(+), 228 deletions(-)
diff --git
a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestResponseBody.java
b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/ResponseBody.java
similarity index 98%
rename from
juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestResponseBody.java
rename to
juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/ResponseBody.java
index 6c83177..4d95d9a 100644
---
a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestResponseBody.java
+++
b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/ResponseBody.java
@@ -47,7 +47,7 @@ import org.apache.juneau.utils.*;
* <li class='link'>{@doc juneau-rest-client}
* </ul>
*/
-public class RestResponseBody implements HttpEntity {
+public class ResponseBody implements HttpEntity {
private static final HttpEntity NULL_ENTITY = new HttpEntity() {
@@ -68,12 +68,12 @@ public class RestResponseBody implements HttpEntity {
@Override
public Header getContentType() {
- return RestResponseHeader.NULL_HEADER;
+ return ResponseHeader.NULL_HEADER;
}
@Override
public Header getContentEncoding() {
- return RestResponseHeader.NULL_HEADER;
+ return ResponseHeader.NULL_HEADER;
}
@Override
@@ -111,7 +111,7 @@ public class RestResponseBody implements HttpEntity {
* @param response The response object.
* @param parser The parser to use to consume the body. Can be
<jk>null</jk>.
*/
- public RestResponseBody(RestClient client, RestRequest request,
RestResponse response, Parser parser) {
+ public ResponseBody(RestClient client, RestRequest request,
RestResponse response, Parser parser) {
this.client = client;
this.request = request;
this.response = response;
@@ -133,7 +133,7 @@ public class RestResponseBody implements HttpEntity {
* The new part parser to use for this body.
* @return This object (for method chaining).
*/
- public RestResponseBody parser(Parser value) {
+ public ResponseBody parser(Parser value) {
this.parser = value;
return this;
}
@@ -147,7 +147,7 @@ public class RestResponseBody implements HttpEntity {
* @param value The schema.
* @return This object (for method chaining).
*/
- public RestResponseBody schema(HttpPartSchema value) {
+ public ResponseBody schema(HttpPartSchema value) {
this.schema = value;
return this;
}
@@ -165,7 +165,7 @@ public class RestResponseBody implements HttpEntity {
*
* @return This object (for method chaining).
*/
- public RestResponseBody cache() {
+ public ResponseBody cache() {
this.cached = true;
return this;
}
@@ -511,7 +511,7 @@ public class RestResponseBody implements HttpEntity {
* <li>
* You can also specify any of the following types:
* <ul class='compact'>
- * <li>{@link RestResponseBody}/{@link HttpEntity}
- Returns access to this object.
+ * <li>{@link ResponseBody}/{@link HttpEntity} -
Returns access to this object.
* <li>{@link Reader} - Returns access to the raw
reader of the response.
* <li>{@link InputStream} - Returns access to the
raw input stream of the response.
* <li>{@link BasicHttpResource} - Raw contents
will be serialized to remote resource. Additional headers and media type will
be set on request.
@@ -622,7 +622,7 @@ public class RestResponseBody implements HttpEntity {
* <li>
* You can also specify any of the following types:
* <ul class='compact'>
- * <li>{@link RestResponseBody}/{@link HttpEntity}
- Returns access to this object.
+ * <li>{@link ResponseBody}/{@link HttpEntity} -
Returns access to this object.
* <li>{@link Reader} - Returns access to the raw
reader of the response.
* <li>{@link InputStream} - Returns access to the
raw input stream of the response.
* <li>{@link BasicHttpResource} - Raw contents
will be serialized to remote resource. Additional headers and media type will
be set on request.
@@ -745,7 +745,7 @@ public class RestResponseBody implements HttpEntity {
try {
Class<?> ic = type.getInnerClass();
- if (ic.equals(RestResponseBody.class) ||
ic.equals(HttpEntity.class))
+ if (ic.equals(ResponseBody.class) ||
ic.equals(HttpEntity.class))
return (T)this;
if (ic.equals(Reader.class))
@@ -770,7 +770,7 @@ public class RestResponseBody implements HttpEntity {
return (T)r;
}
- String ct =
firstNonEmpty(response.getHeader("Content-Type").asStringOrElse("text/plain"));
+ String ct =
firstNonEmpty(response.getResponseHeader("Content-Type").asStringOrElse("text/plain"));
if (parser == null)
parser = client.getMatchingParser(ct);
@@ -1612,7 +1612,7 @@ public class RestResponseBody implements HttpEntity {
* <li>
* If no charset was found on the
<code>Content-Type</code> response header, <js>"UTF-8"</js> is assumed.
* <li>
- * When using this method, the body is automatically
cached by calling the {@link RestResponseBody#cache()}.
+ * When using this method, the body is automatically
cached by calling the {@link ResponseBody#cache()}.
* <li>
* The input stream is automatically closed after this
call.
* </ul>
@@ -1722,8 +1722,8 @@ public class RestResponseBody implements HttpEntity {
* @return The <c>Content-Type</c> header for this entity, or
<jk>null</jk> if the content type is unknown.
*/
@Override /* HttpEntity */
- public RestResponseHeader getContentType() {
- return new RestResponseHeader(request, response,
entity.getContentType());
+ public ResponseHeader getContentType() {
+ return new ResponseHeader(request, response,
entity.getContentType());
}
/**
@@ -1736,8 +1736,8 @@ public class RestResponseBody implements HttpEntity {
* @return The <c>Content-Encoding</c> header for this entity, or
<jk>null</jk> if the content encoding is unknown.
*/
@Override /* HttpEntity */
- public RestResponseHeader getContentEncoding() {
- return new RestResponseHeader(request, response,
entity.getContentEncoding());
+ public ResponseHeader getContentEncoding() {
+ return new ResponseHeader(request, response,
entity.getContentEncoding());
}
/**
diff --git
a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestResponseHeader.java
b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/ResponseHeader.java
similarity index 99%
rename from
juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestResponseHeader.java
rename to
juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/ResponseHeader.java
index ac1f1e1..262d599 100644
---
a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestResponseHeader.java
+++
b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/ResponseHeader.java
@@ -40,7 +40,7 @@ import org.apache.juneau.utils.*;
* <li class='link'>{@doc juneau-rest-client}
* </ul>
*/
-public class RestResponseHeader implements Header {
+public class ResponseHeader implements Header {
static final Header NULL_HEADER = new Header() {
@@ -73,7 +73,7 @@ public class RestResponseHeader implements Header {
* @param response The response object.
* @param header The wrapped header. Can be <jk>null</jk>.
*/
- public RestResponseHeader(RestRequest request, RestResponse response,
Header header) {
+ public ResponseHeader(RestRequest request, RestResponse response,
Header header) {
this.request = request;
this.response = response;
this.header = header == null ? NULL_HEADER : header;
@@ -94,7 +94,7 @@ public class RestResponseHeader implements Header {
* The part schema.
* @return This object (for method chaining).
*/
- public RestResponseHeader schema(HttpPartSchema value) {
+ public ResponseHeader schema(HttpPartSchema value) {
this.schema = value;
return this;
}
@@ -110,7 +110,7 @@ public class RestResponseHeader implements Header {
* <br>If <jk>null</jk>, {@link SimplePartParser#DEFAULT} will be
used.
* @return This object (for method chaining).
*/
- public RestResponseHeader parser(HttpPartParserSession value) {
+ public ResponseHeader parser(HttpPartParserSession value) {
this.parser = value == null ? SimplePartParser.DEFAULT_SESSION
: value;
return this;
}
diff --git
a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestResponseStatusLineAssertion.java
b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/ResponseStatusLineAssertion.java
similarity index 95%
rename from
juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestResponseStatusLineAssertion.java
rename to
juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/ResponseStatusLineAssertion.java
index c3d7bc2..c6ef99e 100644
---
a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestResponseStatusLineAssertion.java
+++
b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/ResponseStatusLineAssertion.java
@@ -27,7 +27,7 @@ import org.apache.juneau.assertions.*;
* .assertStatus().code().isAny(200,404);
* </p>
*/
-public class RestResponseStatusLineAssertion extends
FluentAssertion<RestResponse> {
+public class ResponseStatusLineAssertion extends FluentAssertion<RestResponse>
{
private final StatusLine statusLine;
@@ -37,7 +37,7 @@ public class RestResponseStatusLineAssertion extends
FluentAssertion<RestRespons
* @param statusLine The response status line.
* @param returns The object to return after the test.
*/
- public RestResponseStatusLineAssertion(StatusLine statusLine,
RestResponse returns) {
+ public ResponseStatusLineAssertion(StatusLine statusLine, RestResponse
returns) {
super(null, returns);
this.statusLine = statusLine;
}
diff --git
a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestClient.java
b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestClient.java
index 8910c17..3e9e112 100644
---
a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestClient.java
+++
b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestClient.java
@@ -134,9 +134,9 @@ import org.apache.juneau.utils.*;
* <ul class='javatree'>
* <li class='jc'>{@link RestClient} <jk>extends</jk> {@link HttpClient},
creates {@link RestRequest} objects.
* <li class='jc'>{@link RestRequest} <jk>extends</jk> {@link
HttpUriRequest}, creates {@link RestResponse} objects.
- * <li class='jc'>{@link RestResponse} <jk>extends</jk> {@link
HttpResponse}, creates {@link RestResponseBody} and {@link RestResponseHeader}
objects.
- * <li class='jc'>{@link RestResponseBody} <jk>extends</jk> {@link
HttpEntity}
- * <li class='jc'>{@link RestResponseHeader} <jk>extends</jk> {@link
Header}
+ * <li class='jc'>{@link RestResponse} <jk>extends</jk> {@link
HttpResponse}, creates {@link ResponseBody} and {@link ResponseHeader} objects.
+ * <li class='jc'>{@link ResponseBody} <jk>extends</jk> {@link HttpEntity}
+ * <li class='jc'>{@link ResponseHeader} <jk>extends</jk> {@link Header}
* </ul>
*
*
@@ -190,7 +190,7 @@ import org.apache.juneau.utils.*;
* <p class='w900'>
* The distinction between the two methods is that {@link
RestRequest#complete() complete()} automatically consumes the response body and
* {@link RestRequest#run() run()} does not. Note that you must consume
response bodies in order for HTTP connections to be freed up
- * for reuse! The {@link InputStream InputStreams} returned by the {@link
RestResponseBody} object are auto-closing once
+ * for reuse! The {@link InputStream InputStreams} returned by the {@link
ResponseBody} object are auto-closing once
* they are exhausted, so it is often not necessary to explicitly close them.
*
* <p class='w900'>
@@ -518,7 +518,7 @@ import org.apache.juneau.utils.*;
* <li class='jm'><c>{@link RestResponse#getStatusLine()
getStatusLine()} <jk>returns</jk> {@link StatusLine}</c>
* <li class='jm'><c>{@link RestResponse#getStatusCode()
getStatusCode()} <jk>returns</jk> <jk>int</jk></c>
* <li class='jm'><c>{@link RestResponse#getReasonPhrase()
getReasonPhrase()} <jk>returns</jk> String</c>
- * <li class='jm'><c>{@link RestResponse#assertStatus()
assertStatus()} <jk>returns</jk> {@link RestResponseStatusLineAssertion}</c>
+ * <li class='jm'><c>{@link RestResponse#assertStatus()
assertStatus()} <jk>returns</jk> {@link ResponseStatusLineAssertion}</c>
* </ul>
* </ul>
*
@@ -574,19 +574,19 @@ import org.apache.juneau.utils.*;
* <ul class='javatree'>
* <li class='jc'>{@link RestResponse}
* <ul>
- * <li class='jm'><c>{@link RestResponse#getHeader(String)
getHeader(String)} <jk>returns</jk> {@link RestResponseHeader}</c>
- * <li class='jm'><c>{@link RestResponse#getHeaders(String)
getHeaders(String)} <jk>returns</jk> {@link RestResponseHeader}[]</c>
- * <li class='jm'><c>{@link RestResponse#getFirstHeader(String)
getFirstHeader(String)} <jk>returns</jk> {@link RestResponseHeader}</c>
- * <li class='jm'><c>{@link RestResponse#getLastHeader(String)
getLastHeader(String)} <jk>returns</jk> {@link RestResponseHeader}</c>
- * <li class='jm'><c>{@link RestResponse#getAllHeaders()
getAllHeaders()} <jk>returns</jk> {@link RestResponseHeader}[]</c>
+ * <li class='jm'><c>{@link RestResponse#getResponseHeader(String)
getHeader(String)} <jk>returns</jk> {@link ResponseHeader}</c>
+ * <li class='jm'><c>{@link RestResponse#getHeaders(String)
getHeaders(String)} <jk>returns</jk> {@link ResponseHeader}[]</c>
+ * <li class='jm'><c>{@link RestResponse#getFirstHeader(String)
getFirstHeader(String)} <jk>returns</jk> {@link ResponseHeader}</c>
+ * <li class='jm'><c>{@link RestResponse#getLastHeader(String)
getLastHeader(String)} <jk>returns</jk> {@link ResponseHeader}</c>
+ * <li class='jm'><c>{@link RestResponse#getAllHeaders()
getAllHeaders()} <jk>returns</jk> {@link ResponseHeader}[]</c>
* <li class='jm'><c>{@link RestResponse#getStringHeader(String)
getStringHeader(String)} <jk>returns</jk> String</c>
* <li class='jm'><c>{@link RestResponse#containsHeader(String)
containsHeader(String)} <jk>returns</jk> <jk>boolean</jk></c>
* </ul>
* </ul>
*
* <p class='w900'>
- * Unlike {@link RestResponse#getFirstHeader(String)} and {@link
RestResponse#getLastHeader(String)}, the {@link RestResponse#getHeader(String)}
- * method returns an empty {@link RestResponseHeader} object instead of
returning <jk>null</jk>.
+ * Unlike {@link RestResponse#getFirstHeader(String)} and {@link
RestResponse#getLastHeader(String)}, the {@link
RestResponse#getResponseHeader(String)}
+ * method returns an empty {@link ResponseHeader} object instead of returning
<jk>null</jk>.
* This allows it to be used more easily in fluent calls.
*
* <h5 class='figure'>Example:</h5>
@@ -596,36 +596,36 @@ import org.apache.juneau.utils.*;
* </p>
*
* <p class='w900'>
- * The {@link RestResponseHeader} class extends from the HttpClient {@link
Header} class and provides several convenience
+ * The {@link ResponseHeader} class extends from the HttpClient {@link Header}
class and provides several convenience
* methods:
*
* <ul class='javatree'>
- * <li class='jc'>{@link RestResponseHeader}
+ * <li class='jc'>{@link ResponseHeader}
* <ul>
- * <li class='jm'><c>{@link RestResponseHeader#exists() exists()}
<jk>returns</jk> <jk>boolean</jk></c>
- * <li class='jm'><c>{@link RestResponseHeader#asString()
asString()} <jk>returns</jk> String</c>
- * <li class='jm'><c>{@link RestResponseHeader#asOptionalString()
asOptionalString()} <jk>returns</jk> Optional<String></c>
- * <li class='jm'><c>{@link
RestResponseHeader#asStringOrElse(String) asStringOrElse(String)}
<jk>returns</jk> String</c>
- * <li class='jm'><c>{@link RestResponseHeader#as(Type,Type...)
as(Type,Type...)} <jk>returns</jk> T</c>
- * <li class='jm'><c>{@link RestResponseHeader#as(Class)
as(Class<T>)} <jk>returns</jk> T</c>
- * <li class='jm'><c>{@link
RestResponseHeader#asOptional(Type,Type...) asOptional(Type,Type...)}
<jk>returns</jk> Optional<T></c>
- * <li class='jm'><c>{@link RestResponseHeader#asOptional(Class)
asOptional(Class<T>)} <jk>returns</jk> Optional<T></c>
- * <li class='jm'><c>{@link RestResponseHeader#asMatcher(Pattern)
asMatcher(Pattern)} <jk>returns</jk> {@link Matcher}</c>
- * <li class='jm'><c>{@link RestResponseHeader#asMatcher(String)
asMatcher(String)} <jk>returns</jk> {@link Matcher}</c>
- * <li class='jm'><c>{@link RestResponseHeader#asHeader(Class)
asHeader(Class<T <jk>extends</jk> BasicHeader> c)} <jk>returns</jk>
{@link BasicHeader}</c>
- * <li class='jm'><c>{@link RestResponseHeader#asStringHeader()
asStringHeader()} <jk>returns</jk> {@link BasicIntegerHeader}</c>
- * <li class='jm'><c>{@link RestResponseHeader#asIntegerHeader()
asIntegerHeader()} <jk>returns</jk> {@link BasicStringHeader}</c>
- * <li class='jm'><c>{@link RestResponseHeader#asLongHeader()
asLongHeader()} <jk>returns</jk> {@link BasicLongHeader}</c>
- * <li class='jm'><c>{@link RestResponseHeader#asDateHeader()
asDateHeader()} <jk>returns</jk> {@link BasicDateHeader}</c>
- * <li class='jm'><c>{@link RestResponseHeader#asCsvArrayHeader()
asCsvArrayHeader()} <jk>returns</jk> {@link BasicCsvArrayHeader}</c>
- * <li class='jm'><c>{@link
RestResponseHeader#asEntityTagArrayHeader() asEntityValidatorArrayHeader()}
<jk>returns</jk> {@link BasicEntityTagArrayHeader}</c>
- * <li class='jm'><c>{@link
RestResponseHeader#asStringRangeArrayHeader() asRangeArrayHeader()}
<jk>returns</jk> {@link BasicStringRangeArrayHeader}</c>
- * <li class='jm'><c>{@link RestResponseHeader#asUriHeader()
asUriHeader()} <jk>returns</jk> {@link BasicUriHeader}</c>
+ * <li class='jm'><c>{@link ResponseHeader#exists() exists()}
<jk>returns</jk> <jk>boolean</jk></c>
+ * <li class='jm'><c>{@link ResponseHeader#asString() asString()}
<jk>returns</jk> String</c>
+ * <li class='jm'><c>{@link ResponseHeader#asOptionalString()
asOptionalString()} <jk>returns</jk> Optional<String></c>
+ * <li class='jm'><c>{@link ResponseHeader#asStringOrElse(String)
asStringOrElse(String)} <jk>returns</jk> String</c>
+ * <li class='jm'><c>{@link ResponseHeader#as(Type,Type...)
as(Type,Type...)} <jk>returns</jk> T</c>
+ * <li class='jm'><c>{@link ResponseHeader#as(Class)
as(Class<T>)} <jk>returns</jk> T</c>
+ * <li class='jm'><c>{@link
ResponseHeader#asOptional(Type,Type...) asOptional(Type,Type...)}
<jk>returns</jk> Optional<T></c>
+ * <li class='jm'><c>{@link ResponseHeader#asOptional(Class)
asOptional(Class<T>)} <jk>returns</jk> Optional<T></c>
+ * <li class='jm'><c>{@link ResponseHeader#asMatcher(Pattern)
asMatcher(Pattern)} <jk>returns</jk> {@link Matcher}</c>
+ * <li class='jm'><c>{@link ResponseHeader#asMatcher(String)
asMatcher(String)} <jk>returns</jk> {@link Matcher}</c>
+ * <li class='jm'><c>{@link ResponseHeader#asHeader(Class)
asHeader(Class<T <jk>extends</jk> BasicHeader> c)} <jk>returns</jk>
{@link BasicHeader}</c>
+ * <li class='jm'><c>{@link ResponseHeader#asStringHeader()
asStringHeader()} <jk>returns</jk> {@link BasicIntegerHeader}</c>
+ * <li class='jm'><c>{@link ResponseHeader#asIntegerHeader()
asIntegerHeader()} <jk>returns</jk> {@link BasicStringHeader}</c>
+ * <li class='jm'><c>{@link ResponseHeader#asLongHeader()
asLongHeader()} <jk>returns</jk> {@link BasicLongHeader}</c>
+ * <li class='jm'><c>{@link ResponseHeader#asDateHeader()
asDateHeader()} <jk>returns</jk> {@link BasicDateHeader}</c>
+ * <li class='jm'><c>{@link ResponseHeader#asCsvArrayHeader()
asCsvArrayHeader()} <jk>returns</jk> {@link BasicCsvArrayHeader}</c>
+ * <li class='jm'><c>{@link
ResponseHeader#asEntityTagArrayHeader() asEntityValidatorArrayHeader()}
<jk>returns</jk> {@link BasicEntityTagArrayHeader}</c>
+ * <li class='jm'><c>{@link
ResponseHeader#asStringRangeArrayHeader() asRangeArrayHeader()}
<jk>returns</jk> {@link BasicStringRangeArrayHeader}</c>
+ * <li class='jm'><c>{@link ResponseHeader#asUriHeader()
asUriHeader()} <jk>returns</jk> {@link BasicUriHeader}</c>
* </ul>
* </ul>
*
* <p>
- * The {@link RestResponseHeader#schema(HttpPartSchema)} method allows you to
perform parsing of OpenAPI formats for
+ * The {@link ResponseHeader#schema(HttpPartSchema)} method allows you to
perform parsing of OpenAPI formats for
* header parts.
*
* <h5 class='figure'>Example:</h5>
@@ -641,12 +641,12 @@ import org.apache.juneau.utils.*;
* Assertion methods are also provided for fluent-style calls:
*
* <ul class='javatree'>
- * <li class='jc'>{@link RestResponseHeader}
+ * <li class='jc'>{@link ResponseHeader}
* <ul>
- * <li class='jm'><c>{@link RestResponseHeader#assertString()
assertString()} <jk>returns</jk> {@link FluentStringAssertion}</c>
- * <li class='jm'><c>{@link RestResponseHeader#assertInteger()
assertInteger()} <jk>returns</jk> {@link FluentIntegerAssertion}</c>
- * <li class='jm'><c>{@link RestResponseHeader#assertLong()
assertLong()} <jk>returns</jk> {@link FluentLongAssertion}</c>
- * <li class='jm'><c>{@link RestResponseHeader#assertDate()
assertDate()} <jk>returns</jk> {@link FluentDateAssertion}</c>
+ * <li class='jm'><c>{@link ResponseHeader#assertString()
assertString()} <jk>returns</jk> {@link FluentStringAssertion}</c>
+ * <li class='jm'><c>{@link ResponseHeader#assertInteger()
assertInteger()} <jk>returns</jk> {@link FluentIntegerAssertion}</c>
+ * <li class='jm'><c>{@link ResponseHeader#assertLong()
assertLong()} <jk>returns</jk> {@link FluentLongAssertion}</c>
+ * <li class='jm'><c>{@link ResponseHeader#assertDate()
assertDate()} <jk>returns</jk> {@link FluentDateAssertion}</c>
* </ul>
* </ul>
*
@@ -672,33 +672,33 @@ import org.apache.juneau.utils.*;
* <ul class='javatree'>
* <li class='jc'>{@link RestResponse}
* <ul>
- * <li class='jm'><c>{@link RestResponse#getBody() getBody()}
<jk>returns</jk> {@link RestResponseBody}</c>
+ * <li class='jm'><c>{@link RestResponse#getBody() getBody()}
<jk>returns</jk> {@link ResponseBody}</c>
* </ul>
* </ul>
*
* <p class='w900'>
- * The {@link RestResponseBody} class extends from the HttpClient {@link
HttpEntity} class and provides several convenience
+ * The {@link ResponseBody} class extends from the HttpClient {@link
HttpEntity} class and provides several convenience
* methods:
*
* <ul class='javatree'>
- * <li class='jc'>{@link RestResponseBody}
+ * <li class='jc'>{@link ResponseBody}
* <ul>
- * <li class='jm'><c>{@link RestResponseBody#asInputStream()
asInputStream()} <jk>returns</jk> InputStream</c>
- * <li class='jm'><c>{@link RestResponseBody#asReader()
asReader()} <jk>returns</jk> Reader</c>
- * <li class='jm'><c>{@link RestResponseBody#asReader(Charset)
asReader(Charset)} <jk>returns</jk> Reader</c>
- * <li class='jm'><c>{@link RestResponseBody#pipeTo(OutputStream)
pipeTo(OutputStream)} <jk>returns</jk> {@link RestResponse}</c>
- * <li class='jm'><c>{@link RestResponseBody#pipeTo(Writer)
pipeTo(Writer)} <jk>returns</jk> {@link RestResponse}</c>
- * <li class='jm'><c>{@link RestResponseBody#as(Type,Type...)
as(Type,Type...)} <jk>returns</jk> T</c>
- * <li class='jm'><c>{@link RestResponseBody#as(Class)
as(Class<T>)} <jk>returns</jk> T</c>
- * <li class='jm'><c>{@link RestResponseBody#asFuture(Class)
asFuture(Class<T>)} <jk>returns</jk> Future<T></c>
- * <li class='jm'><c>{@link
RestResponseBody#asFuture(Type,Type...) asFuture(Type,Type...)}
<jk>returns</jk> Future<T></c>
- * <li class='jm'><c>{@link RestResponseBody#asString()
asString()} <jk>returns</jk> String</c>
- * <li class='jm'><c>{@link RestResponseBody#asStringFuture()
asStringFuture()} <jk>returns</jk> Future<String></c>
- * <li class='jm'><c>{@link
RestResponseBody#asAbbreviatedString(int) asAbbreviatedString(int)}
<jk>returns</jk> String</c>
- * <li class='jm'><c>{@link RestResponseBody#asPojoRest(Class)
asPojoRest(Class<?>)} <jk>returns</jk> {@link PojoRest}</c>
- * <li class='jm'><c>{@link RestResponseBody#asPojoRest()
asPojoRest()} <jk>returns</jk> {@link PojoRest}</c>
- * <li class='jm'><c>{@link RestResponseBody#asMatcher(Pattern)
asMatcher(Pattern)} <jk>returns</jk> {@link Matcher}</c>
- * <li class='jm'><c>{@link RestResponseBody#asMatcher(String)
asMatcher(String)} <jk>returns</jk> {@link Matcher}</c>
+ * <li class='jm'><c>{@link ResponseBody#asInputStream()
asInputStream()} <jk>returns</jk> InputStream</c>
+ * <li class='jm'><c>{@link ResponseBody#asReader() asReader()}
<jk>returns</jk> Reader</c>
+ * <li class='jm'><c>{@link ResponseBody#asReader(Charset)
asReader(Charset)} <jk>returns</jk> Reader</c>
+ * <li class='jm'><c>{@link ResponseBody#pipeTo(OutputStream)
pipeTo(OutputStream)} <jk>returns</jk> {@link RestResponse}</c>
+ * <li class='jm'><c>{@link ResponseBody#pipeTo(Writer)
pipeTo(Writer)} <jk>returns</jk> {@link RestResponse}</c>
+ * <li class='jm'><c>{@link ResponseBody#as(Type,Type...)
as(Type,Type...)} <jk>returns</jk> T</c>
+ * <li class='jm'><c>{@link ResponseBody#as(Class)
as(Class<T>)} <jk>returns</jk> T</c>
+ * <li class='jm'><c>{@link ResponseBody#asFuture(Class)
asFuture(Class<T>)} <jk>returns</jk> Future<T></c>
+ * <li class='jm'><c>{@link ResponseBody#asFuture(Type,Type...)
asFuture(Type,Type...)} <jk>returns</jk> Future<T></c>
+ * <li class='jm'><c>{@link ResponseBody#asString() asString()}
<jk>returns</jk> String</c>
+ * <li class='jm'><c>{@link ResponseBody#asStringFuture()
asStringFuture()} <jk>returns</jk> Future<String></c>
+ * <li class='jm'><c>{@link ResponseBody#asAbbreviatedString(int)
asAbbreviatedString(int)} <jk>returns</jk> String</c>
+ * <li class='jm'><c>{@link ResponseBody#asPojoRest(Class)
asPojoRest(Class<?>)} <jk>returns</jk> {@link PojoRest}</c>
+ * <li class='jm'><c>{@link ResponseBody#asPojoRest()
asPojoRest()} <jk>returns</jk> {@link PojoRest}</c>
+ * <li class='jm'><c>{@link ResponseBody#asMatcher(Pattern)
asMatcher(Pattern)} <jk>returns</jk> {@link Matcher}</c>
+ * <li class='jm'><c>{@link ResponseBody#asMatcher(String)
asMatcher(String)} <jk>returns</jk> {@link Matcher}</c>
* </ul>
* </ul>
*
@@ -739,9 +739,9 @@ import org.apache.juneau.utils.*;
*
* <p class='w900'>
* The response body can only be consumed once unless it has been cached into
memory. In many cases, the body is
- * automatically cached when using the assertions methods or methods such as
{@link RestResponseBody#asString()}.
+ * automatically cached when using the assertions methods or methods such as
{@link ResponseBody#asString()}.
* However, methods that involve reading directly from the input stream cannot
be called twice.
- * In these cases, the {@link RestResponse#cacheBody()} and {@link
RestResponseBody#cache()} methods are provided
+ * In these cases, the {@link RestResponse#cacheBody()} and {@link
ResponseBody#cache()} methods are provided
* to cache the response body in memory so that you can perform several
operations against it.
*
* <p class='bcode w800'>
@@ -758,11 +758,11 @@ import org.apache.juneau.utils.*;
* Assertion methods are also provided for fluent-style calls:
*
* <ul class='javatree'>
- * <li class='jc'>{@link RestResponseBody}
+ * <li class='jc'>{@link ResponseBody}
* <ul>
- * <li class='jm'><c>{@link RestResponseBody#assertString()
assertString()} <jk>returns</jk> {@link FluentStringAssertion}</c>
- * <li class='jm'><c>{@link RestResponseBody#assertObject(Class)
assertObject(Class<?>)} <jk>returns</jk> {@link FluentObjectAssertion}</c>
- * <li class='jm'><c>{@link RestResponseBody#assertBytes()
assertBytes()} <jk>returns</jk> {@link FluentByteArrayAssertion}</c>
+ * <li class='jm'><c>{@link ResponseBody#assertString()
assertString()} <jk>returns</jk> {@link FluentStringAssertion}</c>
+ * <li class='jm'><c>{@link ResponseBody#assertObject(Class)
assertObject(Class<?>)} <jk>returns</jk> {@link FluentObjectAssertion}</c>
+ * <li class='jm'><c>{@link ResponseBody#assertBytes()
assertBytes()} <jk>returns</jk> {@link FluentByteArrayAssertion}</c>
* </ul>
* </ul>
*
@@ -1205,7 +1205,7 @@ public class RestClient extends BeanContext implements
HttpClient, Closeable, Re
* <ul>
* <li class='jm'>{@link RestRequest#runFuture()}
* <li class='jm'>{@link RestRequest#completeFuture()}
- * <li class='jm'>{@link RestResponseBody#asFuture(Class)} (and
similar methods)
+ * <li class='jm'>{@link ResponseBody#asFuture(Class)} (and
similar methods)
* </ul>
*
* <p>
diff --git
a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestClientBuilder.java
b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestClientBuilder.java
index 6b8567c..d37ab8c 100644
---
a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestClientBuilder.java
+++
b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestClientBuilder.java
@@ -612,7 +612,7 @@ public class RestClientBuilder extends BeanContextBuilder {
* <ul>
* <li>The parser can be configured using any of the
parser property setters (e.g. {@link #strict()}),
* bean context property setters (e.g. {@link
#swaps(Object...)}), or generic property setters (e.g. {@link #set(String,
Object)}) defined on this builder class.
- * <li>Typically the {@link
RestResponseBody#schema(HttpPartSchema)} method will be used to specify the
structure of the response body.
+ * <li>Typically the {@link
ResponseBody#schema(HttpPartSchema)} method will be used to specify the
structure of the response body.
* </ul>
* <p>
* <c>Accept</c> request header will be set to
<js>"text/openapi"</js> unless overridden
@@ -2537,7 +2537,7 @@ public class RestClientBuilder extends BeanContextBuilder
{
* <ul>
* <li class='jm'>{@link RestRequest#runFuture()}
* <li class='jm'>{@link RestRequest#completeFuture()}
- * <li class='jm'>{@link RestResponseBody#asFuture(Class)} (and
similar methods)
+ * <li class='jm'>{@link ResponseBody#asFuture(Class)} (and
similar methods)
* </ul>
*
* <p>
diff --git
a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestRequest.java
b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestRequest.java
index 9ca6ec2..61f8a10 100644
---
a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestRequest.java
+++
b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestRequest.java
@@ -534,7 +534,7 @@ public class RestRequest extends BeanSession implements
HttpUriRequest, Configur
* <ul>
* <li>The parser can be configured using any of the
parser property setters (e.g. {@link RestClientBuilder#strict()}),
* bean context property setters (e.g. {@link
RestClientBuilder#swaps(Object...)}), or generic property setters (e.g. {@link
RestClientBuilder#set(String, Object)}) defined on this builder class.
- * <li>Typically the {@link
RestResponseBody#schema(HttpPartSchema)} method will be used to specify the
structure of the response body.
+ * <li>Typically the {@link
ResponseBody#schema(HttpPartSchema)} method will be used to specify the
structure of the response body.
* </ul>
* <p>
* <c>Accept</c> request header will be set to
<js>"text/openapi"</js> unless overridden
@@ -2967,7 +2967,7 @@ public class RestRequest extends BeanSession implements
HttpUriRequest, Configur
*
* <p>
* Use this method if you're only interested in the status line of the
response and not the response entity.
- * Attempts to call any of the methods on the response object that
retrieve the body (e.g. {@link RestResponseBody#asReader()}
+ * Attempts to call any of the methods on the response object that
retrieve the body (e.g. {@link ResponseBody#asReader()}
* will cause a {@link RestCallException} to be thrown.
*
* <ul class='notes'>
diff --git
a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestResponse.java
b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestResponse.java
index d82e88b..47841e5 100644
---
a/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestResponse.java
+++
b/juneau-rest/juneau-rest-client/src/main/java/org/apache/juneau/rest/client/RestResponse.java
@@ -51,7 +51,7 @@ public class RestResponse implements HttpResponse {
private final HttpResponse response;
private final Parser parser;
HttpPartParserSession partParser;
- private RestResponseBody responseBody;
+ private ResponseBody responseBody;
private boolean isClosed;
/**
@@ -67,7 +67,7 @@ public class RestResponse implements HttpResponse {
this.request = request;
this.parser = parser;
this.response = response == null ? new BasicHttpResponse(null,
0, null) : response;
- this.responseBody = new RestResponseBody(client, request, this,
parser);
+ this.responseBody = new ResponseBody(client, request, this,
parser);
this.partParser = client.getPartParserSession();
}
@@ -176,8 +176,8 @@ public class RestResponse implements HttpResponse {
* @return A new fluent assertion object.
* @throws RestCallException If REST call failed.
*/
- public RestResponseStatusLineAssertion assertStatus() throws
RestCallException {
- return new RestResponseStatusLineAssertion(getStatusLine(),
this);
+ public ResponseStatusLineAssertion assertStatus() throws
RestCallException {
+ return new ResponseStatusLineAssertion(getStatusLine(), this);
}
/**
@@ -210,7 +210,7 @@ public class RestResponse implements HttpResponse {
* @return The header value, or <jk>null</jk> if header was not found.
*/
public String getStringHeader(String name) {
- return getHeader(name).asString();
+ return getResponseHeader(name).asString();
}
/**
@@ -221,21 +221,21 @@ public class RestResponse implements HttpResponse {
* @return The header value, or the default if header was not found.
*/
public String getStringHeader(String name, String def) {
- return getHeader(name).asStringOrElse(def);
+ return getResponseHeader(name).asStringOrElse(def);
}
/**
* Returns the last header with the specified name.
*
* Unlike {@link #getFirstHeader(String)} and {@link
#getLastHeader(String)}, this method returns an empty
- * {@link RestResponseHeader} object instead of returning
<jk>null</jk>. This allows it to be used more easily
+ * {@link ResponseHeader} object instead of returning <jk>null</jk>.
This allows it to be used more easily
* in fluent calls.
*
* @param name The header name.
* @return The header. Never <jk>null</jk>.
*/
- public RestResponseHeader getHeader(String name) {
- return new RestResponseHeader(request, this,
getLastHeader(name)).parser(partParser);
+ public ResponseHeader getResponseHeader(String name) {
+ return new ResponseHeader(request, this,
getLastHeader(name)).parser(partParser);
}
/**
@@ -259,7 +259,7 @@ public class RestResponse implements HttpResponse {
* @throws RestCallException If REST call failed.
*/
public ContentType getContentType() throws RestCallException {
- return getHeader("Content-Type").as(ContentType.class);
+ return getResponseHeader("Content-Type").as(ContentType.class);
}
/**
@@ -320,7 +320,7 @@ public class RestResponse implements HttpResponse {
* @return A new fluent assertion object.
*/
public FluentStringAssertion<RestResponse> assertStringHeader(String
name) {
- return getHeader(name).assertString();
+ return getResponseHeader(name).assertString();
}
/**
@@ -339,7 +339,7 @@ public class RestResponse implements HttpResponse {
* @return A new fluent assertion object.
*/
public FluentIntegerAssertion<RestResponse> assertIntegerHeader(String
name) {
- return getHeader(name).assertInteger();
+ return getResponseHeader(name).assertInteger();
}
/**
@@ -358,7 +358,7 @@ public class RestResponse implements HttpResponse {
* @return A new fluent assertion object.
*/
public FluentLongAssertion<RestResponse> assertLongHeader(String name) {
- return getHeader(name).assertLong();
+ return getResponseHeader(name).assertLong();
}
/**
@@ -377,7 +377,7 @@ public class RestResponse implements HttpResponse {
* @return A new fluent assertion object.
*/
public FluentZonedDateTimeAssertion<RestResponse>
assertDateHeader(String name) {
- return getHeader(name).assertDate();
+ return getResponseHeader(name).assertDate();
}
/**
@@ -396,7 +396,7 @@ public class RestResponse implements HttpResponse {
* @return A new fluent assertion object.
*/
public FluentListAssertion<RestResponse> assertCsvArrayHeader(String
name) {
- return getHeader(name).assertCsvArray();
+ return getResponseHeader(name).assertCsvArray();
}
/**
@@ -443,7 +443,7 @@ public class RestResponse implements HttpResponse {
* @return A new fluent assertion object.
*/
public FluentStringAssertion<RestResponse> assertContentType() {
- return getHeader("Content-Type").assertString();
+ return getResponseHeader("Content-Type").assertString();
}
//------------------------------------------------------------------------------------------------------------------
@@ -457,7 +457,7 @@ public class RestResponse implements HttpResponse {
*
* @return The body of the response.
*/
- public RestResponseBody getBody() {
+ public ResponseBody getBody() {
return responseBody;
}
@@ -520,7 +520,7 @@ public class RestResponse implements HttpResponse {
* <li>
* If no charset was found on the
<code>Content-Type</code> response header, <js>"UTF-8"</js> is assumed.
* <li>
- * When using this method, the body is automatically
cached by calling the {@link RestResponseBody#cache()}.
+ * When using this method, the body is automatically
cached by calling the {@link ResponseBody#cache()}.
* <li>
* The input stream is automatically closed after this
call.
* </ul>
@@ -548,7 +548,7 @@ public class RestResponse implements HttpResponse {
* <li>
* If no charset was found on the
<code>Content-Type</code> response header, <js>"UTF-8"</js> is assumed.
* <li>
- * When using this method, the body is automatically
cached by calling the {@link RestResponseBody#cache()}.
+ * When using this method, the body is automatically
cached by calling the {@link ResponseBody#cache()}.
* <li>
* The input stream is automatically closed after this
call.
* </ul>
@@ -565,7 +565,7 @@ public class RestResponse implements HttpResponse {
*
* <p>
* <p>
- * Combines the functionality of {@link RestResponseBody#as(Class)}
with {@link #assertBody()} by converting the body to the specified
+ * Combines the functionality of {@link ResponseBody#as(Class)} with
{@link #assertBody()} by converting the body to the specified
* bean and then serializing it to simplified JSON for easy string
comparison.
*
* <h5 class='section'>Examples:</h5>
@@ -581,7 +581,7 @@ public class RestResponse implements HttpResponse {
* <li>
* If no charset was found on the
<code>Content-Type</code> response header, <js>"UTF-8"</js> is assumed.
* <li>
- * When using this method, the body is automatically
cached by calling the {@link RestResponseBody#cache()}.
+ * When using this method, the body is automatically
cached by calling the {@link ResponseBody#cache()}.
* <li>
* The input stream is automatically closed after this
call.
* </ul>
@@ -626,7 +626,7 @@ public class RestResponse implements HttpResponse {
String name = pm.getPartName();
ClassMeta<?> type =
rc.getClassMeta(method.getGenericReturnType());
if (pt == RESPONSE_HEADER)
- return
getHeader(name).parser(pp).schema(schema).as(type);
+ return
getResponseHeader(name).parser(pp).schema(schema).as(type);
if (pt == RESPONSE_STATUS)
return getStatusCode();
return
getBody().schema(schema).as(type);
@@ -749,7 +749,7 @@ public class RestResponse implements HttpResponse {
* @return The response entity. Never <jk>null</jk>.
*/
@Override /* HttpResponse */
- public RestResponseBody getEntity() {
+ public ResponseBody getEntity() {
return responseBody;
}
@@ -767,7 +767,7 @@ public class RestResponse implements HttpResponse {
@Override /* HttpResponse */
public void setEntity(HttpEntity entity) {
response.setEntity(entity);
- this.responseBody = new RestResponseBody(client, request, this,
parser);
+ this.responseBody = new ResponseBody(client, request, this,
parser);
}
/**
@@ -827,11 +827,11 @@ public class RestResponse implements HttpResponse {
* @return All the headers with a specified name of this message.
*/
@Override /* HttpMessage */
- public RestResponseHeader[] getHeaders(String name) {
+ public ResponseHeader[] getHeaders(String name) {
Header[] a = response.getHeaders(name);
- RestResponseHeader[] b = new RestResponseHeader[a.length];
+ ResponseHeader[] b = new ResponseHeader[a.length];
for (int i = 0; i < a.length; i++)
- b[i] = new RestResponseHeader(request, this,
a[i]).parser(partParser);
+ b[i] = new ResponseHeader(request, this,
a[i]).parser(partParser);
return b;
}
@@ -845,9 +845,9 @@ public class RestResponse implements HttpResponse {
* @return The header, or <jk>null</jk> if there is no matching header
in the message.
*/
@Override /* HttpMessage */
- public RestResponseHeader getFirstHeader(String name) {
+ public ResponseHeader getFirstHeader(String name) {
Header h = response.getFirstHeader(name);
- return h == null ? null : new RestResponseHeader(request, this,
h).parser(partParser);
+ return h == null ? null : new ResponseHeader(request, this,
h).parser(partParser);
}
/**
@@ -860,9 +860,9 @@ public class RestResponse implements HttpResponse {
* @return The header, or <jk>null</jk> if there is no matching header
in the message.
*/
@Override /* HttpMessage */
- public RestResponseHeader getLastHeader(String name) {
+ public ResponseHeader getLastHeader(String name) {
Header h = response.getLastHeader(name);
- return h == null ? null : new RestResponseHeader(request, this,
h).parser(partParser);
+ return h == null ? null : new ResponseHeader(request, this,
h).parser(partParser);
}
/**
@@ -873,11 +873,11 @@ public class RestResponse implements HttpResponse {
* @return All the headers of this message.
*/
@Override /* HttpMessage */
- public RestResponseHeader[] getAllHeaders() {
+ public ResponseHeader[] getAllHeaders() {
Header[] a = response.getAllHeaders();
- RestResponseHeader[] b = new RestResponseHeader[a.length];
+ ResponseHeader[] b = new ResponseHeader[a.length];
for (int i = 0; i < a.length; i++)
- b[i] = new RestResponseHeader(request, this,
a[i]).parser(partParser);
+ b[i] = new ResponseHeader(request, this,
a[i]).parser(partParser);
return b;
}
diff --git
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestRequest.java
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestRequest.java
index ef8e911..7bb62db 100644
---
a/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestRequest.java
+++
b/juneau-rest/juneau-rest-server/src/main/java/org/apache/juneau/rest/RestRequest.java
@@ -20,6 +20,7 @@ import static org.apache.juneau.httppart.HttpPartType.*;
import static org.apache.juneau.internal.IOUtils.*;
import static org.apache.juneau.serializer.Serializer.*;
import static org.apache.juneau.rest.HttpRuntimeException.*;
+import static java.lang.Integer.*;
import java.io.*;
import java.lang.reflect.*;
@@ -35,7 +36,9 @@ import javax.servlet.*;
import javax.servlet.http.*;
import org.apache.http.*;
+import org.apache.http.message.*;
import org.apache.juneau.*;
+import org.apache.juneau.assertions.*;
import org.apache.juneau.config.*;
import org.apache.juneau.cp.*;
import org.apache.juneau.cp.Messages;
@@ -214,9 +217,12 @@ public final class RestRequest extends
HttpServletRequestWrapper {
*
* @return A description string of the request.
*/
- public String getDescription() {
- String qs = getQueryString();
- return "HTTP " + getMethod() + " " + getRequestURI() + (qs ==
null ? "" : "?" + qs);
+ public RequestLine getRequestLine() {
+ String x = inner.getProtocol();
+ int i = x.indexOf('/');
+ int j = x.indexOf('.', i);
+ ProtocolVersion pv = new ProtocolVersion(x.substring(0,i),
parseInt(x.substring(i+1,j)), parseInt(x.substring(j+1)));
+ return new BasicRequestLine(inner.getMethod(),
inner.getRequestURI(), pv);
}
//-----------------------------------------------------------------------------------------------------------------
@@ -1296,7 +1302,7 @@ public final class RestRequest extends
HttpServletRequestWrapper {
@Override /* Object */
public String toString() {
- StringBuilder sb = new
StringBuilder("\n").append(getDescription()).append("\n");
+ StringBuilder sb = new
StringBuilder("\n").append(getRequestLine()).append("\n");
sb.append("---Headers---\n");
for (Enumeration<String> e = getHeaderNames();
e.hasMoreElements();) {
String h = e.nextElement();
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/rest/annotation/ResponseHeader_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/rest/annotation/ResponseHeader_Test.java
index 8ab14fd..a271bb9 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/rest/annotation/ResponseHeader_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/rest/annotation/ResponseHeader_Test.java
@@ -18,7 +18,7 @@ import static org.junit.runners.MethodSorters.*;
import org.apache.juneau.*;
import org.apache.juneau.dto.swagger.*;
-import org.apache.juneau.http.annotation.*;
+import org.apache.juneau.http.annotation.ResponseHeader;
import org.apache.juneau.rest.client.*;
import org.apache.juneau.rest.mock.*;
import org.junit.*;
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Config_BeanContext_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Config_BeanContext_Test.java
index c31042b..996ec3d 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Config_BeanContext_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Config_BeanContext_Test.java
@@ -99,7 +99,7 @@ public class RestClient_Config_BeanContext_Test {
public void a02_beanConstructorVisibility() throws Exception {
RestResponse x =
client(A2b.class).beanConstructorVisibility(Visibility.PROTECTED).build().post("/test",new
A2a(1)).header("X",new
A2a(1)).run().cacheBody().assertBody().is("1").assertStringHeader("X").is("1");
assertEquals(1,x.getBody().as(A2a.class).f);
- assertEquals(1,x.getHeader("X").as(A2a.class).f);
+ assertEquals(1,x.getResponseHeader("X").as(A2a.class).f);
}
public static class A3 {
@@ -121,7 +121,7 @@ public class RestClient_Config_BeanContext_Test {
public void a03_beanFieldVisibility() throws Exception {
RestResponse x =
client(A2b.class).beanFieldVisibility(Visibility.PROTECTED).build().post("/test",A3.get()).header("X",A3.get()).run().cacheBody().assertBody().is("{f1:1,f2:2}").assertStringHeader("X").is("f1=1,f2=2");
assertEquals(2,x.getBody().as(A3.class).f2);
- assertEquals(2,x.getHeader("X").as(A3.class).f2);
+ assertEquals(2,x.getResponseHeader("X").as(A3.class).f2);
}
public static interface A4a {
@@ -157,23 +157,23 @@ public class RestClient_Config_BeanContext_Test {
public void a04_beanFilters() throws Exception {
RestResponse x =
client(A2b.class).beanProperties(A4b.class,"f1").build().post("/test",A4b.get()).header("X",A4b.get()).run().cacheBody().assertBody().is("{f1:1}").assertStringHeader("X").is("f1=1");
assertEquals(0,x.getBody().as(A4b.class).f2);
- assertEquals(0,x.getHeader("X").as(A4b.class).f2);
+ assertEquals(0,x.getResponseHeader("X").as(A4b.class).f2);
x =
client(A2b.class).beanProperties(A4b.class,"f1").build().post("/test",A4b.get()).header("X",A4b.get()).run().cacheBody().assertBody().is("{f1:1}").assertStringHeader("X").is("f1=1");
assertEquals(0,x.getBody().as(A4b.class).f2);
- assertEquals(0,x.getHeader("X").as(A4b.class).f2);
+ assertEquals(0,x.getResponseHeader("X").as(A4b.class).f2);
x =
client(A2b.class).beanProperties(A4b.class,"f1").build().post("/test",A4b.get()).header("X",A4b.get()).run().cacheBody().assertBody().is("{f1:1}").assertStringHeader("X").is("f1=1");
assertEquals(0,x.getBody().as(A4b.class).f2);
- assertEquals(0,x.getHeader("X").as(A4b.class).f2);
+ assertEquals(0,x.getResponseHeader("X").as(A4b.class).f2);
x =
client(A2b.class).beanProperties(A4b.class,"f1").build().post("/test",A4b.get()).header("X",A4b.get()).run().cacheBody().assertBody().is("{f1:1}").assertStringHeader("X").is("f1=1");
assertEquals(0,x.getBody().as(A4b.class).f2);
- assertEquals(0,x.getHeader("X").as(A4b.class).f2);
+ assertEquals(0,x.getResponseHeader("X").as(A4b.class).f2);
x =
client(A2b.class).interfaces(A4a.class).build().post("/test",A4b.get()).header("X",A4b.get()).run().cacheBody().assertBody().is("{f3:3}").assertStringHeader("X").is("f3=3");
assertEquals(3,x.getBody().as(A4b.class).f3);
- assertEquals(3,x.getHeader("X").as(A4b.class).f3);
+ assertEquals(3,x.getResponseHeader("X").as(A4b.class).f3);
}
public static class A5 {
@@ -206,7 +206,7 @@ public class RestClient_Config_BeanContext_Test {
public void a05_beanMethodVisibility() throws Exception {
RestResponse x =
client(A2b.class).beanMethodVisibility(Visibility.PROTECTED).build().post("/test",A5.get()).header("X",A5.get()).run().cacheBody().assertBody().is("{f1:1,f2:2}").assertStringHeader("X").is("f1=1,f2=2");
assertEquals(2,x.getBody().as(A5.class).f2);
- assertEquals(2,x.getHeader("X").as(A5.class).f2);
+ assertEquals(2,x.getResponseHeader("X").as(A5.class).f2);
}
public static class A6 {}
@@ -282,15 +282,15 @@ public class RestClient_Config_BeanContext_Test {
x =
client(A2b.class).beanPropertiesReadOnly(OMap.of("09","f2")).build().post("/test",A9.get()).header("X",A9.get()).run().cacheBody().assertBody().is("{f1:1,f2:2}").assertStringHeader("X").is("f1=1,f2=2");
assertEquals("1/0",x.getBody().as(A9.class).toString());
- assertEquals("1/0",x.getHeader("X").as(A9.class).toString());
+
assertEquals("1/0",x.getResponseHeader("X").as(A9.class).toString());
x =
client(A2b.class).beanPropertiesReadOnly(A9.class,"f2").build().post("/test",A9.get()).header("X",A9.get()).run().cacheBody().assertBody().is("{f1:1,f2:2}").assertStringHeader("X").is("f1=1,f2=2");
assertEquals("1/0",x.getBody().as(A9.class).toString());
- assertEquals("1/0",x.getHeader("X").as(A9.class).toString());
+
assertEquals("1/0",x.getResponseHeader("X").as(A9.class).toString());
x =
client(A2b.class).beanPropertiesReadOnly("O9","f2").build().post("/test",A9.get()).header("X",A9.get()).run().cacheBody().assertBody().is("{f1:1,f2:2}").assertStringHeader("X").is("f1=1,f2=2");
assertEquals("1/0",x.getBody().as(A9.class).toString());
- assertEquals("1/0",x.getHeader("X").as(A9.class).toString());
+
assertEquals("1/0",x.getResponseHeader("X").as(A9.class).toString());
}
@Test
@@ -299,15 +299,15 @@ public class RestClient_Config_BeanContext_Test {
x =
client(A2b.class).beanPropertiesWriteOnly(OMap.of("A9","f2")).build().post("/test",A9.get()).header("X",A9.get()).run().cacheBody().assertBody().is("{f1:1}").assertStringHeader("X").is("f1=1");
assertEquals("1/0",x.getBody().as(A9.class).toString());
- assertEquals("1/0",x.getHeader("X").as(A9.class).toString());
+
assertEquals("1/0",x.getResponseHeader("X").as(A9.class).toString());
x =
client(A2b.class).beanPropertiesWriteOnly(A9.class,"f2").build().post("/test",A9.get()).header("X",A9.get()).run().cacheBody().assertBody().is("{f1:1}").assertStringHeader("X").is("f1=1");
assertEquals("1/0",x.getBody().as(A9.class).toString());
- assertEquals("1/0",x.getHeader("X").as(A9.class).toString());
+
assertEquals("1/0",x.getResponseHeader("X").as(A9.class).toString());
x =
client(A2b.class).beanPropertiesWriteOnly("A9","f2").build().post("/test",A9.get()).header("X",A9.get()).run().cacheBody().assertBody().is("{f1:1}").assertStringHeader("X").is("f1=1");
assertEquals("1/0",x.getBody().as(A9.class).toString());
- assertEquals("1/0",x.getHeader("X").as(A9.class).toString());
+
assertEquals("1/0",x.getResponseHeader("X").as(A9.class).toString());
}
@Test
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Config_RestClient_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Config_RestClient_Test.java
index 29f32c4..7722f28 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Config_RestClient_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Config_RestClient_Test.java
@@ -127,12 +127,12 @@ public class RestClient_Config_RestClient_Test {
RestClient x1 = client().executorService(es,true).build();
assertEquals(es,x1.getExecutorService());
-
x1.get("/echo").runFuture().get().assertCode().is(200).assertBody().contains("HTTP
GET /echo");
+
x1.get("/echo").runFuture().get().assertCode().is(200).assertBody().contains("GET
/echo HTTP/1.1");
es = null;
RestClient x2 = client().executorService(es,true).build();
assertNotNull(x2.getExecutorService());
-
x2.get("/echo").runFuture().get().assertCode().is(200).assertBody().contains("HTTP
GET /echo");
+
x2.get("/echo").runFuture().get().assertCode().is(200).assertBody().contains("GET
/echo HTTP/1.1");
}
@Test
@@ -482,13 +482,13 @@ public class RestClient_Config_RestClient_Test {
@Test
public void a12_partSerializer_partParser() throws Exception {
RestClient x =
client(A12.class).header("Foo",bean).partSerializer(A12a.class).partParser(A12b.class).build();
- ABean b =
x.get("/").header("Foo",bean).run().assertStringHeader("Foo").is("x{f:1}").getHeader("Foo").as(ABean.class);
+ ABean b =
x.get("/").header("Foo",bean).run().assertStringHeader("Foo").is("x{f:1}").getResponseHeader("Foo").as(ABean.class);
assertEquals("{f:1}",b.toString());
- b =
x.get().header("Foo",bean).run().assertStringHeader("Foo").is("x{f:1}").getHeader("Foo").as(ABean.class);
+ b =
x.get().header("Foo",bean).run().assertStringHeader("Foo").is("x{f:1}").getResponseHeader("Foo").as(ABean.class);
assertEquals("{f:1}",b.toString());
x = client(A12.class).header("Foo",bean).partSerializer(new
A12a()).partParser(new A12b()).build();
- b =
x.get("/").header("Foo",bean).run().assertStringHeader("Foo").is("x{f:1}").getHeader("Foo").as(ABean.class);
+ b =
x.get("/").header("Foo",bean).run().assertStringHeader("Foo").is("x{f:1}").getResponseHeader("Foo").as(ABean.class);
assertEquals("{f:1}",b.toString());
}
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Paths_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Paths_Test.java
index 3c523c0..0525fc4 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Paths_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Paths_Test.java
@@ -53,38 +53,38 @@ public class RestClient_Paths_Test {
@Test
public void a01_path_String_Object() throws Exception {
- client().build().get("/echo/{x}").path("x",new
A1().init()).run().assertBody().contains("HTTP GET /echo/x=1");
- client().build().get("/echo/*").path("/*",new
A1().init()).run().assertBody().contains("HTTP GET /echo/x=1");
+ client().build().get("/echo/{x}").path("x",new
A1().init()).run().assertBody().contains("GET /echo/x=1 HTTP/1.1");
+ client().build().get("/echo/*").path("/*",new
A1().init()).run().assertBody().contains("GET /echo/x=1 HTTP/1.1");
assertThrown(()->client().build().get("/echo/{x}").path("y","foo")).is("Path
variable {y} was not found in path.");
}
@Test
public void a02_path_NameValuePair() throws Exception {
-
client().build().get("/echo/{x}").path(pair("x","foo")).run().assertBody().contains("HTTP
GET /echo/foo");
+
client().build().get("/echo/{x}").path(pair("x","foo")).run().assertBody().contains("GET
/echo/foo HTTP/1.1");
}
@Test
public void a03_paths_Object() throws Exception {
-
client().build().get("/echo/{x}").paths(pair("x","foo")).run().assertBody().contains("HTTP
GET /echo/foo");
-
client().build().get("/echo/{x}").paths(AList.of(pair("x","foo"))).run().assertBody().contains("HTTP
GET /echo/foo");
-
client().build().get("/echo/{x}").paths(pairs("x","foo")).run().assertBody().contains("HTTP
GET /echo/foo");
-
client().build().get("/echo/{x}").paths(OMap.of("x","foo")).run().assertBody().contains("HTTP
GET /echo/foo");
- client().build().get("/echo/{x}").paths((Object)new
NameValuePair[]{pair("x","foo")}).run().assertBody().contains("HTTP GET
/echo/foo");
- client().build().get("/echo/{x}").paths(new
A1().init()).run().assertBody().contains("HTTP GET /echo/1");
+
client().build().get("/echo/{x}").paths(pair("x","foo")).run().assertBody().contains("GET
/echo/foo HTTP/1.1");
+
client().build().get("/echo/{x}").paths(AList.of(pair("x","foo"))).run().assertBody().contains("GET
/echo/foo HTTP/1.1");
+
client().build().get("/echo/{x}").paths(pairs("x","foo")).run().assertBody().contains("GET
/echo/foo HTTP/1.1");
+
client().build().get("/echo/{x}").paths(OMap.of("x","foo")).run().assertBody().contains("GET
/echo/foo HTTP/1.1");
+ client().build().get("/echo/{x}").paths((Object)new
NameValuePair[]{pair("x","foo")}).run().assertBody().contains("GET /echo/foo
HTTP/1.1");
+ client().build().get("/echo/{x}").paths(new
A1().init()).run().assertBody().contains("GET /echo/1 HTTP/1.1");
assertThrown(()->client().build().get("/echo/{x}").paths("x")).is("Invalid type
passed to paths(): java.lang.String");
-
client().build().get("/echo/{x}").paths((Object)null).run().assertBody().contains("HTTP
GET /echo/%7Bx%7D");
+
client().build().get("/echo/{x}").paths((Object)null).run().assertBody().contains("GET
/echo/%7Bx%7D HTTP/1.1");
}
@Test
public void a04_pathPairs_Objects() throws Exception {
-
client().build().get("/echo/{x}").pathPairs("x",1).run().assertBody().contains("HTTP
GET /echo/1");
+
client().build().get("/echo/{x}").pathPairs("x",1).run().assertBody().contains("GET
/echo/1 HTTP/1.1");
assertThrown(()->client().build().get("/echo/{x}").pathPairs("x")).is("Odd
number of parameters passed into pathPairs()");
}
@Test
public void a05_path_String_Object_Schema() throws Exception {
String[] a = new String[]{"foo","bar"};
-
client().build().get("/echo/{x}").path("x",a,T_ARRAY_PIPES).run().assertBody().contains("HTTP
GET /echo/foo%7Cbar");
+
client().build().get("/echo/{x}").path("x",a,T_ARRAY_PIPES).run().assertBody().contains("GET
/echo/foo%7Cbar HTTP/1.1");
}
//------------------------------------------------------------------------------------------------------------------
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Body_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Body_Test.java
index 9ea5202..2e777f8 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Body_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Body_Test.java
@@ -223,11 +223,11 @@ public class RestClient_Response_Body_Test {
testClient().entity(stringEntity("{f:1}")).get().run().getBody().as(x4,ABean.class);
assertObject(x4.get()).asJson().is("{f:1}");
- HttpEntity x5 =
testClient().entity(stringEntity("{f:1}")).get().run().getBody().as(RestResponseBody.class);
- assertTrue(x5 instanceof RestResponseBody);
+ HttpEntity x5 =
testClient().entity(stringEntity("{f:1}")).get().run().getBody().as(ResponseBody.class);
+ assertTrue(x5 instanceof ResponseBody);
HttpEntity x6 =
testClient().entity(stringEntity("{f:1}")).get().run().getBody().as(HttpEntity.class);
- assertTrue(x6 instanceof RestResponseBody);
+ assertTrue(x6 instanceof ResponseBody);
plainTestClient().entity(stringEntity("foo")).get().run().getBody().assertObject(A7a.class).passes(x->((A7a)x).x.equals("foo"));
plainTestClient().entity(stringEntity("foo")).get().run().getBody().assertObject(A7b.class).passes(x->((A7b)x).x.equals("foo"));
@@ -322,10 +322,10 @@ public class RestClient_Response_Body_Test {
@SuppressWarnings("deprecation")
@Test
public void b01_httpEntityMethods() throws Exception {
- RestResponseBody x1 =
testClient().entity(stringEntity("foo")).get().run().getBody();
+ ResponseBody x1 =
testClient().entity(stringEntity("foo")).get().run().getBody();
assertTrue(x1.isRepeatable());
- RestResponseBody x2 =
testClient().entity(inputStreamEntity("foo")).get().run().getBody();
+ ResponseBody x2 =
testClient().entity(inputStreamEntity("foo")).get().run().getBody();
assertFalse(x2.isRepeatable());
assertLong(x2.getContentLength()).is(-1l);
x2.cache().asString();
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Headers_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Headers_Test.java
index d0cd4b8..893a3ec 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Headers_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Headers_Test.java
@@ -52,8 +52,8 @@ public class RestClient_Response_Headers_Test {
@Test
public void a01_exists() throws Exception {
-
assertFalse(checkFooClient().build().get("/echo").run().getHeader("Foo").exists());
-
assertTrue(checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Foo").exists());
+
assertFalse(checkFooClient().build().get("/echo").run().getResponseHeader("Foo").exists());
+
assertTrue(checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Foo").exists());
}
public static class A2 extends BasicHeader {
@@ -66,132 +66,132 @@ public class RestClient_Response_Headers_Test {
@Test
public void a02_asHeader() throws Exception {
- Header h =
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Foo").asHeader(BasicStringHeader.class).assertName().is("Foo").assertValue().is("bar");
+ Header h =
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Foo").asHeader(BasicStringHeader.class).assertName().is("Foo").assertValue().is("bar");
assertTrue(h instanceof BasicStringHeader);
- h =
checkFooClient().build().get("/echo").header("Foo","\"bar\"").run().getHeader("Foo").asHeader(ETag.class).assertName().is("ETag").assertValue().is("\"bar\"");
+ h =
checkFooClient().build().get("/echo").header("Foo","\"bar\"").run().getResponseHeader("Foo").asHeader(ETag.class).assertName().is("ETag").assertValue().is("\"bar\"");
assertTrue(h instanceof ETag);
-
assertThrown(()->checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Foo").asHeader(Age.class)).contains("Value
could not be parsed");
-
assertThrown(()->checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Foo").asHeader(A2.class)).contains("Could
not determine a method to construct type");
+
assertThrown(()->checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Foo").asHeader(Age.class)).contains("Value
could not be parsed");
+
assertThrown(()->checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Foo").asHeader(A2.class)).contains("Could
not determine a method to construct type");
-
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Foo").asCsvArrayHeader().assertName().is("Foo").assertValue().is("bar");
-
checkFooClient().build().get("/echo").header("Foo","*").run().getHeader("Foo").asEntityTagArrayHeader().assertName().is("Foo").assertValue().is("*");
-
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Foo").asStringRangeArrayHeader().assertName().is("Foo").assertValue().is("bar");
-
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Foo").asStringHeader().assertName().is("Foo").assertValue().is("bar");
-
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Foo").asUriHeader().assertName().is("Foo").assertValue().is("bar");
+
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Foo").asCsvArrayHeader().assertName().is("Foo").assertValue().is("bar");
+
checkFooClient().build().get("/echo").header("Foo","*").run().getResponseHeader("Foo").asEntityTagArrayHeader().assertName().is("Foo").assertValue().is("*");
+
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Foo").asStringRangeArrayHeader().assertName().is("Foo").assertValue().is("bar");
+
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Foo").asStringHeader().assertName().is("Foo").assertValue().is("bar");
+
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Foo").asUriHeader().assertName().is("Foo").assertValue().is("bar");
}
@Test
public void a03_asString() throws Exception {
- String s =
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Foo").asString();
+ String s =
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Foo").asString();
assertEquals("bar", s);
Mutable<String> m = Mutable.create();
-
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Foo").asString(m);
+
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Foo").asString(m);
assertEquals("bar", m.get());
- Optional<String> o =
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Foo").asOptionalString();
+ Optional<String> o =
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Foo").asOptionalString();
assertEquals("bar", o.get());
- o =
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Bar").asOptionalString();
+ o =
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Bar").asOptionalString();
assertFalse(o.isPresent());
- s =
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Foo").asStringOrElse("baz");
+ s =
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Foo").asStringOrElse("baz");
assertEquals("bar", s);
- s =
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Bar").asStringOrElse("baz");
+ s =
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Bar").asStringOrElse("baz");
assertEquals("baz", s);
-
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Foo").asStringOrElse(m,"baz");
+
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Foo").asStringOrElse(m,"baz");
assertEquals("bar", m.get());
-
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Bar").asStringOrElse(m,"baz");
+
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Bar").asStringOrElse(m,"baz");
assertEquals("baz", m.get());
}
@Test
public void a04_asType() throws Exception {
- Integer i =
checkFooClient().build().get("/echo").header("Foo","123").run().getHeader("Foo").as(Integer.class);
+ Integer i =
checkFooClient().build().get("/echo").header("Foo","123").run().getResponseHeader("Foo").as(Integer.class);
assertEquals(123, i.intValue());
Mutable<Integer> m1 = Mutable.create();
-
checkFooClient().build().get("/echo").header("Foo","123").run().getHeader("Foo").as(m1,Integer.class);
+
checkFooClient().build().get("/echo").header("Foo","123").run().getResponseHeader("Foo").as(m1,Integer.class);
assertEquals(123, m1.get().intValue());
- List<Integer> l =
checkFooClient().build().get("/echo").header("Foo","1,2").run().getHeader("Foo").as(LinkedList.class,Integer.class);
+ List<Integer> l =
checkFooClient().build().get("/echo").header("Foo","1,2").run().getResponseHeader("Foo").as(LinkedList.class,Integer.class);
assertObject(l).asJson().is("[1,2]");
Mutable<Integer> m2 = Mutable.create();
-
checkFooClient().build().get("/echo").header("Foo","1,2").run().getHeader("Foo").as(m2,LinkedList.class,Integer.class);
+
checkFooClient().build().get("/echo").header("Foo","1,2").run().getResponseHeader("Foo").as(m2,LinkedList.class,Integer.class);
assertObject(m2.get()).asJson().is("[1,2]");
ClassMeta<LinkedList<Integer>> cm1 =
BeanContext.DEFAULT.getClassMeta(LinkedList.class, Integer.class);
ClassMeta<Integer> cm2 =
BeanContext.DEFAULT.getClassMeta(Integer.class);
- l =
checkFooClient().build().get("/echo").header("Foo","1,2").run().getHeader("Foo").as(cm1);
+ l =
checkFooClient().build().get("/echo").header("Foo","1,2").run().getResponseHeader("Foo").as(cm1);
assertObject(l).asJson().is("[1,2]");
Mutable<LinkedList<Integer>> m3 = Mutable.create();
-
checkFooClient().build().get("/echo").header("Foo","1,2").run().getHeader("Foo").as(m3,cm1);
+
checkFooClient().build().get("/echo").header("Foo","1,2").run().getResponseHeader("Foo").as(m3,cm1);
assertObject(m3.get()).asJson().is("[1,2]");
-
assertThrown(()->checkFooClient().build().get("/echo").header("Foo","foo").run().getHeader("Foo").as(m2,cm1)).contains("Invalid
number");
+
assertThrown(()->checkFooClient().build().get("/echo").header("Foo","foo").run().getResponseHeader("Foo").as(m2,cm1)).contains("Invalid
number");
- Optional<List<Integer>> o1 =
checkFooClient().build().get("/echo").header("Foo","1,2").run().getHeader("Foo").asOptional(LinkedList.class,Integer.class);
+ Optional<List<Integer>> o1 =
checkFooClient().build().get("/echo").header("Foo","1,2").run().getResponseHeader("Foo").asOptional(LinkedList.class,Integer.class);
assertObject(o1.get()).asJson().is("[1,2]");
- o1 =
checkFooClient().build().get("/echo").header("Foo","1,2").run().getHeader("Bar").asOptional(LinkedList.class,Integer.class);
+ o1 =
checkFooClient().build().get("/echo").header("Foo","1,2").run().getResponseHeader("Bar").asOptional(LinkedList.class,Integer.class);
assertFalse(o1.isPresent());
Mutable<Optional<List<Integer>>> m4 = Mutable.create();
-
checkFooClient().build().get("/echo").header("Foo","1,2").run().getHeader("Foo").asOptional(m4,LinkedList.class,Integer.class);
+
checkFooClient().build().get("/echo").header("Foo","1,2").run().getResponseHeader("Foo").asOptional(m4,LinkedList.class,Integer.class);
assertObject(m4.get().get()).asJson().is("[1,2]");
-
checkFooClient().build().get("/echo").header("Foo","1,2").run().getHeader("Bar").asOptional(m4,LinkedList.class,Integer.class);
+
checkFooClient().build().get("/echo").header("Foo","1,2").run().getResponseHeader("Bar").asOptional(m4,LinkedList.class,Integer.class);
assertFalse(m4.get().isPresent());
- Optional<Integer> o2 =
checkFooClient().build().get("/echo").header("Foo","1").run().getHeader("Foo").asOptional(Integer.class);
+ Optional<Integer> o2 =
checkFooClient().build().get("/echo").header("Foo","1").run().getResponseHeader("Foo").asOptional(Integer.class);
assertEquals(1, o2.get().intValue());
- o2 =
checkFooClient().build().get("/echo").header("Foo","1").run().getHeader("Bar").asOptional(Integer.class);
+ o2 =
checkFooClient().build().get("/echo").header("Foo","1").run().getResponseHeader("Bar").asOptional(Integer.class);
assertFalse(o2.isPresent());
- o2 =
checkFooClient().build().get("/echo").header("Foo","1").run().getHeader("Foo").asOptional(cm2);
+ o2 =
checkFooClient().build().get("/echo").header("Foo","1").run().getResponseHeader("Foo").asOptional(cm2);
assertEquals(1, o2.get().intValue());
- o2 =
checkFooClient().build().get("/echo").header("Foo","1").run().getHeader("Bar").asOptional(cm2);
+ o2 =
checkFooClient().build().get("/echo").header("Foo","1").run().getResponseHeader("Bar").asOptional(cm2);
assertFalse(o2.isPresent());
Mutable<Optional<Integer>> m5 = Mutable.create();
-
checkFooClient().build().get("/echo").header("Foo","1").run().getHeader("Foo").asOptional(m5,Integer.class);
+
checkFooClient().build().get("/echo").header("Foo","1").run().getResponseHeader("Foo").asOptional(m5,Integer.class);
assertEquals(1, m5.get().get().intValue());
-
checkFooClient().build().get("/echo").header("Foo","1,2").run().getHeader("Bar").asOptional(m5,Integer.class);
+
checkFooClient().build().get("/echo").header("Foo","1,2").run().getResponseHeader("Bar").asOptional(m5,Integer.class);
assertFalse(m5.get().isPresent());
m5 = Mutable.create();
-
checkFooClient().build().get("/echo").header("Foo","1").run().getHeader("Foo").asOptional(m5,cm2);
+
checkFooClient().build().get("/echo").header("Foo","1").run().getResponseHeader("Foo").asOptional(m5,cm2);
assertEquals(1, m5.get().get().intValue());
-
checkFooClient().build().get("/echo").header("Foo","1,2").run().getHeader("Bar").asOptional(m5,cm2);
+
checkFooClient().build().get("/echo").header("Foo","1,2").run().getResponseHeader("Bar").asOptional(m5,cm2);
assertFalse(m5.get().isPresent());
-
assertTrue(checkFooClient().build().get("/echo").header("Foo","foo").run().getHeader("Foo").asMatcher("foo").matches());
-
assertFalse(checkFooClient().build().get("/echo").header("Foo","foo").run().getHeader("Bar").asMatcher("foo").matches());
-
assertTrue(checkFooClient().build().get("/echo").header("Foo","foo").run().getHeader("Foo").asMatcher("FOO",Pattern.CASE_INSENSITIVE).matches());
-
assertFalse(checkFooClient().build().get("/echo").header("Foo","foo").run().getHeader("Bar").asMatcher("FOO",Pattern.CASE_INSENSITIVE).matches());
+
assertTrue(checkFooClient().build().get("/echo").header("Foo","foo").run().getResponseHeader("Foo").asMatcher("foo").matches());
+
assertFalse(checkFooClient().build().get("/echo").header("Foo","foo").run().getResponseHeader("Bar").asMatcher("foo").matches());
+
assertTrue(checkFooClient().build().get("/echo").header("Foo","foo").run().getResponseHeader("Foo").asMatcher("FOO",Pattern.CASE_INSENSITIVE).matches());
+
assertFalse(checkFooClient().build().get("/echo").header("Foo","foo").run().getResponseHeader("Bar").asMatcher("FOO",Pattern.CASE_INSENSITIVE).matches());
Mutable<Matcher> m6 = Mutable.create();
-
checkFooClient().build().get("/echo").header("Foo","foo").run().getHeader("Foo").asMatcher(m6,"foo");
+
checkFooClient().build().get("/echo").header("Foo","foo").run().getResponseHeader("Foo").asMatcher(m6,"foo");
assertTrue(m6.get().matches());
-
checkFooClient().build().get("/echo").header("Foo","foo").run().getHeader("Bar").asMatcher(m6,"foo");
+
checkFooClient().build().get("/echo").header("Foo","foo").run().getResponseHeader("Bar").asMatcher(m6,"foo");
assertFalse(m6.get().matches());
-
checkFooClient().build().get("/echo").header("Foo","foo").run().getHeader("Foo").asMatcher(m6,"FOO",Pattern.CASE_INSENSITIVE);
+
checkFooClient().build().get("/echo").header("Foo","foo").run().getResponseHeader("Foo").asMatcher(m6,"FOO",Pattern.CASE_INSENSITIVE);
assertTrue(m6.get().matches());
-
checkFooClient().build().get("/echo").header("Foo","foo").run().getHeader("Bar").asMatcher(m6,"FOO",Pattern.CASE_INSENSITIVE);
+
checkFooClient().build().get("/echo").header("Foo","foo").run().getResponseHeader("Bar").asMatcher(m6,"FOO",Pattern.CASE_INSENSITIVE);
assertFalse(m6.get().matches());
-
checkFooClient().build().get("/echo").header("Foo","foo").run().getHeader("Foo").asMatcher(m6,Pattern.compile("FOO",Pattern.CASE_INSENSITIVE));
+
checkFooClient().build().get("/echo").header("Foo","foo").run().getResponseHeader("Foo").asMatcher(m6,Pattern.compile("FOO",Pattern.CASE_INSENSITIVE));
assertTrue(m6.get().matches());
-
checkFooClient().build().get("/echo").header("Foo","foo").run().getHeader("Bar").asMatcher(m6,Pattern.compile("FOO",Pattern.CASE_INSENSITIVE));
+
checkFooClient().build().get("/echo").header("Foo","foo").run().getResponseHeader("Bar").asMatcher(m6,Pattern.compile("FOO",Pattern.CASE_INSENSITIVE));
assertFalse(m6.get().matches());
}
@Test
public void a05_toResponse() throws Exception {
RestResponse r =
checkFooClient().build().get("/echo").header("Foo","123").run();
- assertTrue(r == r.getHeader("Foo").toResponse());
+ assertTrue(r == r.getResponseHeader("Foo").toResponse());
}
//------------------------------------------------------------------------------------------------------------------
@@ -200,14 +200,14 @@ public class RestClient_Response_Headers_Test {
@Test
public void b01_assertions() throws Exception {
-
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Foo").assertString().is("bar");
-
checkFooClient().build().get("/echo").header("Foo","bar").run().getHeader("Bar").assertString().doesNotExist();
-
checkFooClient().build().get("/echo").header("Foo","123").run().getHeader("Foo").assertInteger().is(123);
-
checkFooClient().build().get("/echo").header("Foo","123").run().getHeader("Bar").assertInteger().doesNotExist();
-
checkFooClient().build().get("/echo").header("Foo","123").run().getHeader("Foo").assertLong().is(123l);
-
checkFooClient().build().get("/echo").header("Foo","123").run().getHeader("Bar").assertLong().doesNotExist();
-
checkFooClient().build().get("/echo").header(BasicDateHeader.of("Foo",CALENDAR)).run().getHeader("Foo").assertDate().exists();
-
checkFooClient().build().get("/echo").header(BasicDateHeader.of("Foo",CALENDAR)).run().getHeader("Bar").assertDate().doesNotExist();
+
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Foo").assertString().is("bar");
+
checkFooClient().build().get("/echo").header("Foo","bar").run().getResponseHeader("Bar").assertString().doesNotExist();
+
checkFooClient().build().get("/echo").header("Foo","123").run().getResponseHeader("Foo").assertInteger().is(123);
+
checkFooClient().build().get("/echo").header("Foo","123").run().getResponseHeader("Bar").assertInteger().doesNotExist();
+
checkFooClient().build().get("/echo").header("Foo","123").run().getResponseHeader("Foo").assertLong().is(123l);
+
checkFooClient().build().get("/echo").header("Foo","123").run().getResponseHeader("Bar").assertLong().doesNotExist();
+
checkFooClient().build().get("/echo").header(BasicDateHeader.of("Foo",CALENDAR)).run().getResponseHeader("Foo").assertDate().exists();
+
checkFooClient().build().get("/echo").header(BasicDateHeader.of("Foo",CALENDAR)).run().getResponseHeader("Bar").assertDate().doesNotExist();
}
//------------------------------------------------------------------------------------------------------------------
@@ -216,12 +216,12 @@ public class RestClient_Response_Headers_Test {
@Test
public void c01_getElements() throws Exception {
- HeaderElement[] e =
checkFooClient().build().get("/echo").header("Foo","bar=baz;qux=quux").run().getHeader("Foo").getElements();
+ HeaderElement[] e =
checkFooClient().build().get("/echo").header("Foo","bar=baz;qux=quux").run().getResponseHeader("Foo").getElements();
assertEquals("bar", e[0].getName());
assertEquals("baz", e[0].getValue());
assertEquals("quux", e[0].getParameterByName("qux").getValue());
- e =
checkFooClient().build().get("/echo").header("Foo","bar=baz;qux=quux").run().getHeader("Bar").getElements();
+ e =
checkFooClient().build().get("/echo").header("Foo","bar=baz;qux=quux").run().getResponseHeader("Bar").getElements();
assertEquals(0, e.length);
}
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Test.java
index bb41eaf..4c288c4 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Response_Test.java
@@ -217,7 +217,7 @@ public class RestClient_Response_Test {
assertNull(r.getFirstHeader("Foo"));
r.setHeader(BasicHeader.of("Foo","quuux"));
- r.getHeader("Foo").assertString().is("quuux");
+ r.getResponseHeader("Foo").assertString().is("quuux");
}
//------------------------------------------------------------------------------------------------------------------
diff --git
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Test.java
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Test.java
index bea5fe5..70d8bb9 100644
---
a/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Test.java
+++
b/juneau-utest/src/test/java/org/apache/juneau/rest/client/RestClient_Test.java
@@ -228,13 +228,13 @@ public class RestClient_Test {
return super.execute(request, conn, context);
}
};
-
client().requestExecutor(x).build().get("/echo").run().assertBody().contains("HTTP
GET /echo");
+
client().requestExecutor(x).build().get("/echo").run().assertBody().contains("GET
/echo HTTP/1.1");
assertTrue(b1.get());
}
@Test
public void c04_httpClient_defaultHeaders() throws RestCallException {
- client().defaultHeaders(AList.of(new
org.apache.http.message.BasicHeader("Foo","bar"))).build().get("/echo").run().assertBody().contains("HTTP
GET /echo","Foo: bar");
+ client().defaultHeaders(AList.of(new
org.apache.http.message.BasicHeader("Foo","bar"))).build().get("/echo").run().assertBody().contains("GET
/echo HTTP/1.1","Foo: bar");
}
@Test
