Here are the examples of the java api org.springframework.http.converter.HttpMessageConverter taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.
189 Examples
19
Source : HttpMessageConvertersTests.java
with Apache License 2.0
from yuanmabiji
with Apache License 2.0
from yuanmabiji
@Test
public void addNewConverters() {
HttpMessageConverter<?> converter1 = mock(HttpMessageConverter.clreplaced);
HttpMessageConverter<?> converter2 = mock(HttpMessageConverter.clreplaced);
HttpMessageConverters converters = new HttpMessageConverters(converter1, converter2);
replacedertThat(converters.getConverters().get(0)).isEqualTo(converter1);
replacedertThat(converters.getConverters().get(1)).isEqualTo(converter2);
}
19
Source : HttpMessageConvertersTests.java
with Apache License 2.0
from yuanmabiji
with Apache License 2.0
from yuanmabiji
private AllEncompreplacedingFormHttpMessageConverter findFormConverter(Collection<HttpMessageConverter<?>> converters) {
for (HttpMessageConverter<?> converter : converters) {
if (converter instanceof AllEncompreplacedingFormHttpMessageConverter) {
return (AllEncompreplacedingFormHttpMessageConverter) converter;
}
}
return null;
}
19
Source : RequestPartMethodArgumentResolverTests.java
with MIT License
from Vip-Augus
with MIT License
from Vip-Augus
/**
* Test fixture with {@link RequestPartMethodArgumentResolver} and mock {@link HttpMessageConverter}.
*
* @author Rossen Stoyanchev
* @author Brian Clozel
*/
public clreplaced RequestPartMethodArgumentResolverTests {
private HttpMessageConverter<SimpleBean> messageConverter;
private RequestPartMethodArgumentResolver resolver;
private MultipartFile multipartFile1;
private MultipartFile multipartFile2;
private MockMultipartHttpServletRequest multipartRequest;
private NativeWebRequest webRequest;
private MethodParameter paramRequestPart;
private MethodParameter paramNamedRequestPart;
private MethodParameter paramValidRequestPart;
private MethodParameter paramMultipartFile;
private MethodParameter paramMultipartFileList;
private MethodParameter paramMultipartFileArray;
private MethodParameter paramInt;
private MethodParameter paramMultipartFileNotAnnot;
private MethodParameter paramPart;
private MethodParameter paramPartList;
private MethodParameter paramPartArray;
private MethodParameter paramRequestParamAnnot;
private MethodParameter optionalMultipartFile;
private MethodParameter optionalMultipartFileList;
private MethodParameter optionalPart;
private MethodParameter optionalPartList;
private MethodParameter optionalRequestPart;
@Before
@SuppressWarnings("unchecked")
public void setup() throws Exception {
messageConverter = mock(HttpMessageConverter.clreplaced);
given(messageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
resolver = new RequestPartMethodArgumentResolver(Collections.singletonList(messageConverter));
reset(messageConverter);
byte[] content = "doesn't matter as long as not empty".getBytes(StandardCharsets.UTF_8);
multipartFile1 = new MockMultipartFile("requestPart", "", "text/plain", content);
multipartFile2 = new MockMultipartFile("requestPart", "", "text/plain", content);
multipartRequest = new MockMultipartHttpServletRequest();
multipartRequest.addFile(multipartFile1);
multipartRequest.addFile(multipartFile2);
multipartRequest.addFile(new MockMultipartFile("otherPart", "", "text/plain", content));
webRequest = new ServletWebRequest(multipartRequest, new MockHttpServletResponse());
Method method = ReflectionUtils.findMethod(getClreplaced(), "handle", (Clreplaced<?>[]) null);
paramRequestPart = new SynthesizingMethodParameter(method, 0);
paramRequestPart.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
paramNamedRequestPart = new SynthesizingMethodParameter(method, 1);
paramValidRequestPart = new SynthesizingMethodParameter(method, 2);
paramMultipartFile = new SynthesizingMethodParameter(method, 3);
paramMultipartFileList = new SynthesizingMethodParameter(method, 4);
paramMultipartFileArray = new SynthesizingMethodParameter(method, 5);
paramInt = new SynthesizingMethodParameter(method, 6);
paramMultipartFileNotAnnot = new SynthesizingMethodParameter(method, 7);
paramMultipartFileNotAnnot.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
paramPart = new SynthesizingMethodParameter(method, 8);
paramPart.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
paramPartList = new SynthesizingMethodParameter(method, 9);
paramPartArray = new SynthesizingMethodParameter(method, 10);
paramRequestParamAnnot = new SynthesizingMethodParameter(method, 11);
optionalMultipartFile = new SynthesizingMethodParameter(method, 12);
optionalMultipartFile.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
optionalMultipartFileList = new SynthesizingMethodParameter(method, 13);
optionalMultipartFileList.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
optionalPart = new SynthesizingMethodParameter(method, 14);
optionalPart.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
optionalPartList = new SynthesizingMethodParameter(method, 15);
optionalPartList.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
optionalRequestPart = new SynthesizingMethodParameter(method, 16);
}
@Test
public void supportsParameter() {
replacedertTrue(resolver.supportsParameter(paramRequestPart));
replacedertTrue(resolver.supportsParameter(paramNamedRequestPart));
replacedertTrue(resolver.supportsParameter(paramValidRequestPart));
replacedertTrue(resolver.supportsParameter(paramMultipartFile));
replacedertTrue(resolver.supportsParameter(paramMultipartFileList));
replacedertTrue(resolver.supportsParameter(paramMultipartFileArray));
replacedertFalse(resolver.supportsParameter(paramInt));
replacedertTrue(resolver.supportsParameter(paramMultipartFileNotAnnot));
replacedertTrue(resolver.supportsParameter(paramPart));
replacedertTrue(resolver.supportsParameter(paramPartList));
replacedertTrue(resolver.supportsParameter(paramPartArray));
replacedertFalse(resolver.supportsParameter(paramRequestParamAnnot));
replacedertTrue(resolver.supportsParameter(optionalMultipartFile));
replacedertTrue(resolver.supportsParameter(optionalMultipartFileList));
replacedertTrue(resolver.supportsParameter(optionalPart));
replacedertTrue(resolver.supportsParameter(optionalPartList));
replacedertTrue(resolver.supportsParameter(optionalRequestPart));
}
@Test
public void resolveMultipartFile() throws Exception {
Object actual = resolver.resolveArgument(paramMultipartFile, null, webRequest, null);
replacedertSame(multipartFile1, actual);
}
@Test
public void resolveMultipartFileList() throws Exception {
Object actual = resolver.resolveArgument(paramMultipartFileList, null, webRequest, null);
replacedertTrue(actual instanceof List);
replacedertEquals(Arrays.asList(multipartFile1, multipartFile2), actual);
}
@Test
public void resolveMultipartFileArray() throws Exception {
Object actual = resolver.resolveArgument(paramMultipartFileArray, null, webRequest, null);
replacedertNotNull(actual);
replacedertTrue(actual instanceof MultipartFile[]);
MultipartFile[] parts = (MultipartFile[]) actual;
replacedertEquals(2, parts.length);
replacedertEquals(parts[0], multipartFile1);
replacedertEquals(parts[1], multipartFile2);
}
@Test
public void resolveMultipartFileNotAnnotArgument() throws Exception {
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
MultipartFile expected = new MockMultipartFile("multipartFileNotAnnot", "Hello World".getBytes());
request.addFile(expected);
request.addFile(new MockMultipartFile("otherPart", "", "text/plain", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(paramMultipartFileNotAnnot, null, webRequest, null);
replacedertTrue(result instanceof MultipartFile);
replacedertEquals("Invalid result", expected, result);
}
@Test
public void resolvePartArgument() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
MockPart expected = new MockPart("part", "Hello World".getBytes());
request.addPart(expected);
request.addPart(new MockPart("otherPart", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(paramPart, null, webRequest, null);
replacedertTrue(result instanceof Part);
replacedertEquals("Invalid result", expected, result);
}
@Test
public void resolvePartListArgument() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
MockPart part1 = new MockPart("requestPart", "Hello World 1".getBytes());
MockPart part2 = new MockPart("requestPart", "Hello World 2".getBytes());
request.addPart(part1);
request.addPart(part2);
request.addPart(new MockPart("otherPart", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(paramPartList, null, webRequest, null);
replacedertTrue(result instanceof List);
replacedertEquals(Arrays.asList(part1, part2), result);
}
@Test
public void resolvePartArrayArgument() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
MockPart part1 = new MockPart("requestPart", "Hello World 1".getBytes());
MockPart part2 = new MockPart("requestPart", "Hello World 2".getBytes());
request.addPart(part1);
request.addPart(part2);
request.addPart(new MockPart("otherPart", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(paramPartArray, null, webRequest, null);
replacedertTrue(result instanceof Part[]);
Part[] parts = (Part[]) result;
replacedertEquals(2, parts.length);
replacedertEquals(parts[0], part1);
replacedertEquals(parts[1], part2);
}
@Test
public void resolveRequestPart() throws Exception {
testResolveArgument(new SimpleBean("foo"), paramRequestPart);
}
@Test
public void resolveNamedRequestPart() throws Exception {
testResolveArgument(new SimpleBean("foo"), paramNamedRequestPart);
}
@Test
public void resolveNamedRequestPartNotPresent() throws Exception {
testResolveArgument(null, paramNamedRequestPart);
}
@Test
public void resolveRequestPartNotValid() throws Exception {
try {
testResolveArgument(new SimpleBean(null), paramValidRequestPart);
fail("Expected exception");
} catch (MethodArgumentNotValidException ex) {
replacedertEquals("requestPart", ex.getBindingResult().getObjectName());
replacedertEquals(1, ex.getBindingResult().getErrorCount());
replacedertNotNull(ex.getBindingResult().getFieldError("name"));
}
}
@Test
public void resolveRequestPartValid() throws Exception {
testResolveArgument(new SimpleBean("foo"), paramValidRequestPart);
}
@Test
public void resolveRequestPartRequired() throws Exception {
try {
testResolveArgument(null, paramValidRequestPart);
fail("Expected exception");
} catch (MissingServletRequestPartException ex) {
replacedertEquals("requestPart", ex.getRequestPartName());
}
}
@Test
public void resolveRequestPartNotRequired() throws Exception {
testResolveArgument(new SimpleBean("foo"), paramValidRequestPart);
}
@Test(expected = MultipartException.clreplaced)
public void isMultipartRequest() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
resolver.resolveArgument(paramMultipartFile, new ModelAndViewContainer(), new ServletWebRequest(request), null);
}
// SPR-9079
@Test
public void isMultipartRequestPut() throws Exception {
this.multipartRequest.setMethod("PUT");
Object actualValue = resolver.resolveArgument(paramMultipartFile, null, webRequest, null);
replacedertSame(multipartFile1, actualValue);
}
@Test
public void resolveOptionalMultipartFileArgument() throws Exception {
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
MultipartFile expected = new MockMultipartFile("optionalMultipartFile", "Hello World".getBytes());
request.addFile(expected);
request.addFile(new MockMultipartFile("otherPart", "", "text/plain", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalMultipartFile, null, webRequest, null);
replacedertTrue(actualValue instanceof Optional);
replacedertEquals("Invalid result", expected, ((Optional<?>) actualValue).get());
actualValue = resolver.resolveArgument(optionalMultipartFile, null, webRequest, null);
replacedertTrue(actualValue instanceof Optional);
replacedertEquals("Invalid result", expected, ((Optional<?>) actualValue).get());
}
@Test
public void resolveOptionalMultipartFileArgumentNotPresent() throws Exception {
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalMultipartFile, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
actualValue = resolver.resolveArgument(optionalMultipartFile, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
}
@Test
public void resolveOptionalMultipartFileArgumentWithoutMultipartRequest() throws Exception {
webRequest = new ServletWebRequest(new MockHttpServletRequest());
Object actualValue = resolver.resolveArgument(optionalMultipartFile, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
actualValue = resolver.resolveArgument(optionalMultipartFile, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
}
@Test
public void resolveOptionalMultipartFileList() throws Exception {
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
MultipartFile expected = new MockMultipartFile("requestPart", "Hello World".getBytes());
request.addFile(expected);
request.addFile(new MockMultipartFile("otherPart", "", "text/plain", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalMultipartFileList, null, webRequest, null);
replacedertTrue(actualValue instanceof Optional);
replacedertEquals("Invalid result", Collections.singletonList(expected), ((Optional<?>) actualValue).get());
actualValue = resolver.resolveArgument(optionalMultipartFileList, null, webRequest, null);
replacedertTrue(actualValue instanceof Optional);
replacedertEquals("Invalid result", Collections.singletonList(expected), ((Optional<?>) actualValue).get());
}
@Test
public void resolveOptionalMultipartFileListNotPresent() throws Exception {
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalMultipartFileList, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
actualValue = resolver.resolveArgument(optionalMultipartFileList, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
}
@Test
public void resolveOptionalMultipartFileListWithoutMultipartRequest() throws Exception {
webRequest = new ServletWebRequest(new MockHttpServletRequest());
Object actualValue = resolver.resolveArgument(optionalMultipartFileList, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
actualValue = resolver.resolveArgument(optionalMultipartFileList, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
}
@Test
public void resolveOptionalPartArgument() throws Exception {
MockPart expected = new MockPart("optionalPart", "Hello World".getBytes());
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
request.addPart(expected);
request.addPart(new MockPart("otherPart", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalPart, null, webRequest, null);
replacedertTrue(actualValue instanceof Optional);
replacedertEquals("Invalid result", expected, ((Optional<?>) actualValue).get());
actualValue = resolver.resolveArgument(optionalPart, null, webRequest, null);
replacedertTrue(actualValue instanceof Optional);
replacedertEquals("Invalid result", expected, ((Optional<?>) actualValue).get());
}
@Test
public void resolveOptionalPartArgumentNotPresent() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalPart, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
actualValue = resolver.resolveArgument(optionalPart, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
}
@Test
public void resolveOptionalPartArgumentWithoutMultipartRequest() throws Exception {
webRequest = new ServletWebRequest(new MockHttpServletRequest());
Object actualValue = resolver.resolveArgument(optionalPart, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
actualValue = resolver.resolveArgument(optionalPart, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
}
@Test
public void resolveOptionalPartList() throws Exception {
MockPart expected = new MockPart("requestPart", "Hello World".getBytes());
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
request.addPart(expected);
request.addPart(new MockPart("otherPart", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalPartList, null, webRequest, null);
replacedertTrue(actualValue instanceof Optional);
replacedertEquals("Invalid result", Collections.singletonList(expected), ((Optional<?>) actualValue).get());
actualValue = resolver.resolveArgument(optionalPartList, null, webRequest, null);
replacedertTrue(actualValue instanceof Optional);
replacedertEquals("Invalid result", Collections.singletonList(expected), ((Optional<?>) actualValue).get());
}
@Test
public void resolveOptionalPartListNotPresent() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalPartList, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
actualValue = resolver.resolveArgument(optionalPartList, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
}
@Test
public void resolveOptionalPartListWithoutMultipartRequest() throws Exception {
webRequest = new ServletWebRequest(new MockHttpServletRequest());
Object actualValue = resolver.resolveArgument(optionalPartList, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
actualValue = resolver.resolveArgument(optionalPartList, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
}
@Test
public void resolveOptionalRequestPart() throws Exception {
SimpleBean simpleBean = new SimpleBean("foo");
given(messageConverter.canRead(SimpleBean.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(messageConverter.read(eq(SimpleBean.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(simpleBean);
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
Object actualValue = resolver.resolveArgument(optionalRequestPart, mavContainer, webRequest, new ValidatingBinderFactory());
replacedertEquals("Invalid argument value", Optional.of(simpleBean), actualValue);
replacedertFalse("The requestHandled flag shouldn't change", mavContainer.isRequestHandled());
actualValue = resolver.resolveArgument(optionalRequestPart, mavContainer, webRequest, new ValidatingBinderFactory());
replacedertEquals("Invalid argument value", Optional.of(simpleBean), actualValue);
replacedertFalse("The requestHandled flag shouldn't change", mavContainer.isRequestHandled());
}
@Test
public void resolveOptionalRequestPartNotPresent() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalRequestPart, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
actualValue = resolver.resolveArgument(optionalRequestPart, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
}
@Test
public void resolveOptionalRequestPartWithoutMultipartRequest() throws Exception {
webRequest = new ServletWebRequest(new MockHttpServletRequest());
Object actualValue = resolver.resolveArgument(optionalRequestPart, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
actualValue = resolver.resolveArgument(optionalRequestPart, null, webRequest, null);
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
}
private void testResolveArgument(SimpleBean argValue, MethodParameter parameter) throws Exception {
given(messageConverter.canRead(SimpleBean.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(messageConverter.read(eq(SimpleBean.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(argValue);
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
Object actualValue = resolver.resolveArgument(parameter, mavContainer, webRequest, new ValidatingBinderFactory());
replacedertEquals("Invalid argument value", argValue, actualValue);
replacedertFalse("The requestHandled flag shouldn't change", mavContainer.isRequestHandled());
}
private static clreplaced SimpleBean {
@NotNull
private final String name;
public SimpleBean(String name) {
this.name = name;
}
@SuppressWarnings("unused")
public String getName() {
return name;
}
}
private final clreplaced ValidatingBinderFactory implements WebDataBinderFactory {
@Override
public WebDataBinder createBinder(NativeWebRequest webRequest, @Nullable Object target, String objectName) throws Exception {
LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
validator.afterPropertiesSet();
WebDataBinder dataBinder = new WebDataBinder(target, objectName);
dataBinder.setValidator(validator);
return dataBinder;
}
}
@SuppressWarnings("unused")
public void handle(@RequestPart SimpleBean requestPart, @RequestPart(value = "requestPart", required = false) SimpleBean namedRequestPart, @Valid @RequestPart("requestPart") SimpleBean validRequestPart, @RequestPart("requestPart") MultipartFile multipartFile, @RequestPart("requestPart") List<MultipartFile> multipartFileList, @RequestPart("requestPart") MultipartFile[] multipartFileArray, int i, MultipartFile multipartFileNotAnnot, Part part, @RequestPart("requestPart") List<Part> partList, @RequestPart("requestPart") Part[] partArray, @RequestParam MultipartFile requestParamAnnot, Optional<MultipartFile> optionalMultipartFile, @RequestPart("requestPart") Optional<List<MultipartFile>> optionalMultipartFileList, Optional<Part> optionalPart, @RequestPart("requestPart") Optional<List<Part>> optionalPartList, @RequestPart("requestPart") Optional<SimpleBean> optionalRequestPart) {
}
}
19
Source : WebConfig.java
with GNU Lesser General Public License v3.0
from stylefeng
with GNU Lesser General Public License v3.0
from stylefeng
/**
* 配置string解析器放在json解析器前边
*
* @author fengshuonan
* @Date 2019/8/7 23:09
*/
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
HttpMessageConverter<?> httpMessageConverter = converters.get(0);
converters.remove(0);
converters.add(2, httpMessageConverter);
}
19
Source : GraphQLWebSocketHandlerTests.java
with Apache License 2.0
from spring-projects-experimental
with Apache License 2.0
from spring-projects-experimental
/**
* Unit tests for {@link GraphQLWebSocketHandler}.
*/
public clreplaced GraphQLWebSocketHandlerTests {
private static final String SUBSCRIPTION_ID = "123";
private static final String BOOK_SEARCH_QUERY = "{" + "\"id\":\"" + SUBSCRIPTION_ID + "\"," + "\"type\":\"subscribe\"," + "\"payload\":{\"query\": \"" + " subscription TestSubscription {" + " bookSearch(minPages: 200) {" + " id" + " name" + " pageCount" + " author" + " }}\"}" + "}";
private static final HttpMessageConverter<?> converter = new MappingJackson2HttpMessageConverter();
private final TestWebSocketSession session = new TestWebSocketSession();
private final GraphQLWebSocketHandler handler = initWebSocketHandler(Collections.emptyList(), Duration.ofSeconds(60));
@Test
void query() throws Exception {
String bookQuery = "{" + "\"id\":\"" + SUBSCRIPTION_ID + "\"," + "\"type\":\"subscribe\"," + "\"payload\":{\"query\": \"" + " query TestQuery {" + " bookById(id: \\\"book-1\\\"){ " + " id" + " name" + " pageCount" + " author" + " }}\"}" + "}";
this.handler.afterConnectionEstablished(session);
this.handler.handleTextMessage(session, new TextMessage("{\"type\":\"connection_init\"}"));
this.handler.handleTextMessage(session, new TextMessage(bookQuery));
StepVerifier.create(session.getOutput()).consumeNextWith(message -> replacedertMessageType(message, "connection_ack")).consumeNextWith(message -> replacedertThat(decode(message)).hreplacedize(3).containsEntry("id", SUBSCRIPTION_ID).containsEntry("type", "next").extractingByKey("payload", as(map(String.clreplaced, Object.clreplaced))).extractingByKey("data", as(map(String.clreplaced, Object.clreplaced))).extractingByKey("bookById", as(map(String.clreplaced, Object.clreplaced))).containsEntry("name", "GraphQL for beginners")).consumeNextWith(message -> replacedertMessageType(message, "complete")).then(// Complete output Flux
session::close).verifyComplete();
}
@Test
void subscription() throws Exception {
this.handler.afterConnectionEstablished(session);
this.handler.handleTextMessage(session, new TextMessage("{\"type\":\"connection_init\"}"));
this.handler.handleTextMessage(session, new TextMessage(BOOK_SEARCH_QUERY));
BiConsumer<WebSocketMessage<?>, String> bookPayloadreplacedertion = (message, bookId) -> replacedertThat(decode(message)).hreplacedize(3).containsEntry("id", SUBSCRIPTION_ID).containsEntry("type", "next").extractingByKey("payload", as(map(String.clreplaced, Object.clreplaced))).extractingByKey("data", as(map(String.clreplaced, Object.clreplaced))).extractingByKey("bookSearch", as(map(String.clreplaced, Object.clreplaced))).containsEntry("id", bookId);
StepVerifier.create(session.getOutput()).consumeNextWith(message -> replacedertMessageType(message, "connection_ack")).consumeNextWith(message -> bookPayloadreplacedertion.accept(message, "book-2")).consumeNextWith(message -> bookPayloadreplacedertion.accept(message, "book-3")).consumeNextWith(message -> bookPayloadreplacedertion.accept(message, "book-3")).consumeNextWith(message -> replacedertMessageType(message, "complete")).then(// Complete output Flux
session::close).verifyComplete();
}
@Test
void unauthorizedWithoutMessageType() throws Exception {
this.handler.afterConnectionEstablished(session);
this.handler.handleTextMessage(session, new TextMessage("{\"type\":\"connection_init\"}"));
// No message type
this.handler.handleTextMessage(session, new TextMessage("{\"id\":\"" + SUBSCRIPTION_ID + "\"}"));
StepVerifier.create(session.getOutput()).consumeNextWith(message -> replacedertMessageType(message, "connection_ack")).verifyComplete();
replacedertThat(session.getCloseStatus()).isEqualTo(new CloseStatus(4400, "Invalid message"));
}
@Test
void invalidMessageWithoutId() throws Exception {
this.handler.afterConnectionEstablished(session);
this.handler.handleTextMessage(session, new TextMessage("{\"type\":\"connection_init\"}"));
// No message id
this.handler.handleTextMessage(session, new TextMessage("{\"type\":\"subscribe\"}"));
StepVerifier.create(session.getOutput()).consumeNextWith(message -> replacedertMessageType(message, "connection_ack")).verifyComplete();
replacedertThat(session.getCloseStatus()).isEqualTo(new CloseStatus(4400, "Invalid message"));
}
@Test
void unauthorizedWithoutConnectionInit() throws Exception {
this.handler.afterConnectionEstablished(session);
this.handler.handleTextMessage(session, new TextMessage(BOOK_SEARCH_QUERY));
StepVerifier.create(session.getOutput()).verifyComplete();
replacedertThat(session.getCloseStatus()).isEqualTo(new CloseStatus(4401, "Unauthorized"));
}
@Test
void tooManyConnectionInitRequests() throws Exception {
this.handler.afterConnectionEstablished(session);
this.handler.handleTextMessage(session, new TextMessage("{\"type\":\"connection_init\"}"));
this.handler.handleTextMessage(session, new TextMessage("{\"type\":\"connection_init\"}"));
StepVerifier.create(session.getOutput()).consumeNextWith(message -> replacedertMessageType(message, "connection_ack")).verifyComplete();
replacedertThat(session.getCloseStatus()).isEqualTo(new CloseStatus(4429, "Too many initialisation requests"));
}
@Test
void connectionInitTimeout() {
GraphQLWebSocketHandler handler = initWebSocketHandler(Collections.emptyList(), Duration.ofMillis(50));
handler.afterConnectionEstablished(session);
StepVerifier.create(session.closeStatus()).expectNext(new CloseStatus(4408, "Connection initialisation timeout")).verifyComplete();
}
@Test
void subscriptionExists() throws Exception {
GraphQLWebSocketHandler handler = initWebSocketHandler(Collections.singletonList(new ConsumeOneAndNeverCompleteInterceptor()), null);
handler.afterConnectionEstablished(session);
handler.handleTextMessage(session, new TextMessage("{\"type\":\"connection_init\"}"));
handler.handleTextMessage(session, new TextMessage(BOOK_SEARCH_QUERY));
handler.handleTextMessage(session, new TextMessage(BOOK_SEARCH_QUERY));
// Collect messages until session closed
List<Map<String, Object>> messages = new ArrayList<>();
session.getOutput().subscribe(message -> messages.add(decode(message)));
StepVerifier.create(session.closeStatus()).expectNext(new CloseStatus(4409, "Subscriber for " + SUBSCRIPTION_ID + " already exists")).verifyComplete();
replacedertThat(messages.size()).isEqualTo(2);
replacedertThat(messages.get(0).get("type")).isEqualTo("connection_ack");
replacedertThat(messages.get(1).get("type")).isEqualTo("next");
}
@Test
void clientCompletion() throws Exception {
GraphQLWebSocketHandler handler = initWebSocketHandler(Collections.singletonList(new ConsumeOneAndNeverCompleteInterceptor()), null);
handler.afterConnectionEstablished(session);
handler.handleTextMessage(session, new TextMessage("{\"type\":\"connection_init\"}"));
handler.handleTextMessage(session, new TextMessage(BOOK_SEARCH_QUERY));
String completeMessage = "{\"id\":\"" + SUBSCRIPTION_ID + "\",\"type\":\"complete\"}";
Consumer<String> messageSender = body -> {
try {
handler.handleTextMessage(session, new TextMessage(body));
} catch (Exception ex) {
throw new IllegalStateException(ex);
}
};
StepVerifier.create(session.getOutput()).consumeNextWith(message -> replacedertMessageType(message, "connection_ack")).consumeNextWith(message -> replacedertMessageType(message, "next")).then(() -> messageSender.accept(completeMessage)).as("Second subscription with same id is possible only if the first was properly removed").then(() -> messageSender.accept(BOOK_SEARCH_QUERY)).consumeNextWith(message -> replacedertMessageType(message, "next")).then(() -> messageSender.accept(completeMessage)).verifyTimeout(Duration.ofMillis(500));
}
private GraphQLWebSocketHandler initWebSocketHandler(@Nullable List<WebInterceptor> interceptors, @Nullable Duration initTimeoutDuration) {
try {
return new GraphQLWebSocketHandler(initGraphQL(), (interceptors != null ? interceptors : Collections.emptyList()), converter, (initTimeoutDuration != null ? initTimeoutDuration : Duration.ofSeconds(60)));
} catch (Exception ex) {
throw new IllegalStateException(ex);
}
}
private static GraphQL initGraphQL() throws Exception {
File schemaFile = ResourceUtils.getFile("clreplacedpath:books/schema.graphqls");
TypeDefinitionRegistry typeDefinitionRegistry = new SchemaParser().parse(schemaFile);
RuntimeWiring.Builder builder = RuntimeWiring.newRuntimeWiring();
builder.type(newTypeWiring("Query").dataFetcher("bookById", GraphQLDataFetchers.getBookByIdDataFetcher()));
builder.type(newTypeWiring("Subscription").dataFetcher("bookSearch", GraphQLDataFetchers.getBooksOnSale()));
RuntimeWiring runtimeWiring = builder.build();
GraphQLSchema schema = new SchemaGenerator().makeExecutableSchema(typeDefinitionRegistry, runtimeWiring);
return GraphQL.newGraphQL(schema).build();
}
private void replacedertMessageType(WebSocketMessage<?> message, String messageType) {
Map<String, Object> map = decode(message, Map.clreplaced);
replacedertThat(map).containsEntry("type", messageType);
if (!messageType.equals("connection_ack")) {
replacedertThat(map).containsEntry("id", SUBSCRIPTION_ID);
}
}
@SuppressWarnings("unchecked")
private Map<String, Object> decode(WebSocketMessage<?> message) {
return decode(message, Map.clreplaced);
}
@SuppressWarnings("unchecked")
private <T> T decode(WebSocketMessage<?> message, Clreplaced<T> targetClreplaced) {
try {
HttpInputMessageAdapter inputMessage = new HttpInputMessageAdapter((TextMessage) message);
return ((HttpMessageConverter<T>) converter).read(targetClreplaced, inputMessage);
} catch (IOException ex) {
throw new IllegalStateException(ex);
}
}
private static clreplaced HttpInputMessageAdapter extends ByteArrayInputStream implements HttpInputMessage {
HttpInputMessageAdapter(TextMessage message) {
super(message.asBytes());
}
@Override
public InputStream getBody() {
return this;
}
@Override
public HttpHeaders getHeaders() {
return HttpHeaders.EMPTY;
}
}
}
19
Source : SpringEncoder.java
with Apache License 2.0
from spring-cloud
with Apache License 2.0
from spring-cloud
private boolean shouldHaveNullCharset(HttpMessageConverter messageConverter, FeignOutputMessage outputMessage) {
return binaryContentType(outputMessage) || messageConverter instanceof ByteArrayHttpMessageConverter || messageConverter instanceof ProtobufHttpMessageConverter && ProtobufHttpMessageConverter.PROTOBUF.isCompatibleWith(outputMessage.getHeaders().getContentType());
}
19
Source : RequestPartMethodArgumentResolverTests.java
with Apache License 2.0
from SourceHot
with Apache License 2.0
from SourceHot
/**
* Test fixture with {@link RequestPartMethodArgumentResolver} and mock {@link HttpMessageConverter}.
*
* @author Rossen Stoyanchev
* @author Brian Clozel
*/
public clreplaced RequestPartMethodArgumentResolverTests {
private HttpMessageConverter<SimpleBean> messageConverter;
private RequestPartMethodArgumentResolver resolver;
private MultipartFile multipartFile1;
private MultipartFile multipartFile2;
private MockMultipartHttpServletRequest multipartRequest;
private NativeWebRequest webRequest;
private MethodParameter paramRequestPart;
private MethodParameter paramNamedRequestPart;
private MethodParameter paramValidRequestPart;
private MethodParameter paramMultipartFile;
private MethodParameter paramMultipartFileList;
private MethodParameter paramMultipartFileArray;
private MethodParameter paramInt;
private MethodParameter paramMultipartFileNotAnnot;
private MethodParameter paramPart;
private MethodParameter paramPartList;
private MethodParameter paramPartArray;
private MethodParameter paramRequestParamAnnot;
private MethodParameter optionalMultipartFile;
private MethodParameter optionalMultipartFileList;
private MethodParameter optionalPart;
private MethodParameter optionalPartList;
private MethodParameter optionalRequestPart;
@BeforeEach
@SuppressWarnings("unchecked")
public void setup() throws Exception {
messageConverter = mock(HttpMessageConverter.clreplaced);
given(messageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
resolver = new RequestPartMethodArgumentResolver(Collections.singletonList(messageConverter));
reset(messageConverter);
byte[] content = "doesn't matter as long as not empty".getBytes(StandardCharsets.UTF_8);
multipartFile1 = new MockMultipartFile("requestPart", "", "text/plain", content);
multipartFile2 = new MockMultipartFile("requestPart", "", "text/plain", content);
multipartRequest = new MockMultipartHttpServletRequest();
multipartRequest.addFile(multipartFile1);
multipartRequest.addFile(multipartFile2);
multipartRequest.addFile(new MockMultipartFile("otherPart", "", "text/plain", content));
webRequest = new ServletWebRequest(multipartRequest, new MockHttpServletResponse());
Method method = ReflectionUtils.findMethod(getClreplaced(), "handle", (Clreplaced<?>[]) null);
paramRequestPart = new SynthesizingMethodParameter(method, 0);
paramRequestPart.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
paramNamedRequestPart = new SynthesizingMethodParameter(method, 1);
paramValidRequestPart = new SynthesizingMethodParameter(method, 2);
paramMultipartFile = new SynthesizingMethodParameter(method, 3);
paramMultipartFileList = new SynthesizingMethodParameter(method, 4);
paramMultipartFileArray = new SynthesizingMethodParameter(method, 5);
paramInt = new SynthesizingMethodParameter(method, 6);
paramMultipartFileNotAnnot = new SynthesizingMethodParameter(method, 7);
paramMultipartFileNotAnnot.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
paramPart = new SynthesizingMethodParameter(method, 8);
paramPart.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
paramPartList = new SynthesizingMethodParameter(method, 9);
paramPartArray = new SynthesizingMethodParameter(method, 10);
paramRequestParamAnnot = new SynthesizingMethodParameter(method, 11);
optionalMultipartFile = new SynthesizingMethodParameter(method, 12);
optionalMultipartFile.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
optionalMultipartFileList = new SynthesizingMethodParameter(method, 13);
optionalMultipartFileList.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
optionalPart = new SynthesizingMethodParameter(method, 14);
optionalPart.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
optionalPartList = new SynthesizingMethodParameter(method, 15);
optionalPartList.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
optionalRequestPart = new SynthesizingMethodParameter(method, 16);
}
@Test
public void supportsParameter() {
replacedertThat(resolver.supportsParameter(paramRequestPart)).isTrue();
replacedertThat(resolver.supportsParameter(paramNamedRequestPart)).isTrue();
replacedertThat(resolver.supportsParameter(paramValidRequestPart)).isTrue();
replacedertThat(resolver.supportsParameter(paramMultipartFile)).isTrue();
replacedertThat(resolver.supportsParameter(paramMultipartFileList)).isTrue();
replacedertThat(resolver.supportsParameter(paramMultipartFileArray)).isTrue();
replacedertThat(resolver.supportsParameter(paramInt)).isFalse();
replacedertThat(resolver.supportsParameter(paramMultipartFileNotAnnot)).isTrue();
replacedertThat(resolver.supportsParameter(paramPart)).isTrue();
replacedertThat(resolver.supportsParameter(paramPartList)).isTrue();
replacedertThat(resolver.supportsParameter(paramPartArray)).isTrue();
replacedertThat(resolver.supportsParameter(paramRequestParamAnnot)).isFalse();
replacedertThat(resolver.supportsParameter(optionalMultipartFile)).isTrue();
replacedertThat(resolver.supportsParameter(optionalMultipartFileList)).isTrue();
replacedertThat(resolver.supportsParameter(optionalPart)).isTrue();
replacedertThat(resolver.supportsParameter(optionalPartList)).isTrue();
replacedertThat(resolver.supportsParameter(optionalRequestPart)).isTrue();
}
@Test
public void resolveMultipartFile() throws Exception {
Object actual = resolver.resolveArgument(paramMultipartFile, null, webRequest, null);
replacedertThat(actual).isSameAs(multipartFile1);
}
@Test
public void resolveMultipartFileList() throws Exception {
Object actual = resolver.resolveArgument(paramMultipartFileList, null, webRequest, null);
boolean condition = actual instanceof List;
replacedertThat(condition).isTrue();
replacedertThat(actual).isEqualTo(Arrays.asList(multipartFile1, multipartFile2));
}
@Test
public void resolveMultipartFileArray() throws Exception {
Object actual = resolver.resolveArgument(paramMultipartFileArray, null, webRequest, null);
replacedertThat(actual).isNotNull();
boolean condition = actual instanceof MultipartFile[];
replacedertThat(condition).isTrue();
MultipartFile[] parts = (MultipartFile[]) actual;
replacedertThat(parts.length).isEqualTo(2);
replacedertThat(multipartFile1).isEqualTo(parts[0]);
replacedertThat(multipartFile2).isEqualTo(parts[1]);
}
@Test
public void resolveMultipartFileNotAnnotArgument() throws Exception {
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
MultipartFile expected = new MockMultipartFile("multipartFileNotAnnot", "Hello World".getBytes());
request.addFile(expected);
request.addFile(new MockMultipartFile("otherPart", "", "text/plain", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(paramMultipartFileNotAnnot, null, webRequest, null);
boolean condition = result instanceof MultipartFile;
replacedertThat(condition).isTrue();
replacedertThat(result).as("Invalid result").isEqualTo(expected);
}
@Test
public void resolvePartArgument() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
MockPart expected = new MockPart("part", "Hello World".getBytes());
request.addPart(expected);
request.addPart(new MockPart("otherPart", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(paramPart, null, webRequest, null);
boolean condition = result instanceof Part;
replacedertThat(condition).isTrue();
replacedertThat(result).as("Invalid result").isEqualTo(expected);
}
@Test
public void resolvePartListArgument() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
MockPart part1 = new MockPart("requestPart", "Hello World 1".getBytes());
MockPart part2 = new MockPart("requestPart", "Hello World 2".getBytes());
request.addPart(part1);
request.addPart(part2);
request.addPart(new MockPart("otherPart", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(paramPartList, null, webRequest, null);
boolean condition = result instanceof List;
replacedertThat(condition).isTrue();
replacedertThat(result).isEqualTo(Arrays.asList(part1, part2));
}
@Test
public void resolvePartArrayArgument() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
MockPart part1 = new MockPart("requestPart", "Hello World 1".getBytes());
MockPart part2 = new MockPart("requestPart", "Hello World 2".getBytes());
request.addPart(part1);
request.addPart(part2);
request.addPart(new MockPart("otherPart", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(paramPartArray, null, webRequest, null);
boolean condition = result instanceof Part[];
replacedertThat(condition).isTrue();
Part[] parts = (Part[]) result;
replacedertThat(parts.length).isEqualTo(2);
replacedertThat(part1).isEqualTo(parts[0]);
replacedertThat(part2).isEqualTo(parts[1]);
}
@Test
public void resolveRequestPart() throws Exception {
testResolveArgument(new SimpleBean("foo"), paramRequestPart);
}
@Test
public void resolveNamedRequestPart() throws Exception {
testResolveArgument(new SimpleBean("foo"), paramNamedRequestPart);
}
@Test
public void resolveNamedRequestPartNotPresent() throws Exception {
testResolveArgument(null, paramNamedRequestPart);
}
@Test
public void resolveRequestPartNotValid() throws Exception {
replacedertThatExceptionOfType(MethodArgumentNotValidException.clreplaced).isThrownBy(() -> testResolveArgument(new SimpleBean(null), paramValidRequestPart)).satisfies(ex -> {
BindingResult bindingResult = ex.getBindingResult();
replacedertThat(bindingResult.getObjectName()).isEqualTo("requestPart");
replacedertThat(bindingResult.getErrorCount()).isEqualTo(1);
replacedertThat(bindingResult.getFieldError("name")).isNotNull();
});
}
@Test
public void resolveRequestPartValid() throws Exception {
testResolveArgument(new SimpleBean("foo"), paramValidRequestPart);
}
@Test
public void resolveRequestPartRequired() throws Exception {
replacedertThatExceptionOfType(MissingServletRequestPartException.clreplaced).isThrownBy(() -> testResolveArgument(null, paramValidRequestPart)).satisfies(ex -> replacedertThat(ex.getRequestPartName()).isEqualTo("requestPart"));
}
@Test
public void resolveRequestPartNotRequired() throws Exception {
testResolveArgument(new SimpleBean("foo"), paramValidRequestPart);
}
@Test
public void isMultipartRequest() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
replacedertThatExceptionOfType(MultipartException.clreplaced).isThrownBy(() -> resolver.resolveArgument(paramMultipartFile, new ModelAndViewContainer(), new ServletWebRequest(request), null));
}
// SPR-9079
@Test
public void isMultipartRequestPut() throws Exception {
this.multipartRequest.setMethod("PUT");
Object actualValue = resolver.resolveArgument(paramMultipartFile, null, webRequest, null);
replacedertThat(actualValue).isSameAs(multipartFile1);
}
@Test
public void resolveOptionalMultipartFileArgument() throws Exception {
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
MultipartFile expected = new MockMultipartFile("optionalMultipartFile", "Hello World".getBytes());
request.addFile(expected);
request.addFile(new MockMultipartFile("otherPart", "", "text/plain", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalMultipartFile, null, webRequest, null);
boolean condition1 = actualValue instanceof Optional;
replacedertThat(condition1).isTrue();
replacedertThat(((Optional<?>) actualValue).get()).as("Invalid result").isEqualTo(expected);
actualValue = resolver.resolveArgument(optionalMultipartFile, null, webRequest, null);
boolean condition = actualValue instanceof Optional;
replacedertThat(condition).isTrue();
replacedertThat(((Optional<?>) actualValue).get()).as("Invalid result").isEqualTo(expected);
}
@Test
public void resolveOptionalMultipartFileArgumentNotPresent() throws Exception {
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalMultipartFile, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
actualValue = resolver.resolveArgument(optionalMultipartFile, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
}
@Test
public void resolveOptionalMultipartFileArgumentWithoutMultipartRequest() throws Exception {
webRequest = new ServletWebRequest(new MockHttpServletRequest());
Object actualValue = resolver.resolveArgument(optionalMultipartFile, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
actualValue = resolver.resolveArgument(optionalMultipartFile, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
}
@Test
public void resolveOptionalMultipartFileList() throws Exception {
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
MultipartFile expected = new MockMultipartFile("requestPart", "Hello World".getBytes());
request.addFile(expected);
request.addFile(new MockMultipartFile("otherPart", "", "text/plain", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalMultipartFileList, null, webRequest, null);
boolean condition1 = actualValue instanceof Optional;
replacedertThat(condition1).isTrue();
replacedertThat(((Optional<?>) actualValue).get()).as("Invalid result").isEqualTo(Collections.singletonList(expected));
actualValue = resolver.resolveArgument(optionalMultipartFileList, null, webRequest, null);
boolean condition = actualValue instanceof Optional;
replacedertThat(condition).isTrue();
replacedertThat(((Optional<?>) actualValue).get()).as("Invalid result").isEqualTo(Collections.singletonList(expected));
}
@Test
public void resolveOptionalMultipartFileListNotPresent() throws Exception {
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalMultipartFileList, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
actualValue = resolver.resolveArgument(optionalMultipartFileList, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
}
@Test
public void resolveOptionalMultipartFileListWithoutMultipartRequest() throws Exception {
webRequest = new ServletWebRequest(new MockHttpServletRequest());
Object actualValue = resolver.resolveArgument(optionalMultipartFileList, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
actualValue = resolver.resolveArgument(optionalMultipartFileList, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
}
@Test
public void resolveOptionalPartArgument() throws Exception {
MockPart expected = new MockPart("optionalPart", "Hello World".getBytes());
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
request.addPart(expected);
request.addPart(new MockPart("otherPart", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalPart, null, webRequest, null);
boolean condition1 = actualValue instanceof Optional;
replacedertThat(condition1).isTrue();
replacedertThat(((Optional<?>) actualValue).get()).as("Invalid result").isEqualTo(expected);
actualValue = resolver.resolveArgument(optionalPart, null, webRequest, null);
boolean condition = actualValue instanceof Optional;
replacedertThat(condition).isTrue();
replacedertThat(((Optional<?>) actualValue).get()).as("Invalid result").isEqualTo(expected);
}
@Test
public void resolveOptionalPartArgumentNotPresent() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalPart, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
actualValue = resolver.resolveArgument(optionalPart, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
}
@Test
public void resolveOptionalPartArgumentWithoutMultipartRequest() throws Exception {
webRequest = new ServletWebRequest(new MockHttpServletRequest());
Object actualValue = resolver.resolveArgument(optionalPart, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
actualValue = resolver.resolveArgument(optionalPart, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
}
@Test
public void resolveOptionalPartList() throws Exception {
MockPart expected = new MockPart("requestPart", "Hello World".getBytes());
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
request.addPart(expected);
request.addPart(new MockPart("otherPart", "Hello World".getBytes()));
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalPartList, null, webRequest, null);
boolean condition1 = actualValue instanceof Optional;
replacedertThat(condition1).isTrue();
replacedertThat(((Optional<?>) actualValue).get()).as("Invalid result").isEqualTo(Collections.singletonList(expected));
actualValue = resolver.resolveArgument(optionalPartList, null, webRequest, null);
boolean condition = actualValue instanceof Optional;
replacedertThat(condition).isTrue();
replacedertThat(((Optional<?>) actualValue).get()).as("Invalid result").isEqualTo(Collections.singletonList(expected));
}
@Test
public void resolveOptionalPartListNotPresent() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalPartList, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
actualValue = resolver.resolveArgument(optionalPartList, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
}
@Test
public void resolveOptionalPartListWithoutMultipartRequest() throws Exception {
webRequest = new ServletWebRequest(new MockHttpServletRequest());
Object actualValue = resolver.resolveArgument(optionalPartList, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
actualValue = resolver.resolveArgument(optionalPartList, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
}
@Test
public void resolveOptionalRequestPart() throws Exception {
SimpleBean simpleBean = new SimpleBean("foo");
given(messageConverter.canRead(SimpleBean.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(messageConverter.read(eq(SimpleBean.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(simpleBean);
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
Object actualValue = resolver.resolveArgument(optionalRequestPart, mavContainer, webRequest, new ValidatingBinderFactory());
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.of(simpleBean));
replacedertThat(mavContainer.isRequestHandled()).as("The requestHandled flag shouldn't change").isFalse();
actualValue = resolver.resolveArgument(optionalRequestPart, mavContainer, webRequest, new ValidatingBinderFactory());
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.of(simpleBean));
replacedertThat(mavContainer.isRequestHandled()).as("The requestHandled flag shouldn't change").isFalse();
}
@Test
public void resolveOptionalRequestPartNotPresent() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
webRequest = new ServletWebRequest(request);
Object actualValue = resolver.resolveArgument(optionalRequestPart, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
actualValue = resolver.resolveArgument(optionalRequestPart, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
}
@Test
public void resolveOptionalRequestPartWithoutMultipartRequest() throws Exception {
webRequest = new ServletWebRequest(new MockHttpServletRequest());
Object actualValue = resolver.resolveArgument(optionalRequestPart, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
actualValue = resolver.resolveArgument(optionalRequestPart, null, webRequest, null);
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(Optional.empty());
}
private void testResolveArgument(SimpleBean argValue, MethodParameter parameter) throws Exception {
given(messageConverter.canRead(SimpleBean.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(messageConverter.read(eq(SimpleBean.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(argValue);
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
Object actualValue = resolver.resolveArgument(parameter, mavContainer, webRequest, new ValidatingBinderFactory());
replacedertThat(actualValue).as("Invalid argument value").isEqualTo(argValue);
replacedertThat(mavContainer.isRequestHandled()).as("The requestHandled flag shouldn't change").isFalse();
}
private static clreplaced SimpleBean {
@NotNull
private final String name;
public SimpleBean(String name) {
this.name = name;
}
@SuppressWarnings("unused")
public String getName() {
return name;
}
}
private final clreplaced ValidatingBinderFactory implements WebDataBinderFactory {
@Override
public WebDataBinder createBinder(NativeWebRequest webRequest, @Nullable Object target, String objectName) throws Exception {
LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
validator.afterPropertiesSet();
WebDataBinder dataBinder = new WebDataBinder(target, objectName);
dataBinder.setValidator(validator);
return dataBinder;
}
}
@SuppressWarnings("unused")
public void handle(@RequestPart SimpleBean requestPart, @RequestPart(value = "requestPart", required = false) SimpleBean namedRequestPart, @Valid @RequestPart("requestPart") SimpleBean validRequestPart, @RequestPart("requestPart") MultipartFile multipartFile, @RequestPart("requestPart") List<MultipartFile> multipartFileList, @RequestPart("requestPart") MultipartFile[] multipartFileArray, int i, MultipartFile multipartFileNotAnnot, Part part, @RequestPart("requestPart") List<Part> partList, @RequestPart("requestPart") Part[] partArray, @RequestParam MultipartFile requestParamAnnot, Optional<MultipartFile> optionalMultipartFile, @RequestPart("requestPart") Optional<List<MultipartFile>> optionalMultipartFileList, Optional<Part> optionalPart, @RequestPart("requestPart") Optional<List<Part>> optionalPartList, @RequestPart("requestPart") Optional<SimpleBean> optionalRequestPart) {
}
}
19
Source : ResultEntityResponseServletConfiguration.java
with Apache License 2.0
from penggle
with Apache License 2.0
from penggle
@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
for (int i = 0, len = converters.size(); i < len; i++) {
HttpMessageConverter<?> converter = converters.get(i);
if (!(converter instanceof DelegateHttpMessageConverter)) {
converter = new DelegateHttpMessageConverter((HttpMessageConverter<Object>) converter);
// replace
converters.set(i, converter);
}
}
}
19
Source : MessageConverter.java
with MIT License
from osvaldjr
with MIT License
from osvaldjr
@Override
public HttpMessageConverters getObject() {
HttpMessageConverter jacksonConverter = new MappingJackson2HttpMessageConverter(objectMapper());
return new HttpMessageConverters(jacksonConverter);
}
19
Source : TitusProtobufHttpMessageConverter.java
with Apache License 2.0
from Netflix
with Apache License 2.0
from Netflix
@Controller
public clreplaced replacedusProtobufHttpMessageConverter implements HttpMessageConverter<Message> {
private static final ObjectMapper MAPPER = CommonObjectMappers.protobufMapper();
private final HttpMessageConverter<Message> delegate;
@Inject
public replacedusProtobufHttpMessageConverter() {
this.delegate = new ProtobufHttpMessageConverter();
}
@Override
public boolean canRead(Clreplaced<?> clazz, MediaType mediaType) {
return Message.clreplaced.isreplacedignableFrom(clazz);
}
@Override
public boolean canWrite(Clreplaced<?> clazz, MediaType mediaType) {
return Message.clreplaced.isreplacedignableFrom(clazz) && MediaType.APPLICATION_JSON.equals(mediaType);
}
@Override
public List<MediaType> getSupportedMediaTypes() {
return Collections.singletonList(MediaType.APPLICATION_JSON);
}
@Override
public Message read(Clreplaced<? extends Message> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
return delegate.read(clazz, inputMessage);
}
@Override
public void write(Message enreplacedy, MediaType contentType, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {
outputMessage.getHeaders().add(HttpHeaders.CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
MAPPER.writeValue(outputMessage.getBody(), enreplacedy);
}
}
19
Source : RequestResponseBodyMethodProcessorMockTests.java
with Apache License 2.0
from langtianya
with Apache License 2.0
from langtianya
/**
* Test fixture for {@link RequestResponseBodyMethodProcessor} delegating to a
* mock HttpMessageConverter.
*
* <p>Also see {@link RequestResponseBodyMethodProcessorTests}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
*/
public clreplaced RequestResponseBodyMethodProcessorMockTests {
private RequestResponseBodyMethodProcessor processor;
private HttpMessageConverter<String> messageConverter;
private MethodParameter paramRequestBodyString;
private MethodParameter paramInt;
private MethodParameter paramValidBean;
private MethodParameter paramStringNotRequired;
private MethodParameter returnTypeString;
private MethodParameter returnTypeInt;
private MethodParameter returnTypeStringProduces;
private ModelAndViewContainer mavContainer;
private NativeWebRequest webRequest;
private MockHttpServletRequest servletRequest;
@SuppressWarnings("unchecked")
@Before
public void setUp() throws Exception {
messageConverter = mock(HttpMessageConverter.clreplaced);
given(messageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
processor = new RequestResponseBodyMethodProcessor(Collections.<HttpMessageConverter<?>>singletonList(messageConverter));
Method methodHandle1 = getClreplaced().getMethod("handle1", String.clreplaced, Integer.TYPE);
paramRequestBodyString = new MethodParameter(methodHandle1, 0);
paramInt = new MethodParameter(methodHandle1, 1);
returnTypeString = new MethodParameter(methodHandle1, -1);
returnTypeInt = new MethodParameter(getClreplaced().getMethod("handle2"), -1);
returnTypeStringProduces = new MethodParameter(getClreplaced().getMethod("handle3"), -1);
paramValidBean = new MethodParameter(getClreplaced().getMethod("handle4", SimpleBean.clreplaced), 0);
paramStringNotRequired = new MethodParameter(getClreplaced().getMethod("handle5", String.clreplaced), 0);
mavContainer = new ModelAndViewContainer();
servletRequest = new MockHttpServletRequest();
servletRequest.setMethod("POST");
webRequest = new ServletWebRequest(servletRequest, new MockHttpServletResponse());
}
@Test
public void supportsParameter() {
replacedertTrue("RequestBody parameter not supported", processor.supportsParameter(paramRequestBodyString));
replacedertFalse("non-RequestBody parameter supported", processor.supportsParameter(paramInt));
}
@Test
public void supportsReturnType() {
replacedertTrue("ResponseBody return type not supported", processor.supportsReturnType(returnTypeString));
replacedertFalse("non-ResponseBody return type supported", processor.supportsReturnType(returnTypeInt));
}
@Test
public void resolveArgument() throws Exception {
MediaType contentType = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Content-Type", contentType.toString());
String body = "Foo";
servletRequest.setContent(body.getBytes(Charset.forName("UTF-8")));
given(messageConverter.canRead(String.clreplaced, contentType)).willReturn(true);
given(messageConverter.read(eq(String.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(body);
Object result = processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, new ValidatingBinderFactory());
replacedertEquals("Invalid argument", body, result);
replacedertFalse("The requestHandled flag shouldn't change", mavContainer.isRequestHandled());
}
@Test
public void resolveArgumentNotValid() throws Exception {
try {
testResolveArgumentWithValidation(new SimpleBean(null));
fail("Expected exception");
} catch (MethodArgumentNotValidException e) {
replacedertEquals("simpleBean", e.getBindingResult().getObjectName());
replacedertEquals(1, e.getBindingResult().getErrorCount());
replacedertNotNull(e.getBindingResult().getFieldError("name"));
}
}
@Test
public void resolveArgumentValid() throws Exception {
testResolveArgumentWithValidation(new SimpleBean("name"));
}
private void testResolveArgumentWithValidation(SimpleBean simpleBean) throws Exception {
MediaType contentType = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Content-Type", contentType.toString());
servletRequest.setContent("payload".getBytes(Charset.forName("UTF-8")));
@SuppressWarnings("unchecked")
HttpMessageConverter<SimpleBean> beanConverter = mock(HttpMessageConverter.clreplaced);
given(beanConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
given(beanConverter.canRead(SimpleBean.clreplaced, contentType)).willReturn(true);
given(beanConverter.read(eq(SimpleBean.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(simpleBean);
processor = new RequestResponseBodyMethodProcessor(Collections.<HttpMessageConverter<?>>singletonList(beanConverter));
processor.resolveArgument(paramValidBean, mavContainer, webRequest, new ValidatingBinderFactory());
}
@Test(expected = HttpMediaTypeNotSupportedException.clreplaced)
public void resolveArgumentCannotRead() throws Exception {
MediaType contentType = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Content-Type", contentType.toString());
servletRequest.setContent("payload".getBytes(Charset.forName("UTF-8")));
given(messageConverter.canRead(String.clreplaced, contentType)).willReturn(false);
processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null);
}
@Test(expected = HttpMediaTypeNotSupportedException.clreplaced)
public void resolveArgumentNoContentType() throws Exception {
servletRequest.setContent("payload".getBytes(Charset.forName("UTF-8")));
given(messageConverter.canRead(String.clreplaced, MediaType.APPLICATION_OCTET_STREAM)).willReturn(false);
processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null);
}
@Test(expected = HttpMediaTypeNotSupportedException.clreplaced)
public void resolveArgumentInvalidContentType() throws Exception {
this.servletRequest.setContentType("bad");
servletRequest.setContent("payload".getBytes(Charset.forName("UTF-8")));
processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null);
}
// SPR-9942
@Test(expected = HttpMessageNotReadableException.clreplaced)
public void resolveArgumentRequiredNoContent() throws Exception {
servletRequest.setContentType(MediaType.TEXT_PLAIN_VALUE);
servletRequest.setContent(new byte[0]);
given(messageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(messageConverter.read(eq(String.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(null);
replacedertNull(processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test
public void resolveArgumentNotRequiredNoContent() throws Exception {
servletRequest.setContentType("text/plain");
servletRequest.setContent(new byte[0]);
given(messageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
replacedertNull(processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory()));
}
// SPR-13417
@Test
public void resolveArgumentNotRequiredNoContentNoContentType() throws Exception {
servletRequest.setContent(new byte[0]);
given(messageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(messageConverter.canRead(String.clreplaced, MediaType.APPLICATION_OCTET_STREAM)).willReturn(false);
replacedertNull(processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test
public void resolveArgumentNotGetRequests() throws Exception {
servletRequest.setMethod("GET");
servletRequest.setContent(new byte[0]);
given(messageConverter.canRead(String.clreplaced, MediaType.APPLICATION_OCTET_STREAM)).willReturn(false);
replacedertNull(processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test
public void handleReturnValue() throws Exception {
MediaType accepted = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Accept", accepted.toString());
String body = "Foo";
given(messageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(messageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
given(messageConverter.canWrite(String.clreplaced, accepted)).willReturn(true);
processor.handleReturnValue(body, returnTypeString, mavContainer, webRequest);
replacedertTrue("The requestHandled flag wasn't set", mavContainer.isRequestHandled());
verify(messageConverter).write(eq(body), eq(accepted), isA(HttpOutputMessage.clreplaced));
}
@Test
public void handleReturnValueProduces() throws Exception {
String body = "Foo";
servletRequest.addHeader("Accept", "text/*");
servletRequest.setAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE, Collections.singleton(MediaType.TEXT_HTML));
given(messageConverter.canWrite(String.clreplaced, MediaType.TEXT_HTML)).willReturn(true);
processor.handleReturnValue(body, returnTypeStringProduces, mavContainer, webRequest);
replacedertTrue(mavContainer.isRequestHandled());
verify(messageConverter).write(eq(body), eq(MediaType.TEXT_HTML), isA(HttpOutputMessage.clreplaced));
}
@Test(expected = HttpMediaTypeNotAcceptableException.clreplaced)
public void handleReturnValueNotAcceptable() throws Exception {
MediaType accepted = MediaType.APPLICATION_ATOM_XML;
servletRequest.addHeader("Accept", accepted.toString());
given(messageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(messageConverter.getSupportedMediaTypes()).willReturn(Arrays.asList(MediaType.TEXT_PLAIN));
given(messageConverter.canWrite(String.clreplaced, accepted)).willReturn(false);
processor.handleReturnValue("Foo", returnTypeString, mavContainer, webRequest);
}
@Test(expected = HttpMediaTypeNotAcceptableException.clreplaced)
public void handleReturnValueNotAcceptableProduces() throws Exception {
MediaType accepted = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Accept", accepted.toString());
given(messageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(messageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
given(messageConverter.canWrite(String.clreplaced, accepted)).willReturn(false);
processor.handleReturnValue("Foo", returnTypeStringProduces, mavContainer, webRequest);
}
// SPR-9841
@Test
public void handleReturnValueMediaTypeSuffix() throws Exception {
String body = "Foo";
MediaType accepted = MediaType.APPLICATION_XHTML_XML;
List<MediaType> supported = Collections.singletonList(MediaType.valueOf("application/*+xml"));
servletRequest.addHeader("Accept", accepted);
given(messageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(messageConverter.getSupportedMediaTypes()).willReturn(supported);
given(messageConverter.canWrite(String.clreplaced, accepted)).willReturn(true);
processor.handleReturnValue(body, returnTypeStringProduces, mavContainer, webRequest);
replacedertTrue(mavContainer.isRequestHandled());
verify(messageConverter).write(eq(body), eq(accepted), isA(HttpOutputMessage.clreplaced));
}
@SuppressWarnings("unused")
@ResponseBody
public String handle1(@RequestBody String s, int i) {
return s;
}
@SuppressWarnings("unused")
public int handle2() {
return 42;
}
@SuppressWarnings("unused")
@ResponseBody
public String handle3() {
return null;
}
@SuppressWarnings("unused")
public void handle4(@Valid @RequestBody SimpleBean b) {
}
@SuppressWarnings("unused")
public void handle5(@RequestBody(required = false) String s) {
}
private final clreplaced ValidatingBinderFactory implements WebDataBinderFactory {
@Override
public WebDataBinder createBinder(NativeWebRequest webRequest, Object target, String objectName) throws Exception {
LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
validator.afterPropertiesSet();
WebDataBinder dataBinder = new WebDataBinder(target, objectName);
dataBinder.setValidator(validator);
return dataBinder;
}
}
@SuppressWarnings("unused")
private static clreplaced SimpleBean {
@NotNull
private final String name;
public SimpleBean(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
}
19
Source : RequestPartMethodArgumentResolverTests.java
with Apache License 2.0
from langtianya
with Apache License 2.0
from langtianya
/**
* Test fixture with {@link RequestPartMethodArgumentResolver} and mock {@link HttpMessageConverter}.
*
* @author Rossen Stoyanchev
* @author Brian Clozel
*/
public clreplaced RequestPartMethodArgumentResolverTests {
private RequestPartMethodArgumentResolver resolver;
private HttpMessageConverter<SimpleBean> messageConverter;
private MultipartFile multipartFile1;
private MultipartFile multipartFile2;
private MethodParameter paramRequestPart;
private MethodParameter paramNamedRequestPart;
private MethodParameter paramValidRequestPart;
private MethodParameter paramMultipartFile;
private MethodParameter paramMultipartFileList;
private MethodParameter paramMultipartFileArray;
private MethodParameter paramInt;
private MethodParameter paramMultipartFileNotAnnot;
private MethodParameter paramPart;
private MethodParameter paramPartList;
private MethodParameter paramPartArray;
private MethodParameter paramRequestParamAnnot;
private MethodParameter optionalMultipartFile;
private MethodParameter optionalPart;
private MethodParameter optionalRequestPart;
private NativeWebRequest webRequest;
private MockMultipartHttpServletRequest multipartRequest;
@SuppressWarnings("unchecked")
@Before
public void setUp() throws Exception {
Method method = getClreplaced().getMethod("handle", SimpleBean.clreplaced, SimpleBean.clreplaced, SimpleBean.clreplaced, MultipartFile.clreplaced, List.clreplaced, MultipartFile[].clreplaced, Integer.TYPE, MultipartFile.clreplaced, Part.clreplaced, List.clreplaced, Part[].clreplaced, MultipartFile.clreplaced, Optional.clreplaced, Optional.clreplaced, Optional.clreplaced);
paramRequestPart = new SynthesizingMethodParameter(method, 0);
paramRequestPart.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
paramNamedRequestPart = new SynthesizingMethodParameter(method, 1);
paramValidRequestPart = new SynthesizingMethodParameter(method, 2);
paramMultipartFile = new SynthesizingMethodParameter(method, 3);
paramMultipartFileList = new SynthesizingMethodParameter(method, 4);
paramMultipartFileArray = new SynthesizingMethodParameter(method, 5);
paramInt = new SynthesizingMethodParameter(method, 6);
paramMultipartFileNotAnnot = new SynthesizingMethodParameter(method, 7);
paramMultipartFileNotAnnot.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
paramPart = new SynthesizingMethodParameter(method, 8);
paramPart.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
paramPartList = new SynthesizingMethodParameter(method, 9);
paramPartArray = new SynthesizingMethodParameter(method, 10);
paramRequestParamAnnot = new SynthesizingMethodParameter(method, 11);
optionalMultipartFile = new SynthesizingMethodParameter(method, 12);
optionalMultipartFile.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
optionalPart = new SynthesizingMethodParameter(method, 13);
optionalPart.initParameterNameDiscovery(new LocalVariableTableParameterNameDiscoverer());
optionalRequestPart = new SynthesizingMethodParameter(method, 14);
messageConverter = mock(HttpMessageConverter.clreplaced);
given(messageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
resolver = new RequestPartMethodArgumentResolver(Collections.<HttpMessageConverter<?>>singletonList(messageConverter));
reset(messageConverter);
byte[] content = "doesn't matter as long as not empty".getBytes(Charset.forName("UTF-8"));
multipartFile1 = new MockMultipartFile("requestPart", "", "text/plain", content);
multipartFile2 = new MockMultipartFile("requestPart", "", "text/plain", content);
multipartRequest = new MockMultipartHttpServletRequest();
multipartRequest.addFile(multipartFile1);
multipartRequest.addFile(multipartFile2);
webRequest = new ServletWebRequest(multipartRequest, new MockHttpServletResponse());
}
@Test
public void supportsParameter() {
replacedertTrue("RequestPart parameter not supported", resolver.supportsParameter(paramRequestPart));
replacedertTrue("MultipartFile parameter not supported", resolver.supportsParameter(paramMultipartFileNotAnnot));
replacedertTrue("Part parameter not supported", resolver.supportsParameter(paramPart));
replacedertTrue("List<Part> parameter not supported", resolver.supportsParameter(paramPartList));
replacedertTrue("Part[] parameter not supported", resolver.supportsParameter(paramPartArray));
replacedertTrue("MultipartFile parameter not supported", resolver.supportsParameter(paramMultipartFile));
replacedertTrue("List<MultipartFile> parameter not supported", resolver.supportsParameter(paramMultipartFileList));
replacedertTrue("MultipartFile[] parameter not supported", resolver.supportsParameter(paramMultipartFileArray));
replacedertFalse("non-RequestPart parameter should not be supported", resolver.supportsParameter(paramInt));
replacedertFalse("@RequestParam args should not be supported", resolver.supportsParameter(paramRequestParamAnnot));
}
@Test
public void resolveMultipartFile() throws Exception {
Object actual = resolver.resolveArgument(paramMultipartFile, null, webRequest, null);
replacedertNotNull(actual);
replacedertSame(multipartFile1, actual);
}
@Test
public void resolveMultipartFileList() throws Exception {
Object actual = resolver.resolveArgument(paramMultipartFileList, null, webRequest, null);
replacedertNotNull(actual);
replacedertTrue(actual instanceof List);
replacedertEquals(Arrays.asList(multipartFile1, multipartFile2), actual);
}
@Test
public void resolveMultipartFileArray() throws Exception {
Object actual = resolver.resolveArgument(paramMultipartFileArray, null, webRequest, null);
replacedertNotNull(actual);
replacedertTrue(actual instanceof MultipartFile[]);
MultipartFile[] parts = (MultipartFile[]) actual;
replacedertEquals(parts[0], multipartFile1);
replacedertEquals(parts[1], multipartFile2);
}
@Test
public void resolveMultipartFileNotAnnotArgument() throws Exception {
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
MultipartFile expected = new MockMultipartFile("multipartFileNotAnnot", "Hello World".getBytes());
request.addFile(expected);
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(paramMultipartFileNotAnnot, null, webRequest, null);
replacedertTrue(result instanceof MultipartFile);
replacedertEquals("Invalid result", expected, result);
}
@Test
public void resolvePartArgument() throws Exception {
MockPart expected = new MockPart("part", "Hello World".getBytes());
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
request.addPart(expected);
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(paramPart, null, webRequest, null);
replacedertTrue(result instanceof Part);
replacedertEquals("Invalid result", expected, result);
}
@Test
public void resolvePartListArgument() throws Exception {
MockPart part1 = new MockPart("requestPart1", "Hello World 1".getBytes());
MockPart part2 = new MockPart("requestPart2", "Hello World 2".getBytes());
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
request.addPart(part1);
request.addPart(part2);
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(paramPartList, null, webRequest, null);
replacedertTrue(result instanceof List);
replacedertEquals(Arrays.asList(part1, part2), result);
}
@Test
public void resolvePartArrayArgument() throws Exception {
MockPart part1 = new MockPart("requestPart1", "Hello World 1".getBytes());
MockPart part2 = new MockPart("requestPart2", "Hello World 2".getBytes());
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
request.addPart(part1);
request.addPart(part2);
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(paramPartArray, null, webRequest, null);
replacedertTrue(result instanceof Part[]);
Part[] parts = (Part[]) result;
replacedertThat(parts, Matchers.arrayWithSize(2));
replacedertEquals(parts[0], part1);
replacedertEquals(parts[1], part2);
}
@Test
public void resolveRequestPart() throws Exception {
testResolveArgument(new SimpleBean("foo"), paramRequestPart);
}
@Test
public void resolveNamedRequestPart() throws Exception {
testResolveArgument(new SimpleBean("foo"), paramNamedRequestPart);
}
@Test
public void resolveNamedRequestPartNotPresent() throws Exception {
testResolveArgument(null, paramNamedRequestPart);
}
@Test
public void resolveRequestPartNotValid() throws Exception {
try {
testResolveArgument(new SimpleBean(null), paramValidRequestPart);
fail("Expected exception");
} catch (MethodArgumentNotValidException ex) {
replacedertEquals("requestPart", ex.getBindingResult().getObjectName());
replacedertEquals(1, ex.getBindingResult().getErrorCount());
replacedertNotNull(ex.getBindingResult().getFieldError("name"));
}
}
@Test
public void resolveRequestPartValid() throws Exception {
testResolveArgument(new SimpleBean("foo"), paramValidRequestPart);
}
@Test
public void resolveRequestPartRequired() throws Exception {
try {
testResolveArgument(null, paramValidRequestPart);
fail("Expected exception");
} catch (MissingServletRequestPartException ex) {
replacedertEquals("requestPart", ex.getRequestPartName());
}
}
@Test
public void resolveRequestPartNotRequired() throws Exception {
testResolveArgument(new SimpleBean("foo"), paramValidRequestPart);
}
@Test(expected = MultipartException.clreplaced)
public void isMultipartRequest() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
resolver.resolveArgument(paramMultipartFile, new ModelAndViewContainer(), new ServletWebRequest(request), null);
}
// SPR-9079
@Test
public void isMultipartRequestPut() throws Exception {
this.multipartRequest.setMethod("PUT");
Object actual = resolver.resolveArgument(paramMultipartFile, null, webRequest, null);
replacedertSame(multipartFile1, actual);
}
@Test
public void resolveOptionalMultipartFileArgument() throws Exception {
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
MultipartFile expected = new MockMultipartFile("optionalMultipartFile", "Hello World".getBytes());
request.addFile(expected);
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(optionalMultipartFile, null, webRequest, null);
replacedertTrue(result instanceof Optional);
replacedertEquals("Invalid result", expected, ((Optional) result).get());
}
@Test
public void resolveOptionalMultipartFileArgumentNotPresent() throws Exception {
MockMultipartHttpServletRequest request = new MockMultipartHttpServletRequest();
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(optionalMultipartFile, null, webRequest, null);
replacedertTrue(result instanceof Optional);
replacedertFalse("Invalid result", ((Optional) result).isPresent());
}
@Test
public void resolveOptionalPartArgument() throws Exception {
MockPart expected = new MockPart("optionalPart", "Hello World".getBytes());
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
request.addPart(expected);
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(optionalPart, null, webRequest, null);
replacedertTrue(result instanceof Optional);
replacedertEquals("Invalid result", expected, ((Optional) result).get());
}
@Test
public void resolveOptionalPartArgumentNotPresent() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest();
request.setMethod("POST");
request.setContentType("multipart/form-data");
webRequest = new ServletWebRequest(request);
Object result = resolver.resolveArgument(optionalPart, null, webRequest, null);
replacedertTrue(result instanceof Optional);
replacedertFalse("Invalid result", ((Optional) result).isPresent());
}
@Test
public void resolveOptionalRequestPart() throws Exception {
SimpleBean simpleBean = new SimpleBean("foo");
given(messageConverter.canRead(SimpleBean.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(messageConverter.read(eq(SimpleBean.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(simpleBean);
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
Object actualValue = resolver.resolveArgument(optionalRequestPart, mavContainer, webRequest, new ValidatingBinderFactory());
replacedertEquals("Invalid argument value", Optional.of(simpleBean), actualValue);
replacedertFalse("The requestHandled flag shouldn't change", mavContainer.isRequestHandled());
}
@Test
public void resolveOptionalRequestPartNotPresent() throws Exception {
given(messageConverter.canRead(SimpleBean.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(messageConverter.read(eq(SimpleBean.clreplaced), isA(RequestPartServletServerHttpRequest.clreplaced))).willReturn(null);
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
Object actualValue = resolver.resolveArgument(optionalRequestPart, mavContainer, webRequest, new ValidatingBinderFactory());
replacedertEquals("Invalid argument value", Optional.empty(), actualValue);
replacedertFalse("The requestHandled flag shouldn't change", mavContainer.isRequestHandled());
}
private void testResolveArgument(SimpleBean argValue, MethodParameter parameter) throws Exception {
given(messageConverter.canRead(SimpleBean.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(messageConverter.read(eq(SimpleBean.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(argValue);
ModelAndViewContainer mavContainer = new ModelAndViewContainer();
Object actualValue = resolver.resolveArgument(parameter, mavContainer, webRequest, new ValidatingBinderFactory());
replacedertEquals("Invalid argument value", argValue, actualValue);
replacedertFalse("The requestHandled flag shouldn't change", mavContainer.isRequestHandled());
}
private static clreplaced SimpleBean {
@NotNull
private final String name;
public SimpleBean(String name) {
this.name = name;
}
@SuppressWarnings("unused")
public String getName() {
return name;
}
}
private final clreplaced ValidatingBinderFactory implements WebDataBinderFactory {
@Override
public WebDataBinder createBinder(NativeWebRequest webRequest, Object target, String objectName) throws Exception {
LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
validator.afterPropertiesSet();
WebDataBinder dataBinder = new WebDataBinder(target, objectName);
dataBinder.setValidator(validator);
return dataBinder;
}
}
@SuppressWarnings("unused")
public void handle(@RequestPart SimpleBean requestPart, @RequestPart(value = "requestPart", required = false) SimpleBean namedRequestPart, @Valid @RequestPart("requestPart") SimpleBean validRequestPart, @RequestPart("requestPart") MultipartFile multipartFile, @RequestPart("requestPart") List<MultipartFile> multipartFileList, @RequestPart("requestPart") MultipartFile[] multipartFileArray, int i, MultipartFile multipartFileNotAnnot, Part part, @RequestPart("part") List<Part> partList, @RequestPart("part") Part[] partArray, @RequestParam MultipartFile requestParamAnnot, Optional<MultipartFile> optionalMultipartFile, Optional<Part> optionalPart, @RequestPart("requestPart") Optional<SimpleBean> optionalRequestPart) {
}
}
19
Source : OrderWebConfig.java
with MIT License
from fernandoBRS
with MIT License
from fernandoBRS
@Bean
public HttpMessageConverters customConverters() {
HttpMessageConverter<?> additional = new MappingJackson2HttpMessageConverter();
return new HttpMessageConverters(additional);
}
19
Source : WxApiMessageConverterExtractor.java
with Apache License 2.0
from FastBootWeixin
with Apache License 2.0
from FastBootWeixin
@Override
public T extractData(ResponseEnreplacedy<HttpInputMessage> responseEnreplacedy) throws IOException {
MediaType contentType = getContentType(responseEnreplacedy);
for (HttpMessageConverter<?> messageConverter : this.messageConverters) {
if (messageConverter instanceof GenericHttpMessageConverter) {
GenericHttpMessageConverter<?> genericMessageConverter = (GenericHttpMessageConverter<?>) messageConverter;
if (genericMessageConverter.canRead(this.responseType, null, contentType)) {
return (T) genericMessageConverter.read(this.responseType, null, responseEnreplacedy.getBody());
}
}
if (this.responseClreplaced != null) {
if (messageConverter.canRead(this.responseClreplaced, contentType)) {
return (T) messageConverter.read((Clreplaced) this.responseClreplaced, responseEnreplacedy.getBody());
}
}
}
throw new WxApiResponseException("不能转换相应数据为类型:" + this.responseType, responseEnreplacedy);
}
19
Source : JsonSerializationHack.java
with Apache License 2.0
from ctripcorp
with Apache License 2.0
from ctripcorp
@Inject
public void init() {
for (HttpMessageConverter<?> converter : adapter.getMessageConverters()) {
if (!(converter instanceof MappingJackson2HttpMessageConverter))
continue;
((MappingJackson2HttpMessageConverter) converter).setObjectMapper(objectMapper);
}
}
19
Source : BaseITCase.java
with Apache License 2.0
from arohou
with Apache License 2.0
from arohou
/**
* Base integration test case clreplaced.
* <p>
* Sets up the whole spring context for running and provides some utils.
*
* @author Cezary Krzyżanowski on 25.07.2017.
*/
@RunWith(SpringRunner.clreplaced)
@SpringBootTest(clreplacedes = GP2SApplication.clreplaced)
@WebAppConfiguration
@ActiveProfiles("integration-test")
public abstract clreplaced BaseITCase<T extends BaseAuditableEnreplacedy> extends BaseMockMvcTCase<T> {
private HttpMessageConverter<Object> mappingJackson2HttpMessageConverter;
@Autowired
private void setConverters(HttpMessageConverter<Object>[] converters) {
this.mappingJackson2HttpMessageConverter = Arrays.stream(converters).filter(hmc -> hmc instanceof MappingJackson2HttpMessageConverter).findAny().orElse(null);
replacedertNotNull("the JSON message converter must not be null", this.mappingJackson2HttpMessageConverter);
}
@Autowired
private WebApplicationContext webApplicationContext;
@Before
public final void initMockMvc() throws Exception {
setMockMvc(webAppContextSetup(webApplicationContext).alwaysDo(MockMvcResultHandlers.print()).build());
}
/**
* Converts a given #Object to JSON.
*
* @param o The object to convert.
* @return A JSON string
* @throws IOException When JSON parsing fails.
*/
@NonNull
protected String json(Object o) throws IOException {
final MockHttpOutputMessage mockHttpOutputMessage = new MockHttpOutputMessage();
this.mappingJackson2HttpMessageConverter.write(o, MediaType.APPLICATION_JSON, mockHttpOutputMessage);
return mockHttpOutputMessage.getBodyreplacedtring();
}
}
19
Source : HttpMessageConverterHolder.java
with Apache License 2.0
from alibaba
with Apache License 2.0
from alibaba
/**
* {@link HttpMessageConverter} Holder with {@link MediaType}.
*
* @author <a href="mailto:[email protected]">Mercy</a>
*/
public clreplaced HttpMessageConverterHolder {
private final MediaType mediaType;
private final HttpMessageConverter<?> converter;
public HttpMessageConverterHolder(MediaType mediaType, HttpMessageConverter<?> converter) {
this.mediaType = mediaType;
this.converter = converter;
}
public MediaType getMediaType() {
return mediaType;
}
public HttpMessageConverter<?> getConverter() {
return converter;
}
}
19
Source : ServicesRestWebMvcAutoConfiguration.java
with Apache License 2.0
from Activiti
with Apache License 2.0
from Activiti
@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
// for some, not yet identified, reason the ObjectMapper used by MappingJackson2HttpMessageConverter
// does not contains the object mapper customizations provided by custom Module beans.
// need to call configure here to ensure that the customisations are registered
for (HttpMessageConverter<?> converter : converters) {
// should exclude TypeConstrainedMappingJackson2HttpMessageConverter from configuration
if (converter instanceof MappingJackson2HttpMessageConverter && !(converter instanceof TypeConstrainedMappingJackson2HttpMessageConverter)) {
objectMapperBuilder.configure(((MappingJackson2HttpMessageConverter) converter).getObjectMapper());
}
}
}
19
Source : AlfrescoWebAutoConfiguration.java
with Apache License 2.0
from Activiti
with Apache License 2.0
from Activiti
@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
// the property spring.hateoas.use-hal-as-default-json-media-type is not working
// we need to manually remove application/json from supported mediaTypes
for (HttpMessageConverter<?> converter : converters) {
if (converter instanceof TypeConstrainedMappingJackson2HttpMessageConverter) {
ArrayList<MediaType> mediaTypes = new ArrayList<>(converter.getSupportedMediaTypes());
mediaTypes.remove(MediaType.APPLICATION_JSON);
((TypeConstrainedMappingJackson2HttpMessageConverter) converter).setSupportedMediaTypes(mediaTypes);
}
}
}
18
Source : HttpMessageConvertersTests.java
with Apache License 2.0
from yuanmabiji
with Apache License 2.0
from yuanmabiji
@Test
public void postProcessPartConverters() {
HttpMessageConverters converters = new HttpMessageConverters() {
@Override
protected List<HttpMessageConverter<?>> postProcessPartConverters(List<HttpMessageConverter<?>> converters) {
converters.removeIf(MappingJackson2XmlHttpMessageConverter.clreplaced::isInstance);
return converters;
}
};
List<Clreplaced<?>> converterClreplacedes = new ArrayList<>();
for (HttpMessageConverter<?> converter : extractFormPartConverters(converters.getConverters())) {
converterClreplacedes.add(converter.getClreplaced());
}
replacedertThat(converterClreplacedes).containsExactly(ByteArrayHttpMessageConverter.clreplaced, StringHttpMessageConverter.clreplaced, ResourceHttpMessageConverter.clreplaced, SourceHttpMessageConverter.clreplaced, MappingJackson2HttpMessageConverter.clreplaced, MappingJackson2SmileHttpMessageConverter.clreplaced);
}
18
Source : HttpMessageConvertersTests.java
with Apache License 2.0
from yuanmabiji
with Apache License 2.0
from yuanmabiji
@Test
public void containsDefaults() {
HttpMessageConverters converters = new HttpMessageConverters();
List<Clreplaced<?>> converterClreplacedes = new ArrayList<>();
for (HttpMessageConverter<?> converter : converters) {
converterClreplacedes.add(converter.getClreplaced());
}
replacedertThat(converterClreplacedes).containsExactly(ByteArrayHttpMessageConverter.clreplaced, StringHttpMessageConverter.clreplaced, ResourceHttpMessageConverter.clreplaced, ResourceRegionHttpMessageConverter.clreplaced, SourceHttpMessageConverter.clreplaced, AllEncompreplacedingFormHttpMessageConverter.clreplaced, MappingJackson2HttpMessageConverter.clreplaced, MappingJackson2SmileHttpMessageConverter.clreplaced, MappingJackson2CborHttpMessageConverter.clreplaced, MappingJackson2XmlHttpMessageConverter.clreplaced);
}
18
Source : HttpMessageConvertersTests.java
with Apache License 2.0
from yuanmabiji
with Apache License 2.0
from yuanmabiji
@Test
public void postProcessConverters() {
HttpMessageConverters converters = new HttpMessageConverters() {
@Override
protected List<HttpMessageConverter<?>> postProcessConverters(List<HttpMessageConverter<?>> converters) {
converters.removeIf(MappingJackson2XmlHttpMessageConverter.clreplaced::isInstance);
return converters;
}
};
List<Clreplaced<?>> converterClreplacedes = new ArrayList<>();
for (HttpMessageConverter<?> converter : converters) {
converterClreplacedes.add(converter.getClreplaced());
}
replacedertThat(converterClreplacedes).containsExactly(ByteArrayHttpMessageConverter.clreplaced, StringHttpMessageConverter.clreplaced, ResourceHttpMessageConverter.clreplaced, ResourceRegionHttpMessageConverter.clreplaced, SourceHttpMessageConverter.clreplaced, AllEncompreplacedingFormHttpMessageConverter.clreplaced, MappingJackson2HttpMessageConverter.clreplaced, MappingJackson2SmileHttpMessageConverter.clreplaced, MappingJackson2CborHttpMessageConverter.clreplaced);
}
18
Source : HttpMessageConvertersAutoConfigurationTests.java
with Apache License 2.0
from yuanmabiji
with Apache License 2.0
from yuanmabiji
private void replacedertConverterBeanRegisteredWithHttpMessageConverters(replacedertableApplicationContext context, Clreplaced<? extends HttpMessageConverter<?>> type) {
HttpMessageConverter<?> converter = context.getBean(type);
HttpMessageConverters converters = context.getBean(HttpMessageConverters.clreplaced);
replacedertThat(converters.getConverters()).contains(converter);
}
18
Source : ApiIT.java
with MIT License
from vsfexperts
with MIT License
from vsfexperts
@Before
public void setUp() {
final HttpMessageConverter<String> messageConverter = new StringHttpMessageConverter(Charset.forName("UTF-8"));
rest = new RestTemplate();
rest.getMessageConverters().add(0, messageConverter);
}
18
Source : RequestResponseBodyMethodProcessorMockTests.java
with MIT License
from Vip-Augus
with MIT License
from Vip-Augus
/**
* Test fixture for {@link RequestResponseBodyMethodProcessor} delegating to a
* mock HttpMessageConverter.
*
* <p>Also see {@link RequestResponseBodyMethodProcessorTests}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
* @author Juergen Hoeller
*/
public clreplaced RequestResponseBodyMethodProcessorMockTests {
private HttpMessageConverter<String> stringMessageConverter;
private HttpMessageConverter<Resource> resourceMessageConverter;
private HttpMessageConverter<Object> resourceRegionMessageConverter;
private RequestResponseBodyMethodProcessor processor;
private ModelAndViewContainer mavContainer;
private MockHttpServletRequest servletRequest;
private MockHttpServletResponse servletResponse;
private NativeWebRequest webRequest;
private MethodParameter paramRequestBodyString;
private MethodParameter paramInt;
private MethodParameter paramValidBean;
private MethodParameter paramStringNotRequired;
private MethodParameter paramOptionalString;
private MethodParameter returnTypeString;
private MethodParameter returnTypeInt;
private MethodParameter returnTypeStringProduces;
private MethodParameter returnTypeResource;
@Before
@SuppressWarnings("unchecked")
public void setup() throws Exception {
stringMessageConverter = mock(HttpMessageConverter.clreplaced);
given(stringMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
resourceMessageConverter = mock(HttpMessageConverter.clreplaced);
given(resourceMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.ALL));
resourceRegionMessageConverter = mock(HttpMessageConverter.clreplaced);
given(resourceRegionMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.ALL));
processor = new RequestResponseBodyMethodProcessor(Arrays.asList(stringMessageConverter, resourceMessageConverter, resourceRegionMessageConverter));
mavContainer = new ModelAndViewContainer();
servletRequest = new MockHttpServletRequest();
servletRequest.setMethod("POST");
servletResponse = new MockHttpServletResponse();
webRequest = new ServletWebRequest(servletRequest, servletResponse);
Method methodHandle1 = getClreplaced().getMethod("handle1", String.clreplaced, Integer.TYPE);
paramRequestBodyString = new MethodParameter(methodHandle1, 0);
paramInt = new MethodParameter(methodHandle1, 1);
paramValidBean = new MethodParameter(getClreplaced().getMethod("handle2", SimpleBean.clreplaced), 0);
paramStringNotRequired = new MethodParameter(getClreplaced().getMethod("handle3", String.clreplaced), 0);
paramOptionalString = new MethodParameter(getClreplaced().getMethod("handle4", Optional.clreplaced), 0);
returnTypeString = new MethodParameter(methodHandle1, -1);
returnTypeInt = new MethodParameter(getClreplaced().getMethod("handle5"), -1);
returnTypeStringProduces = new MethodParameter(getClreplaced().getMethod("handle6"), -1);
returnTypeResource = new MethodParameter(getClreplaced().getMethod("handle7"), -1);
}
@Test
public void supportsParameter() {
replacedertTrue("RequestBody parameter not supported", processor.supportsParameter(paramRequestBodyString));
replacedertFalse("non-RequestBody parameter supported", processor.supportsParameter(paramInt));
}
@Test
public void supportsReturnType() {
replacedertTrue("ResponseBody return type not supported", processor.supportsReturnType(returnTypeString));
replacedertFalse("non-ResponseBody return type supported", processor.supportsReturnType(returnTypeInt));
}
@Test
public void resolveArgument() throws Exception {
MediaType contentType = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Content-Type", contentType.toString());
String body = "Foo";
servletRequest.setContent(body.getBytes(StandardCharsets.UTF_8));
given(stringMessageConverter.canRead(String.clreplaced, contentType)).willReturn(true);
given(stringMessageConverter.read(eq(String.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(body);
Object result = processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, new ValidatingBinderFactory());
replacedertEquals("Invalid argument", body, result);
replacedertFalse("The requestHandled flag shouldn't change", mavContainer.isRequestHandled());
}
@Test
public void resolveArgumentNotValid() throws Exception {
try {
testResolveArgumentWithValidation(new SimpleBean(null));
fail("Expected exception");
} catch (MethodArgumentNotValidException e) {
replacedertEquals("simpleBean", e.getBindingResult().getObjectName());
replacedertEquals(1, e.getBindingResult().getErrorCount());
replacedertNotNull(e.getBindingResult().getFieldError("name"));
}
}
@Test
public void resolveArgumentValid() throws Exception {
testResolveArgumentWithValidation(new SimpleBean("name"));
}
private void testResolveArgumentWithValidation(SimpleBean simpleBean) throws Exception {
MediaType contentType = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Content-Type", contentType.toString());
servletRequest.setContent("payload".getBytes(StandardCharsets.UTF_8));
@SuppressWarnings("unchecked")
HttpMessageConverter<SimpleBean> beanConverter = mock(HttpMessageConverter.clreplaced);
given(beanConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
given(beanConverter.canRead(SimpleBean.clreplaced, contentType)).willReturn(true);
given(beanConverter.read(eq(SimpleBean.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(simpleBean);
processor = new RequestResponseBodyMethodProcessor(Collections.singletonList(beanConverter));
processor.resolveArgument(paramValidBean, mavContainer, webRequest, new ValidatingBinderFactory());
}
@Test(expected = HttpMediaTypeNotSupportedException.clreplaced)
public void resolveArgumentCannotRead() throws Exception {
MediaType contentType = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Content-Type", contentType.toString());
servletRequest.setContent("payload".getBytes(StandardCharsets.UTF_8));
given(stringMessageConverter.canRead(String.clreplaced, contentType)).willReturn(false);
processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null);
}
@Test(expected = HttpMediaTypeNotSupportedException.clreplaced)
public void resolveArgumentNoContentType() throws Exception {
servletRequest.setContent("payload".getBytes(StandardCharsets.UTF_8));
given(stringMessageConverter.canRead(String.clreplaced, MediaType.APPLICATION_OCTET_STREAM)).willReturn(false);
processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null);
}
@Test(expected = HttpMediaTypeNotSupportedException.clreplaced)
public void resolveArgumentInvalidContentType() throws Exception {
this.servletRequest.setContentType("bad");
servletRequest.setContent("payload".getBytes(StandardCharsets.UTF_8));
processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null);
}
// SPR-9942
@Test(expected = HttpMessageNotReadableException.clreplaced)
public void resolveArgumentRequiredNoContent() throws Exception {
servletRequest.setContentType(MediaType.TEXT_PLAIN_VALUE);
servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(stringMessageConverter.read(eq(String.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(null);
replacedertNull(processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test
public void resolveArgumentNotGetRequests() throws Exception {
servletRequest.setMethod("GET");
servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.APPLICATION_OCTET_STREAM)).willReturn(false);
replacedertNull(processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test
public void resolveArgumentNotRequiredWithContent() throws Exception {
servletRequest.setContentType("text/plain");
servletRequest.setContent("body".getBytes());
given(stringMessageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(stringMessageConverter.read(eq(String.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn("body");
replacedertEquals("body", processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test
public void resolveArgumentNotRequiredNoContent() throws Exception {
servletRequest.setContentType("text/plain");
servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
replacedertNull(processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory()));
}
// SPR-13417
@Test
public void resolveArgumentNotRequiredNoContentNoContentType() throws Exception {
servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.APPLICATION_OCTET_STREAM)).willReturn(false);
replacedertNull(processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test
public void resolveArgumentOptionalWithContent() throws Exception {
servletRequest.setContentType("text/plain");
servletRequest.setContent("body".getBytes());
given(stringMessageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(stringMessageConverter.read(eq(String.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn("body");
replacedertEquals(Optional.of("body"), processor.resolveArgument(paramOptionalString, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test
public void resolveArgumentOptionalNoContent() throws Exception {
servletRequest.setContentType("text/plain");
servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
replacedertEquals(Optional.empty(), processor.resolveArgument(paramOptionalString, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test
public void resolveArgumentOptionalNoContentNoContentType() throws Exception {
servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.APPLICATION_OCTET_STREAM)).willReturn(false);
replacedertEquals(Optional.empty(), processor.resolveArgument(paramOptionalString, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test
public void handleReturnValue() throws Exception {
MediaType accepted = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Accept", accepted.toString());
String body = "Foo";
given(stringMessageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(stringMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
given(stringMessageConverter.canWrite(String.clreplaced, accepted)).willReturn(true);
processor.handleReturnValue(body, returnTypeString, mavContainer, webRequest);
replacedertTrue("The requestHandled flag wasn't set", mavContainer.isRequestHandled());
verify(stringMessageConverter).write(eq(body), eq(accepted), isA(HttpOutputMessage.clreplaced));
}
@Test
public void handleReturnValueProduces() throws Exception {
String body = "Foo";
servletRequest.addHeader("Accept", "text/*");
servletRequest.setAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE, Collections.singleton(MediaType.TEXT_HTML));
given(stringMessageConverter.canWrite(String.clreplaced, MediaType.TEXT_HTML)).willReturn(true);
processor.handleReturnValue(body, returnTypeStringProduces, mavContainer, webRequest);
replacedertTrue(mavContainer.isRequestHandled());
verify(stringMessageConverter).write(eq(body), eq(MediaType.TEXT_HTML), isA(HttpOutputMessage.clreplaced));
}
@Test(expected = HttpMediaTypeNotAcceptableException.clreplaced)
public void handleReturnValueNotAcceptable() throws Exception {
MediaType accepted = MediaType.APPLICATION_ATOM_XML;
servletRequest.addHeader("Accept", accepted.toString());
given(stringMessageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(stringMessageConverter.getSupportedMediaTypes()).willReturn(Arrays.asList(MediaType.TEXT_PLAIN));
given(stringMessageConverter.canWrite(String.clreplaced, accepted)).willReturn(false);
processor.handleReturnValue("Foo", returnTypeString, mavContainer, webRequest);
}
@Test(expected = HttpMediaTypeNotAcceptableException.clreplaced)
public void handleReturnValueNotAcceptableProduces() throws Exception {
MediaType accepted = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Accept", accepted.toString());
given(stringMessageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(stringMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
given(stringMessageConverter.canWrite(String.clreplaced, accepted)).willReturn(false);
processor.handleReturnValue("Foo", returnTypeStringProduces, mavContainer, webRequest);
}
@Test
public void handleReturnTypeResource() throws Exception {
Resource returnValue = new ByteArrayResource("Content".getBytes(StandardCharsets.UTF_8));
given(resourceMessageConverter.canWrite(ByteArrayResource.clreplaced, null)).willReturn(true);
given(resourceMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.ALL));
given(resourceMessageConverter.canWrite(ByteArrayResource.clreplaced, MediaType.APPLICATION_OCTET_STREAM)).willReturn(true);
processor.handleReturnValue(returnValue, returnTypeResource, mavContainer, webRequest);
then(resourceMessageConverter).should(times(1)).write(any(ByteArrayResource.clreplaced), eq(MediaType.APPLICATION_OCTET_STREAM), any(HttpOutputMessage.clreplaced));
replacedertEquals(200, servletResponse.getStatus());
}
// SPR-9841
@Test
public void handleReturnValueMediaTypeSuffix() throws Exception {
String body = "Foo";
MediaType accepted = MediaType.APPLICATION_XHTML_XML;
List<MediaType> supported = Collections.singletonList(MediaType.valueOf("application/*+xml"));
servletRequest.addHeader("Accept", accepted);
given(stringMessageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(stringMessageConverter.getSupportedMediaTypes()).willReturn(supported);
given(stringMessageConverter.canWrite(String.clreplaced, accepted)).willReturn(true);
processor.handleReturnValue(body, returnTypeStringProduces, mavContainer, webRequest);
replacedertTrue(mavContainer.isRequestHandled());
verify(stringMessageConverter).write(eq(body), eq(accepted), isA(HttpOutputMessage.clreplaced));
}
@Test
public void handleReturnTypeResourceByteRange() throws Exception {
Resource returnValue = new ByteArrayResource("Content".getBytes(StandardCharsets.UTF_8));
servletRequest.addHeader("Range", "bytes=0-5");
given(resourceRegionMessageConverter.canWrite(any(), eq(null))).willReturn(true);
given(resourceRegionMessageConverter.canWrite(any(), eq(MediaType.APPLICATION_OCTET_STREAM))).willReturn(true);
processor.handleReturnValue(returnValue, returnTypeResource, mavContainer, webRequest);
then(resourceRegionMessageConverter).should(times(1)).write(anyCollection(), eq(MediaType.APPLICATION_OCTET_STREAM), argThat(outputMessage -> "bytes".equals(outputMessage.getHeaders().getFirst(HttpHeaders.ACCEPT_RANGES))));
replacedertEquals(206, servletResponse.getStatus());
}
@Test
public void handleReturnTypeResourceIllegalByteRange() throws Exception {
Resource returnValue = new ByteArrayResource("Content".getBytes(StandardCharsets.UTF_8));
servletRequest.addHeader("Range", "illegal");
given(resourceRegionMessageConverter.canWrite(any(), eq(null))).willReturn(true);
given(resourceRegionMessageConverter.canWrite(any(), eq(MediaType.APPLICATION_OCTET_STREAM))).willReturn(true);
processor.handleReturnValue(returnValue, returnTypeResource, mavContainer, webRequest);
then(resourceRegionMessageConverter).should(never()).write(anyCollection(), eq(MediaType.APPLICATION_OCTET_STREAM), any(HttpOutputMessage.clreplaced));
replacedertEquals(416, servletResponse.getStatus());
}
@SuppressWarnings("unused")
@ResponseBody
public String handle1(@RequestBody String s, int i) {
return s;
}
@SuppressWarnings("unused")
public void handle2(@Valid @RequestBody SimpleBean b) {
}
@SuppressWarnings("unused")
public void handle3(@RequestBody(required = false) String s) {
}
@SuppressWarnings("unused")
public void handle4(@RequestBody Optional<String> s) {
}
@SuppressWarnings("unused")
public int handle5() {
return 42;
}
@SuppressWarnings("unused")
@ResponseBody
public String handle6() {
return null;
}
@SuppressWarnings("unused")
@ResponseBody
public Resource handle7() {
return null;
}
private final clreplaced ValidatingBinderFactory implements WebDataBinderFactory {
@Override
public WebDataBinder createBinder(NativeWebRequest webRequest, @Nullable Object target, String objectName) throws Exception {
LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
validator.afterPropertiesSet();
WebDataBinder dataBinder = new WebDataBinder(target, objectName);
dataBinder.setValidator(validator);
return dataBinder;
}
}
@SuppressWarnings("unused")
private static clreplaced SimpleBean {
@NotNull
private final String name;
public SimpleBean(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
}
18
Source : GraphQLWebSocketHandler.java
with Apache License 2.0
from spring-projects-experimental
with Apache License 2.0
from spring-projects-experimental
/**
* WebSocketHandler for GraphQL based on
* <a href="https://github.com/enisdenjo/graphql-ws/blob/master/PROTOCOL.md">GraphQL Over WebSocket Protocol</a>
* and for use on a Servlet container with {@code spring-websocket}.
*/
public clreplaced GraphQLWebSocketHandler extends TextWebSocketHandler implements SubProtocolCapable {
private static final Log logger = LogFactory.getLog(GraphQLWebSocketHandler.clreplaced);
private static final List<String> SUB_PROTOCOL_LIST = Arrays.asList("graphql-transport-ws", "subscriptions-transport-ws");
private final WebInterceptorExecutionChain executionChain;
private final Duration initTimeoutDuration;
private final HttpMessageConverter<?> converter;
private final Map<String, SessionState> sessionInfoMap = new ConcurrentHashMap<>();
/**
* Create a new instance.
* @param graphQL the GraphQL instance to use for query execution
* @param interceptors 0 or more interceptors to customize input and output
* @param converter for JSON encoding and decoding
* @param initTimeoutDuration the time within which the {@code CONNECTION_INIT}
* type message must be received.
*/
public GraphQLWebSocketHandler(GraphQL graphQL, List<WebInterceptor> interceptors, HttpMessageConverter<?> converter, Duration initTimeoutDuration) {
replacedert.notNull(converter, "HttpMessageConverter for JSON is required");
this.executionChain = new WebInterceptorExecutionChain(graphQL, interceptors);
this.initTimeoutDuration = initTimeoutDuration;
this.converter = converter;
}
@Override
public List<String> getSubProtocols() {
return SUB_PROTOCOL_LIST;
}
@Override
public void afterConnectionEstablished(WebSocketSession session) {
if ("subscriptions-transport-ws".equalsIgnoreCase(session.getAcceptedProtocol())) {
if (logger.isDebugEnabled()) {
logger.debug("apollographql/subscriptions-transport-ws is not supported, nor maintained. " + "Please, use https://github.com/enisdenjo/graphql-ws.");
}
GraphQLStatus.closeSession(session, GraphQLStatus.INVALID_MESSAGE_STATUS);
return;
}
SessionState sessionState = new SessionState(session.getId());
this.sessionInfoMap.put(session.getId(), sessionState);
Mono.delay(this.initTimeoutDuration).then(Mono.fromRunnable(() -> {
if (!sessionState.isConnectionInitProcessed()) {
GraphQLStatus.closeSession(session, GraphQLStatus.INIT_TIMEOUT_STATUS);
}
})).subscribe();
}
@Override
@SuppressWarnings("unchecked")
protected void handleTextMessage(WebSocketSession session, TextMessage message) throws Exception {
Map<String, Object> map = decode(message, Map.clreplaced);
String id = (String) map.get("id");
MessageType messageType = MessageType.resolve((String) map.get("type"));
if (messageType == null) {
GraphQLStatus.closeSession(session, GraphQLStatus.INVALID_MESSAGE_STATUS);
return;
}
SessionState sessionState = getSessionInfo(session);
switch(messageType) {
case SUBSCRIBE:
if (!sessionState.isConnectionInitProcessed()) {
GraphQLStatus.closeSession(session, GraphQLStatus.UNAUTHORIZED_STATUS);
return;
}
if (id == null) {
GraphQLStatus.closeSession(session, GraphQLStatus.INVALID_MESSAGE_STATUS);
return;
}
URI uri = session.getUri();
HttpHeaders headers = session.getHandshakeHeaders();
WebSocketMessageInput input = new WebSocketMessageInput(uri, headers, id, getPayload(map));
if (logger.isDebugEnabled()) {
logger.debug("Executing: " + input);
}
this.executionChain.execute(input).flatMapMany(output -> handleWebOutput(session, input.requestId(), output)).publishOn(// Serial blocking send via single thread
sessionState.getScheduler()).subscribe(new SendMessageSubscriber(id, session, sessionState));
return;
case COMPLETE:
if (id != null) {
Subscription subscription = sessionState.getSubscriptions().remove(id);
if (subscription != null) {
subscription.cancel();
}
}
return;
case CONNECTION_INIT:
if (sessionState.setConnectionInitProcessed()) {
GraphQLStatus.closeSession(session, GraphQLStatus.TOO_MANY_INIT_REQUESTS_STATUS);
return;
}
TextMessage outputMessage = encode(session, null, MessageType.CONNECTION_ACK, null);
session.sendMessage(outputMessage);
return;
default:
GraphQLStatus.closeSession(session, GraphQLStatus.INVALID_MESSAGE_STATUS);
}
}
@SuppressWarnings("unchecked")
private <T> T decode(TextMessage message, Clreplaced<T> targetClreplaced) throws IOException {
return ((HttpMessageConverter<T>) this.converter).read(targetClreplaced, new HttpInputMessageAdapter(message));
}
@SuppressWarnings("unchecked")
private static Map<String, Object> getPayload(Map<String, Object> message) {
Map<String, Object> payload = (Map<String, Object>) message.get("payload");
replacedert.notNull(payload, "No \"payload\" in message: " + message);
return payload;
}
private SessionState getSessionInfo(WebSocketSession session) {
SessionState info = this.sessionInfoMap.get(session.getId());
replacedert.notNull(info, "No SessionInfo for " + session);
return info;
}
@SuppressWarnings("unchecked")
private Flux<TextMessage> handleWebOutput(WebSocketSession session, String id, WebOutput output) {
if (logger.isDebugEnabled()) {
logger.debug("Execution result ready" + (!CollectionUtils.isEmpty(output.getErrors()) ? " with errors: " + output.getErrors() : "") + ".");
}
Flux<ExecutionResult> outputFlux;
if (output.getData() instanceof Publisher) {
// Subscription
outputFlux = Flux.from((Publisher<ExecutionResult>) output.getData()).doOnSubscribe(subscription -> {
Subscription prev = getSessionInfo(session).getSubscriptions().putIfAbsent(id, subscription);
if (prev != null) {
throw new SubscriptionExistsException();
}
});
} else {
// Query
outputFlux = (CollectionUtils.isEmpty(output.getErrors()) ? Flux.just(output) : Flux.error(new IllegalStateException("Execution failed: " + output.getErrors())));
}
return outputFlux.map(result -> {
Map<String, Object> dataMap = result.toSpecification();
return encode(session, id, MessageType.NEXT, dataMap);
}).concatWith(Mono.fromCallable(() -> encode(session, id, MessageType.COMPLETE, null))).onErrorResume(ex -> {
if (ex instanceof SubscriptionExistsException) {
CloseStatus status = new CloseStatus(4409, "Subscriber for " + id + " already exists");
GraphQLStatus.closeSession(session, status);
return Flux.empty();
}
ErrorType errorType = ErrorType.DataFetchingException;
String message = ex.getMessage();
Map<String, Object> errorMap = GraphqlErrorBuilder.newError().errorType(errorType).message(message).build().toSpecification();
return Mono.just(encode(session, id, MessageType.ERROR, errorMap));
});
}
@SuppressWarnings("unchecked")
private <T> TextMessage encode(WebSocketSession session, @Nullable String id, MessageType messageType, @Nullable Object payload) {
Map<String, Object> payloadMap = new HashMap<>(3);
payloadMap.put("type", messageType.getType());
if (id != null) {
payloadMap.put("id", id);
}
if (payload != null) {
payloadMap.put("payload", payload);
}
try {
HttpOutputMessageAdapter outputMessage = new HttpOutputMessageAdapter();
((HttpMessageConverter<T>) this.converter).write((T) payloadMap, null, outputMessage);
return new TextMessage(outputMessage.toByteArray());
} catch (IOException ex) {
throw new IllegalStateException("Failed to write " + payloadMap + " as JSON", ex);
}
}
@Override
public void handleTransportError(WebSocketSession session, Throwable exception) {
SessionState info = this.sessionInfoMap.remove(session.getId());
if (info != null) {
info.dispose();
}
}
@Override
public void afterConnectionClosed(WebSocketSession session, CloseStatus closeStatus) {
SessionState info = this.sessionInfoMap.remove(session.getId());
if (info != null) {
info.dispose();
}
}
@Override
public boolean supportsPartialMessages() {
return false;
}
private enum MessageType {
CONNECTION_INIT("connection_init"),
CONNECTION_ACK("connection_ack"),
SUBSCRIBE("subscribe"),
NEXT("next"),
ERROR("error"),
COMPLETE("complete");
private static final Map<String, MessageType> messageTypes = new HashMap<>(6);
static {
for (MessageType messageType : MessageType.values()) {
messageTypes.put(messageType.getType(), messageType);
}
}
private final String type;
MessageType(String type) {
this.type = type;
}
public String getType() {
return this.type;
}
@Nullable
public static MessageType resolve(@Nullable String type) {
return (type != null ? messageTypes.get(type) : null);
}
}
private static clreplaced GraphQLStatus {
private static final CloseStatus INVALID_MESSAGE_STATUS = new CloseStatus(4400, "Invalid message");
private static final CloseStatus UNAUTHORIZED_STATUS = new CloseStatus(4401, "Unauthorized");
private static final CloseStatus INIT_TIMEOUT_STATUS = new CloseStatus(4408, "Connection initialisation timeout");
private static final CloseStatus TOO_MANY_INIT_REQUESTS_STATUS = new CloseStatus(4429, "Too many initialisation requests");
public static void closeSession(WebSocketSession session, CloseStatus status) {
try {
session.close(status);
} catch (IOException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Error while closing session with status: " + status, ex);
}
}
}
}
private static clreplaced HttpInputMessageAdapter extends ByteArrayInputStream implements HttpInputMessage {
HttpInputMessageAdapter(TextMessage message) {
super(message.asBytes());
}
@Override
public InputStream getBody() {
return this;
}
@Override
public HttpHeaders getHeaders() {
return HttpHeaders.EMPTY;
}
}
private static clreplaced HttpOutputMessageAdapter extends ByteArrayOutputStream implements HttpOutputMessage {
private static final HttpHeaders noOpHeaders = new HttpHeaders();
@Override
public OutputStream getBody() {
return this;
}
@Override
public HttpHeaders getHeaders() {
return noOpHeaders;
}
}
private static clreplaced SessionState {
private boolean connectionInitProcessed;
private final Map<String, Subscription> subscriptions = new ConcurrentHashMap<>();
private final Scheduler scheduler;
public SessionState(String sessionId) {
this.scheduler = Schedulers.newSingle("GraphQL-WsSession-" + sessionId);
}
public boolean isConnectionInitProcessed() {
return this.connectionInitProcessed;
}
public synchronized boolean setConnectionInitProcessed() {
boolean previousValue = this.connectionInitProcessed;
this.connectionInitProcessed = true;
return previousValue;
}
public Map<String, Subscription> getSubscriptions() {
return this.subscriptions;
}
public void dispose() {
for (Map.Entry<String, Subscription> entry : this.subscriptions.entrySet()) {
try {
entry.getValue().cancel();
} catch (Throwable ex) {
// Ignore and keep on
}
}
this.subscriptions.clear();
this.scheduler.dispose();
}
public Scheduler getScheduler() {
return this.scheduler;
}
}
private clreplaced SendMessageSubscriber extends BaseSubscriber<TextMessage> {
private final String subscriptionId;
private final WebSocketSession session;
private final SessionState sessionState;
public SendMessageSubscriber(String subscriptionId, WebSocketSession session, SessionState sessionState) {
this.subscriptionId = subscriptionId;
this.session = session;
this.sessionState = sessionState;
}
@Override
protected void hookOnSubscribe(Subscription subscription) {
subscription.request(1);
}
@Override
protected void hookOnNext(TextMessage nextMessage) {
try {
this.session.sendMessage(nextMessage);
request(1);
} catch (IOException ex) {
ExceptionWebSocketHandlerDecorator.tryCloseWithError(this.session, ex, logger);
}
}
@Override
public void hookOnError(Throwable ex) {
ExceptionWebSocketHandlerDecorator.tryCloseWithError(this.session, ex, logger);
}
@Override
public void hookOnComplete() {
this.sessionState.getSubscriptions().remove(this.subscriptionId);
}
}
private static clreplaced SubscriptionExistsException extends RuntimeException {
}
}
18
Source : OAuth2TokenRevocationEndpointFilterTests.java
with Apache License 2.0
from spring-projects-experimental
with Apache License 2.0
from spring-projects-experimental
/**
* Tests for {@link OAuth2TokenRevocationEndpointFilter}.
*
* @author Vivek Babu
* @author Joe Grandja
*/
public clreplaced OAuth2TokenRevocationEndpointFilterTests {
private AuthenticationManager authenticationManager;
private OAuth2TokenRevocationEndpointFilter filter;
private final HttpMessageConverter<OAuth2Error> errorHttpResponseConverter = new OAuth2ErrorHttpMessageConverter();
@Before
public void setUp() {
this.authenticationManager = mock(AuthenticationManager.clreplaced);
this.filter = new OAuth2TokenRevocationEndpointFilter(this.authenticationManager);
}
@After
public void cleanup() {
SecurityContextHolder.clearContext();
}
@Test
public void constructorWhenAuthenticationManagerNullThenThrowIllegalArgumentException() {
replacedertThatThrownBy(() -> new OAuth2TokenRevocationEndpointFilter(null)).isInstanceOf(IllegalArgumentException.clreplaced).hasMessage("authenticationManager cannot be null");
}
@Test
public void constructorWhenTokenRevocationEndpointUriNullThenThrowIllegalArgumentException() {
replacedertThatThrownBy(() -> new OAuth2TokenRevocationEndpointFilter(this.authenticationManager, null)).isInstanceOf(IllegalArgumentException.clreplaced).hasMessage("tokenRevocationEndpointUri cannot be empty");
}
@Test
public void doFilterWhenNotTokenRevocationRequestThenNotProcessed() throws Exception {
String requestUri = "/path";
MockHttpServletRequest request = new MockHttpServletRequest("POST", requestUri);
request.setServletPath(requestUri);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verify(filterChain).doFilter(any(HttpServletRequest.clreplaced), any(HttpServletResponse.clreplaced));
}
@Test
public void doFilterWhenTokenRevocationRequestGetThenNotProcessed() throws Exception {
String requestUri = OAuth2TokenRevocationEndpointFilter.DEFAULT_TOKEN_REVOCATION_ENDPOINT_URI;
MockHttpServletRequest request = new MockHttpServletRequest("GET", requestUri);
request.setServletPath(requestUri);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verify(filterChain).doFilter(any(HttpServletRequest.clreplaced), any(HttpServletResponse.clreplaced));
}
@Test
public void doFilterWhenTokenRevocationRequestMissingTokenThenInvalidRequestError() throws Exception {
doFilterWhenTokenRevocationRequestInvalidParameterThenError(OAuth2ParameterNames2.TOKEN, OAuth2ErrorCodes.INVALID_REQUEST, request -> request.removeParameter(OAuth2ParameterNames2.TOKEN));
}
@Test
public void doFilterWhenTokenRevocationRequestMultipleTokenThenInvalidRequestError() throws Exception {
doFilterWhenTokenRevocationRequestInvalidParameterThenError(OAuth2ParameterNames2.TOKEN, OAuth2ErrorCodes.INVALID_REQUEST, request -> request.addParameter(OAuth2ParameterNames2.TOKEN, "token-2"));
}
@Test
public void doFilterWhenTokenRevocationRequestMultipleTokenTypeHintThenInvalidRequestError() throws Exception {
doFilterWhenTokenRevocationRequestInvalidParameterThenError(OAuth2ParameterNames2.TOKEN_TYPE_HINT, OAuth2ErrorCodes.INVALID_REQUEST, request -> request.addParameter(OAuth2ParameterNames2.TOKEN_TYPE_HINT, OAuth2TokenType.ACCESS_TOKEN.getValue()));
}
@Test
public void doFilterWhenTokenRevocationRequestValidThenSuccessResponse() throws Exception {
RegisteredClient registeredClient = TestRegisteredClients.registeredClient().build();
Authentication clientPrincipal = new OAuth2ClientAuthenticationToken(registeredClient);
OAuth2AccessToken accessToken = new OAuth2AccessToken(OAuth2AccessToken.TokenType.BEARER, "token", Instant.now(), Instant.now().plus(Duration.ofHours(1)), new HashSet<>(Arrays.asList("scope1", "scope2")));
OAuth2TokenRevocationAuthenticationToken tokenRevocationAuthentication = new OAuth2TokenRevocationAuthenticationToken(accessToken, clientPrincipal);
when(this.authenticationManager.authenticate(any())).thenReturn(tokenRevocationAuthentication);
SecurityContext securityContext = SecurityContextHolder.createEmptyContext();
securityContext.setAuthentication(clientPrincipal);
SecurityContextHolder.setContext(securityContext);
MockHttpServletRequest request = createTokenRevocationRequest();
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verifyNoInteractions(filterChain);
verify(this.authenticationManager).authenticate(any());
replacedertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
}
private void doFilterWhenTokenRevocationRequestInvalidParameterThenError(String parameterName, String errorCode, Consumer<MockHttpServletRequest> requestConsumer) throws Exception {
MockHttpServletRequest request = createTokenRevocationRequest();
requestConsumer.accept(request);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verifyNoInteractions(filterChain);
replacedertThat(response.getStatus()).isEqualTo(HttpStatus.BAD_REQUEST.value());
OAuth2Error error = readError(response);
replacedertThat(error.getErrorCode()).isEqualTo(errorCode);
replacedertThat(error.getDescription()).isEqualTo("OAuth 2.0 Token Revocation Parameter: " + parameterName);
}
private OAuth2Error readError(MockHttpServletResponse response) throws Exception {
MockClientHttpResponse httpResponse = new MockClientHttpResponse(response.getContentAsByteArray(), HttpStatus.valueOf(response.getStatus()));
return this.errorHttpResponseConverter.read(OAuth2Error.clreplaced, httpResponse);
}
private static MockHttpServletRequest createTokenRevocationRequest() {
String requestUri = OAuth2TokenRevocationEndpointFilter.DEFAULT_TOKEN_REVOCATION_ENDPOINT_URI;
MockHttpServletRequest request = new MockHttpServletRequest("POST", requestUri);
request.setServletPath(requestUri);
request.addParameter(OAuth2ParameterNames2.TOKEN, "token");
request.addParameter(OAuth2ParameterNames2.TOKEN_TYPE_HINT, OAuth2TokenType.ACCESS_TOKEN.getValue());
return request;
}
}
18
Source : OAuth2TokenEndpointFilterTests.java
with Apache License 2.0
from spring-projects-experimental
with Apache License 2.0
from spring-projects-experimental
/**
* Tests for {@link OAuth2TokenEndpointFilter}.
*
* @author Madhu Bhat
* @author Joe Grandja
* @author Daniel Garnier-Moiroux
*/
public clreplaced OAuth2TokenEndpointFilterTests {
private AuthenticationManager authenticationManager;
private OAuth2TokenEndpointFilter filter;
private final HttpMessageConverter<OAuth2Error> errorHttpResponseConverter = new OAuth2ErrorHttpMessageConverter();
private final HttpMessageConverter<OAuth2AccessTokenResponse> accessTokenHttpResponseConverter = new OAuth2AccessTokenResponseHttpMessageConverter();
@Before
public void setUp() {
this.authenticationManager = mock(AuthenticationManager.clreplaced);
this.filter = new OAuth2TokenEndpointFilter(this.authenticationManager);
}
@After
public void cleanup() {
SecurityContextHolder.clearContext();
}
@Test
public void constructorWhenAuthenticationManagerNullThenThrowIllegalArgumentException() {
replacedertThatThrownBy(() -> new OAuth2TokenEndpointFilter(null, "tokenEndpointUri")).isInstanceOf(IllegalArgumentException.clreplaced).hasMessage("authenticationManager cannot be null");
}
@Test
public void constructorWhenTokenEndpointUriNullThenThrowIllegalArgumentException() {
replacedertThatThrownBy(() -> new OAuth2TokenEndpointFilter(this.authenticationManager, null)).isInstanceOf(IllegalArgumentException.clreplaced).hasMessage("tokenEndpointUri cannot be empty");
}
@Test
public void doFilterWhenNotTokenRequestThenNotProcessed() throws Exception {
String requestUri = "/path";
MockHttpServletRequest request = new MockHttpServletRequest("POST", requestUri);
request.setServletPath(requestUri);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verify(filterChain).doFilter(any(HttpServletRequest.clreplaced), any(HttpServletResponse.clreplaced));
}
@Test
public void doFilterWhenTokenRequestGetThenNotProcessed() throws Exception {
String requestUri = OAuth2TokenEndpointFilter.DEFAULT_TOKEN_ENDPOINT_URI;
MockHttpServletRequest request = new MockHttpServletRequest("GET", requestUri);
request.setServletPath(requestUri);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verify(filterChain).doFilter(any(HttpServletRequest.clreplaced), any(HttpServletResponse.clreplaced));
}
@Test
public void doFilterWhenTokenRequestMissingGrantTypeThenInvalidRequestError() throws Exception {
MockHttpServletRequest request = createAuthorizationCodeTokenRequest(TestRegisteredClients.registeredClient().build());
request.removeParameter(OAuth2ParameterNames.GRANT_TYPE);
doFilterWhenTokenRequestInvalidParameterThenError(OAuth2ParameterNames.GRANT_TYPE, OAuth2ErrorCodes.INVALID_REQUEST, request);
}
@Test
public void doFilterWhenTokenRequestMultipleGrantTypeThenInvalidRequestError() throws Exception {
MockHttpServletRequest request = createAuthorizationCodeTokenRequest(TestRegisteredClients.registeredClient().build());
request.addParameter(OAuth2ParameterNames.GRANT_TYPE, AuthorizationGrantType.AUTHORIZATION_CODE.getValue());
doFilterWhenTokenRequestInvalidParameterThenError(OAuth2ParameterNames.GRANT_TYPE, OAuth2ErrorCodes.INVALID_REQUEST, request);
}
@Test
public void doFilterWhenTokenRequestInvalidGrantTypeThenUnsupportedGrantTypeError() throws Exception {
MockHttpServletRequest request = createAuthorizationCodeTokenRequest(TestRegisteredClients.registeredClient().build());
request.setParameter(OAuth2ParameterNames.GRANT_TYPE, "invalid-grant-type");
doFilterWhenTokenRequestInvalidParameterThenError(OAuth2ParameterNames.GRANT_TYPE, OAuth2ErrorCodes.UNSUPPORTED_GRANT_TYPE, request);
}
@Test
public void doFilterWhenTokenRequestMissingCodeThenInvalidRequestError() throws Exception {
MockHttpServletRequest request = createAuthorizationCodeTokenRequest(TestRegisteredClients.registeredClient().build());
request.removeParameter(OAuth2ParameterNames.CODE);
doFilterWhenTokenRequestInvalidParameterThenError(OAuth2ParameterNames.CODE, OAuth2ErrorCodes.INVALID_REQUEST, request);
}
@Test
public void doFilterWhenTokenRequestMultipleCodeThenInvalidRequestError() throws Exception {
MockHttpServletRequest request = createAuthorizationCodeTokenRequest(TestRegisteredClients.registeredClient().build());
request.addParameter(OAuth2ParameterNames.CODE, "code-2");
doFilterWhenTokenRequestInvalidParameterThenError(OAuth2ParameterNames.CODE, OAuth2ErrorCodes.INVALID_REQUEST, request);
}
@Test
public void doFilterWhenTokenRequestMultipleRedirectUriThenInvalidRequestError() throws Exception {
MockHttpServletRequest request = createAuthorizationCodeTokenRequest(TestRegisteredClients.registeredClient().build());
request.addParameter(OAuth2ParameterNames.REDIRECT_URI, "https://example2.com");
doFilterWhenTokenRequestInvalidParameterThenError(OAuth2ParameterNames.REDIRECT_URI, OAuth2ErrorCodes.INVALID_REQUEST, request);
}
@Test
public void doFilterWhenAuthorizationCodeTokenRequestThenAccessTokenResponse() throws Exception {
RegisteredClient registeredClient = TestRegisteredClients.registeredClient().build();
Authentication clientPrincipal = new OAuth2ClientAuthenticationToken(registeredClient);
OAuth2AccessToken accessToken = new OAuth2AccessToken(OAuth2AccessToken.TokenType.BEARER, "token", Instant.now(), Instant.now().plus(Duration.ofHours(1)), new HashSet<>(Arrays.asList("scope1", "scope2")));
OAuth2RefreshToken refreshToken = new OAuth2RefreshToken2("refresh-token", Instant.now(), Instant.now().plus(Duration.ofDays(1)));
Map<String, Object> additionalParameters = Collections.singletonMap("custom-param", "custom-value");
OAuth2AccessTokenAuthenticationToken accessTokenAuthentication = new OAuth2AccessTokenAuthenticationToken(registeredClient, clientPrincipal, accessToken, refreshToken, additionalParameters);
when(this.authenticationManager.authenticate(any())).thenReturn(accessTokenAuthentication);
SecurityContext securityContext = SecurityContextHolder.createEmptyContext();
securityContext.setAuthentication(clientPrincipal);
SecurityContextHolder.setContext(securityContext);
MockHttpServletRequest request = createAuthorizationCodeTokenRequest(registeredClient);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verifyNoInteractions(filterChain);
ArgumentCaptor<OAuth2AuthorizationCodeAuthenticationToken> authorizationCodeAuthenticationCaptor = ArgumentCaptor.forClreplaced(OAuth2AuthorizationCodeAuthenticationToken.clreplaced);
verify(this.authenticationManager).authenticate(authorizationCodeAuthenticationCaptor.capture());
OAuth2AuthorizationCodeAuthenticationToken authorizationCodeAuthentication = authorizationCodeAuthenticationCaptor.getValue();
replacedertThat(authorizationCodeAuthentication.getCode()).isEqualTo(request.getParameter(OAuth2ParameterNames.CODE));
replacedertThat(authorizationCodeAuthentication.getPrincipal()).isEqualTo(clientPrincipal);
replacedertThat(authorizationCodeAuthentication.getRedirectUri()).isEqualTo(request.getParameter(OAuth2ParameterNames.REDIRECT_URI));
replacedertThat(authorizationCodeAuthentication.getAdditionalParameters()).containsExactly(entry("custom-param-1", "custom-value-1"));
replacedertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
OAuth2AccessTokenResponse accessTokenResponse = readAccessTokenResponse(response);
OAuth2AccessToken accessTokenResult = accessTokenResponse.getAccessToken();
replacedertThat(accessTokenResult.getTokenType()).isEqualTo(accessToken.getTokenType());
replacedertThat(accessTokenResult.getTokenValue()).isEqualTo(accessToken.getTokenValue());
replacedertThat(accessTokenResult.getIssuedAt()).isBetween(accessToken.getIssuedAt().minusSeconds(1), accessToken.getIssuedAt().plusSeconds(1));
replacedertThat(accessTokenResult.getExpiresAt()).isBetween(accessToken.getExpiresAt().minusSeconds(1), accessToken.getExpiresAt().plusSeconds(1));
replacedertThat(accessTokenResult.getScopes()).isEqualTo(accessToken.getScopes());
replacedertThat(accessTokenResponse.getRefreshToken().getTokenValue()).isEqualTo(refreshToken.getTokenValue());
replacedertThat(accessTokenResponse.getAdditionalParameters()).containsExactly(entry("custom-param", "custom-value"));
}
@Test
public void doFilterWhenClientCredentialsTokenRequestMultipleScopeThenInvalidRequestError() throws Exception {
MockHttpServletRequest request = createClientCredentialsTokenRequest(TestRegisteredClients.registeredClient2().build());
request.addParameter(OAuth2ParameterNames.SCOPE, "profile");
doFilterWhenTokenRequestInvalidParameterThenError(OAuth2ParameterNames.SCOPE, OAuth2ErrorCodes.INVALID_REQUEST, request);
}
@Test
public void doFilterWhenClientCredentialsTokenRequestThenAccessTokenResponse() throws Exception {
RegisteredClient registeredClient = TestRegisteredClients.registeredClient2().build();
Authentication clientPrincipal = new OAuth2ClientAuthenticationToken(registeredClient);
OAuth2AccessToken accessToken = new OAuth2AccessToken(OAuth2AccessToken.TokenType.BEARER, "token", Instant.now(), Instant.now().plus(Duration.ofHours(1)), new HashSet<>(Arrays.asList("scope1", "scope2")));
OAuth2AccessTokenAuthenticationToken accessTokenAuthentication = new OAuth2AccessTokenAuthenticationToken(registeredClient, clientPrincipal, accessToken);
when(this.authenticationManager.authenticate(any())).thenReturn(accessTokenAuthentication);
SecurityContext securityContext = SecurityContextHolder.createEmptyContext();
securityContext.setAuthentication(clientPrincipal);
SecurityContextHolder.setContext(securityContext);
MockHttpServletRequest request = createClientCredentialsTokenRequest(registeredClient);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verifyNoInteractions(filterChain);
ArgumentCaptor<OAuth2ClientCredentialsAuthenticationToken> clientCredentialsAuthenticationCaptor = ArgumentCaptor.forClreplaced(OAuth2ClientCredentialsAuthenticationToken.clreplaced);
verify(this.authenticationManager).authenticate(clientCredentialsAuthenticationCaptor.capture());
OAuth2ClientCredentialsAuthenticationToken clientCredentialsAuthentication = clientCredentialsAuthenticationCaptor.getValue();
replacedertThat(clientCredentialsAuthentication.getPrincipal()).isEqualTo(clientPrincipal);
replacedertThat(clientCredentialsAuthentication.getScopes()).isEqualTo(registeredClient.getScopes());
replacedertThat(clientCredentialsAuthentication.getAdditionalParameters()).containsExactly(entry("custom-param-1", "custom-value-1"));
replacedertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
OAuth2AccessTokenResponse accessTokenResponse = readAccessTokenResponse(response);
OAuth2AccessToken accessTokenResult = accessTokenResponse.getAccessToken();
replacedertThat(accessTokenResult.getTokenType()).isEqualTo(accessToken.getTokenType());
replacedertThat(accessTokenResult.getTokenValue()).isEqualTo(accessToken.getTokenValue());
replacedertThat(accessTokenResult.getIssuedAt()).isBetween(accessToken.getIssuedAt().minusSeconds(1), accessToken.getIssuedAt().plusSeconds(1));
replacedertThat(accessTokenResult.getExpiresAt()).isBetween(accessToken.getExpiresAt().minusSeconds(1), accessToken.getExpiresAt().plusSeconds(1));
replacedertThat(accessTokenResult.getScopes()).isEqualTo(accessToken.getScopes());
}
@Test
public void doFilterWhenRefreshTokenRequestMissingRefreshTokenThenInvalidRequestError() throws Exception {
MockHttpServletRequest request = createRefreshTokenTokenRequest(TestRegisteredClients.registeredClient().build());
request.removeParameter(OAuth2ParameterNames.REFRESH_TOKEN);
doFilterWhenTokenRequestInvalidParameterThenError(OAuth2ParameterNames.REFRESH_TOKEN, OAuth2ErrorCodes.INVALID_REQUEST, request);
}
@Test
public void doFilterWhenRefreshTokenRequestMultipleRefreshTokenThenInvalidRequestError() throws Exception {
MockHttpServletRequest request = createRefreshTokenTokenRequest(TestRegisteredClients.registeredClient().build());
request.addParameter(OAuth2ParameterNames.REFRESH_TOKEN, "refresh-token-2");
doFilterWhenTokenRequestInvalidParameterThenError(OAuth2ParameterNames.REFRESH_TOKEN, OAuth2ErrorCodes.INVALID_REQUEST, request);
}
@Test
public void doFilterWhenRefreshTokenRequestMultipleScopeThenInvalidRequestError() throws Exception {
MockHttpServletRequest request = createRefreshTokenTokenRequest(TestRegisteredClients.registeredClient().build());
request.addParameter(OAuth2ParameterNames.SCOPE, "profile");
doFilterWhenTokenRequestInvalidParameterThenError(OAuth2ParameterNames.SCOPE, OAuth2ErrorCodes.INVALID_REQUEST, request);
}
@Test
public void doFilterWhenRefreshTokenRequestThenAccessTokenResponse() throws Exception {
RegisteredClient registeredClient = TestRegisteredClients.registeredClient().build();
Authentication clientPrincipal = new OAuth2ClientAuthenticationToken(registeredClient);
OAuth2AccessToken accessToken = new OAuth2AccessToken(OAuth2AccessToken.TokenType.BEARER, "token", Instant.now(), Instant.now().plus(Duration.ofHours(1)), new HashSet<>(Arrays.asList("scope1", "scope2")));
OAuth2RefreshToken refreshToken = new OAuth2RefreshToken("refresh-token", Instant.now());
OAuth2AccessTokenAuthenticationToken accessTokenAuthentication = new OAuth2AccessTokenAuthenticationToken(registeredClient, clientPrincipal, accessToken, refreshToken);
when(this.authenticationManager.authenticate(any())).thenReturn(accessTokenAuthentication);
SecurityContext securityContext = SecurityContextHolder.createEmptyContext();
securityContext.setAuthentication(clientPrincipal);
SecurityContextHolder.setContext(securityContext);
MockHttpServletRequest request = createRefreshTokenTokenRequest(registeredClient);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verifyNoInteractions(filterChain);
ArgumentCaptor<OAuth2RefreshTokenAuthenticationToken> refreshTokenAuthenticationCaptor = ArgumentCaptor.forClreplaced(OAuth2RefreshTokenAuthenticationToken.clreplaced);
verify(this.authenticationManager).authenticate(refreshTokenAuthenticationCaptor.capture());
OAuth2RefreshTokenAuthenticationToken refreshTokenAuthenticationToken = refreshTokenAuthenticationCaptor.getValue();
replacedertThat(refreshTokenAuthenticationToken.getRefreshToken()).isEqualTo(refreshToken.getTokenValue());
replacedertThat(refreshTokenAuthenticationToken.getPrincipal()).isEqualTo(clientPrincipal);
replacedertThat(refreshTokenAuthenticationToken.getScopes()).isEqualTo(registeredClient.getScopes());
replacedertThat(refreshTokenAuthenticationToken.getAdditionalParameters()).containsExactly(entry("custom-param-1", "custom-value-1"));
replacedertThat(response.getStatus()).isEqualTo(HttpStatus.OK.value());
OAuth2AccessTokenResponse accessTokenResponse = readAccessTokenResponse(response);
OAuth2AccessToken accessTokenResult = accessTokenResponse.getAccessToken();
replacedertThat(accessTokenResult.getTokenType()).isEqualTo(accessToken.getTokenType());
replacedertThat(accessTokenResult.getTokenValue()).isEqualTo(accessToken.getTokenValue());
replacedertThat(accessTokenResult.getIssuedAt()).isBetween(accessToken.getIssuedAt().minusSeconds(1), accessToken.getIssuedAt().plusSeconds(1));
replacedertThat(accessTokenResult.getExpiresAt()).isBetween(accessToken.getExpiresAt().minusSeconds(1), accessToken.getExpiresAt().plusSeconds(1));
replacedertThat(accessTokenResult.getScopes()).isEqualTo(accessToken.getScopes());
OAuth2RefreshToken refreshTokenResult = accessTokenResponse.getRefreshToken();
replacedertThat(refreshTokenResult.getTokenValue()).isEqualTo(refreshToken.getTokenValue());
}
private void doFilterWhenTokenRequestInvalidParameterThenError(String parameterName, String errorCode, MockHttpServletRequest request) throws Exception {
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verifyNoInteractions(filterChain);
replacedertThat(response.getStatus()).isEqualTo(HttpStatus.BAD_REQUEST.value());
OAuth2Error error = readError(response);
replacedertThat(error.getErrorCode()).isEqualTo(errorCode);
replacedertThat(error.getDescription()).isEqualTo("OAuth 2.0 Parameter: " + parameterName);
}
private OAuth2Error readError(MockHttpServletResponse response) throws Exception {
MockClientHttpResponse httpResponse = new MockClientHttpResponse(response.getContentAsByteArray(), HttpStatus.valueOf(response.getStatus()));
return this.errorHttpResponseConverter.read(OAuth2Error.clreplaced, httpResponse);
}
private OAuth2AccessTokenResponse readAccessTokenResponse(MockHttpServletResponse response) throws Exception {
MockClientHttpResponse httpResponse = new MockClientHttpResponse(response.getContentAsByteArray(), HttpStatus.valueOf(response.getStatus()));
return this.accessTokenHttpResponseConverter.read(OAuth2AccessTokenResponse.clreplaced, httpResponse);
}
private static MockHttpServletRequest createAuthorizationCodeTokenRequest(RegisteredClient registeredClient) {
String[] redirectUris = registeredClient.getRedirectUris().toArray(new String[0]);
String requestUri = OAuth2TokenEndpointFilter.DEFAULT_TOKEN_ENDPOINT_URI;
MockHttpServletRequest request = new MockHttpServletRequest("POST", requestUri);
request.setServletPath(requestUri);
request.addParameter(OAuth2ParameterNames.GRANT_TYPE, AuthorizationGrantType.AUTHORIZATION_CODE.getValue());
request.addParameter(OAuth2ParameterNames.CODE, "code");
request.addParameter(OAuth2ParameterNames.REDIRECT_URI, redirectUris[0]);
// The client does not need to send the client ID param, but we are resilient in case they do
request.addParameter(OAuth2ParameterNames.CLIENT_ID, registeredClient.getClientId());
request.addParameter("custom-param-1", "custom-value-1");
return request;
}
private static MockHttpServletRequest createClientCredentialsTokenRequest(RegisteredClient registeredClient) {
String requestUri = OAuth2TokenEndpointFilter.DEFAULT_TOKEN_ENDPOINT_URI;
MockHttpServletRequest request = new MockHttpServletRequest("POST", requestUri);
request.setServletPath(requestUri);
request.addParameter(OAuth2ParameterNames.GRANT_TYPE, AuthorizationGrantType.CLIENT_CREDENTIALS.getValue());
request.addParameter(OAuth2ParameterNames.SCOPE, StringUtils.collectionToDelimitedString(registeredClient.getScopes(), " "));
request.addParameter("custom-param-1", "custom-value-1");
return request;
}
private static MockHttpServletRequest createRefreshTokenTokenRequest(RegisteredClient registeredClient) {
String requestUri = OAuth2TokenEndpointFilter.DEFAULT_TOKEN_ENDPOINT_URI;
MockHttpServletRequest request = new MockHttpServletRequest("POST", requestUri);
request.setServletPath(requestUri);
request.addParameter(OAuth2ParameterNames.GRANT_TYPE, AuthorizationGrantType.REFRESH_TOKEN.getValue());
request.addParameter(OAuth2ParameterNames.REFRESH_TOKEN, "refresh-token");
request.addParameter(OAuth2ParameterNames.SCOPE, StringUtils.collectionToDelimitedString(registeredClient.getScopes(), " "));
request.addParameter("custom-param-1", "custom-value-1");
return request;
}
}
18
Source : OAuth2ClientAuthenticationFilterTests.java
with Apache License 2.0
from spring-projects-experimental
with Apache License 2.0
from spring-projects-experimental
/**
* Tests for {@link OAuth2ClientAuthenticationFilter}.
*
* @author Patryk Kostrzewa
* @author Joe Grandja
*/
public clreplaced OAuth2ClientAuthenticationFilterTests {
private String filterProcessesUrl = "/oauth2/token";
private AuthenticationManager authenticationManager;
private RequestMatcher requestMatcher;
private AuthenticationConverter authenticationConverter;
private OAuth2ClientAuthenticationFilter filter;
private final HttpMessageConverter<OAuth2Error> errorHttpResponseConverter = new OAuth2ErrorHttpMessageConverter();
@Before
public void setUp() {
this.authenticationManager = mock(AuthenticationManager.clreplaced);
this.requestMatcher = new AntPathRequestMatcher(this.filterProcessesUrl, HttpMethod.POST.name());
this.filter = new OAuth2ClientAuthenticationFilter(this.authenticationManager, this.requestMatcher);
this.authenticationConverter = mock(AuthenticationConverter.clreplaced);
this.filter.setAuthenticationConverter(this.authenticationConverter);
}
@After
public void cleanup() {
SecurityContextHolder.clearContext();
}
@Test
public void constructorWhenAuthenticationManagerNullThenThrowIllegalArgumentException() {
replacedertThatThrownBy(() -> new OAuth2ClientAuthenticationFilter(null, this.requestMatcher)).isInstanceOf(IllegalArgumentException.clreplaced).hasMessage("authenticationManager cannot be null");
}
@Test
public void constructorWhenRequestMatcherNullThenThrowIllegalArgumentException() {
replacedertThatThrownBy(() -> new OAuth2ClientAuthenticationFilter(this.authenticationManager, null)).isInstanceOf(IllegalArgumentException.clreplaced).hasMessage("requestMatcher cannot be null");
}
@Test
public void setAuthenticationConverterWhenNullThenThrowIllegalArgumentException() {
replacedertThatThrownBy(() -> this.filter.setAuthenticationConverter(null)).isInstanceOf(IllegalArgumentException.clreplaced).hasMessage("authenticationConverter cannot be null");
}
@Test
public void setAuthenticationSuccessHandlerWhenNullThenThrowIllegalArgumentException() {
replacedertThatThrownBy(() -> this.filter.setAuthenticationSuccessHandler(null)).isInstanceOf(IllegalArgumentException.clreplaced).hasMessage("authenticationSuccessHandler cannot be null");
}
@Test
public void setAuthenticationFailureHandlerWhenNullThenThrowIllegalArgumentException() {
replacedertThatThrownBy(() -> this.filter.setAuthenticationFailureHandler(null)).isInstanceOf(IllegalArgumentException.clreplaced).hasMessage("authenticationFailureHandler cannot be null");
}
@Test
public void doFilterWhenRequestDoesNotMatchThenNotProcessed() throws Exception {
String requestUri = "/path";
MockHttpServletRequest request = new MockHttpServletRequest("POST", requestUri);
request.setServletPath(requestUri);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verify(filterChain).doFilter(any(HttpServletRequest.clreplaced), any(HttpServletResponse.clreplaced));
}
@Test
public void doFilterWhenRequestMatchesAndEmptyCredentialsThenNotProcessed() throws Exception {
MockHttpServletRequest request = new MockHttpServletRequest("POST", this.filterProcessesUrl);
request.setServletPath(this.filterProcessesUrl);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verify(filterChain).doFilter(any(HttpServletRequest.clreplaced), any(HttpServletResponse.clreplaced));
}
@Test
public void doFilterWhenRequestMatchesAndInvalidCredentialsThenInvalidRequestError() throws Exception {
when(this.authenticationConverter.convert(any(HttpServletRequest.clreplaced))).thenThrow(new OAuth2AuthenticationException(new OAuth2Error(OAuth2ErrorCodes.INVALID_REQUEST)));
MockHttpServletRequest request = new MockHttpServletRequest("POST", this.filterProcessesUrl);
request.setServletPath(this.filterProcessesUrl);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verifyNoInteractions(filterChain);
replacedertThat(SecurityContextHolder.getContext().getAuthentication()).isNull();
replacedertThat(response.getStatus()).isEqualTo(HttpStatus.BAD_REQUEST.value());
OAuth2Error error = readError(response);
replacedertThat(error.getErrorCode()).isEqualTo(OAuth2ErrorCodes.INVALID_REQUEST);
}
@Test
public void doFilterWhenRequestMatchesAndBadCredentialsThenInvalidClientError() throws Exception {
when(this.authenticationConverter.convert(any(HttpServletRequest.clreplaced))).thenReturn(new OAuth2ClientAuthenticationToken("clientId", "invalid-secret", ClientAuthenticationMethod.BASIC, null));
when(this.authenticationManager.authenticate(any(Authentication.clreplaced))).thenThrow(new OAuth2AuthenticationException(new OAuth2Error(OAuth2ErrorCodes.INVALID_CLIENT)));
MockHttpServletRequest request = new MockHttpServletRequest("POST", this.filterProcessesUrl);
request.setServletPath(this.filterProcessesUrl);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verifyNoInteractions(filterChain);
replacedertThat(SecurityContextHolder.getContext().getAuthentication()).isNull();
replacedertThat(response.getStatus()).isEqualTo(HttpStatus.UNAUTHORIZED.value());
OAuth2Error error = readError(response);
replacedertThat(error.getErrorCode()).isEqualTo(OAuth2ErrorCodes.INVALID_CLIENT);
}
@Test
public void doFilterWhenRequestMatchesAndValidCredentialsThenProcessed() throws Exception {
RegisteredClient registeredClient = TestRegisteredClients.registeredClient().build();
when(this.authenticationConverter.convert(any(HttpServletRequest.clreplaced))).thenReturn(new OAuth2ClientAuthenticationToken(registeredClient.getClientId(), registeredClient.getClientSecret(), ClientAuthenticationMethod.BASIC, null));
when(this.authenticationManager.authenticate(any(Authentication.clreplaced))).thenReturn(new OAuth2ClientAuthenticationToken(registeredClient));
MockHttpServletRequest request = new MockHttpServletRequest("POST", this.filterProcessesUrl);
request.setServletPath(this.filterProcessesUrl);
MockHttpServletResponse response = new MockHttpServletResponse();
FilterChain filterChain = mock(FilterChain.clreplaced);
this.filter.doFilter(request, response, filterChain);
verify(filterChain).doFilter(any(HttpServletRequest.clreplaced), any(HttpServletResponse.clreplaced));
Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
replacedertThat(authentication).isInstanceOf(OAuth2ClientAuthenticationToken.clreplaced);
replacedertThat(((OAuth2ClientAuthenticationToken) authentication).getRegisteredClient()).isEqualTo(registeredClient);
}
private OAuth2Error readError(MockHttpServletResponse response) throws Exception {
MockClientHttpResponse httpResponse = new MockClientHttpResponse(response.getContentAsByteArray(), HttpStatus.valueOf(response.getStatus()));
return this.errorHttpResponseConverter.read(OAuth2Error.clreplaced, httpResponse);
}
}
18
Source : OAuth2TokenEndpointFilter.java
with Apache License 2.0
from spring-projects-experimental
with Apache License 2.0
from spring-projects-experimental
/**
* A {@code Filter} for the OAuth 2.0 Token endpoint,
* which handles the processing of an OAuth 2.0 Authorization Grant.
*
* <p>
* It converts the OAuth 2.0 Authorization Grant request to an {@link Authentication},
* which is then authenticated by the {@link AuthenticationManager}.
* If the authentication succeeds, the {@link AuthenticationManager} returns an
* {@link OAuth2AccessTokenAuthenticationToken}, which is returned in the OAuth 2.0 Access Token response.
* In case of any error, an {@link OAuth2Error} is returned in the OAuth 2.0 Error response.
*
* <p>
* By default, this {@code Filter} responds to authorization grant requests
* at the {@code URI} {@code /oauth2/token} and {@code HttpMethod} {@code POST}.
*
* <p>
* The default endpoint {@code URI} {@code /oauth2/token} may be overridden
* via the constructor {@link #OAuth2TokenEndpointFilter(AuthenticationManager, String)}.
*
* @author Joe Grandja
* @author Madhu Bhat
* @author Daniel Garnier-Moiroux
* @since 0.0.1
* @see AuthenticationManager
* @see OAuth2AuthorizationCodeAuthenticationProvider
* @see OAuth2RefreshTokenAuthenticationProvider
* @see OAuth2ClientCredentialsAuthenticationProvider
* @see <a target="_blank" href="https://tools.ietf.org/html/rfc6749#section-3.2">Section 3.2 Token Endpoint</a>
*/
public clreplaced OAuth2TokenEndpointFilter extends OncePerRequestFilter {
/**
* The default endpoint {@code URI} for access token requests.
*/
public static final String DEFAULT_TOKEN_ENDPOINT_URI = "/oauth2/token";
private final AuthenticationManager authenticationManager;
private final RequestMatcher tokenEndpointMatcher;
private final AuthenticationConverter authorizationGrantAuthenticationConverter;
private final HttpMessageConverter<OAuth2AccessTokenResponse> accessTokenHttpResponseConverter = new OAuth2AccessTokenResponseHttpMessageConverter();
private final HttpMessageConverter<OAuth2Error> errorHttpResponseConverter = new OAuth2ErrorHttpMessageConverter();
/**
* Constructs an {@code OAuth2TokenEndpointFilter} using the provided parameters.
*
* @param authenticationManager the authentication manager
*/
public OAuth2TokenEndpointFilter(AuthenticationManager authenticationManager) {
this(authenticationManager, DEFAULT_TOKEN_ENDPOINT_URI);
}
/**
* Constructs an {@code OAuth2TokenEndpointFilter} using the provided parameters.
*
* @param authenticationManager the authentication manager
* @param tokenEndpointUri the endpoint {@code URI} for access token requests
*/
public OAuth2TokenEndpointFilter(AuthenticationManager authenticationManager, String tokenEndpointUri) {
replacedert.notNull(authenticationManager, "authenticationManager cannot be null");
replacedert.hasText(tokenEndpointUri, "tokenEndpointUri cannot be empty");
this.authenticationManager = authenticationManager;
this.tokenEndpointMatcher = new AntPathRequestMatcher(tokenEndpointUri, HttpMethod.POST.name());
List<AuthenticationConverter> converters = new ArrayList<>();
converters.add(new AuthorizationCodeAuthenticationConverter());
converters.add(new RefreshTokenAuthenticationConverter());
converters.add(new ClientCredentialsAuthenticationConverter());
this.authorizationGrantAuthenticationConverter = new DelegatingAuthenticationConverter(converters);
}
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
if (!this.tokenEndpointMatcher.matches(request)) {
filterChain.doFilter(request, response);
return;
}
try {
String[] grantTypes = request.getParameterValues(OAuth2ParameterNames.GRANT_TYPE);
if (grantTypes == null || grantTypes.length != 1) {
throwError(OAuth2ErrorCodes.INVALID_REQUEST, OAuth2ParameterNames.GRANT_TYPE);
}
Authentication authorizationGrantAuthentication = this.authorizationGrantAuthenticationConverter.convert(request);
if (authorizationGrantAuthentication == null) {
throwError(OAuth2ErrorCodes.UNSUPPORTED_GRANT_TYPE, OAuth2ParameterNames.GRANT_TYPE);
}
OAuth2AccessTokenAuthenticationToken accessTokenAuthentication = (OAuth2AccessTokenAuthenticationToken) this.authenticationManager.authenticate(authorizationGrantAuthentication);
sendAccessTokenResponse(response, accessTokenAuthentication);
} catch (OAuth2AuthenticationException ex) {
SecurityContextHolder.clearContext();
sendErrorResponse(response, ex.getError());
}
}
private void sendAccessTokenResponse(HttpServletResponse response, OAuth2AccessTokenAuthenticationToken accessTokenAuthentication) throws IOException {
OAuth2AccessToken accessToken = accessTokenAuthentication.getAccessToken();
OAuth2RefreshToken refreshToken = accessTokenAuthentication.getRefreshToken();
Map<String, Object> additionalParameters = accessTokenAuthentication.getAdditionalParameters();
OAuth2AccessTokenResponse.Builder builder = OAuth2AccessTokenResponse.withToken(accessToken.getTokenValue()).tokenType(accessToken.getTokenType()).scopes(accessToken.getScopes());
if (accessToken.getIssuedAt() != null && accessToken.getExpiresAt() != null) {
builder.expiresIn(ChronoUnit.SECONDS.between(accessToken.getIssuedAt(), accessToken.getExpiresAt()));
}
if (refreshToken != null) {
builder.refreshToken(refreshToken.getTokenValue());
}
if (!CollectionUtils.isEmpty(additionalParameters)) {
builder.additionalParameters(additionalParameters);
}
OAuth2AccessTokenResponse accessTokenResponse = builder.build();
ServletServerHttpResponse httpResponse = new ServletServerHttpResponse(response);
this.accessTokenHttpResponseConverter.write(accessTokenResponse, null, httpResponse);
}
private void sendErrorResponse(HttpServletResponse response, OAuth2Error error) throws IOException {
ServletServerHttpResponse httpResponse = new ServletServerHttpResponse(response);
httpResponse.setStatusCode(HttpStatus.BAD_REQUEST);
this.errorHttpResponseConverter.write(error, null, httpResponse);
}
private static void throwError(String errorCode, String parameterName) {
OAuth2Error error = new OAuth2Error(errorCode, "OAuth 2.0 Parameter: " + parameterName, "https://tools.ietf.org/html/rfc6749#section-5.2");
throw new OAuth2AuthenticationException(error);
}
private static clreplaced AuthorizationCodeAuthenticationConverter implements AuthenticationConverter {
@Override
public Authentication convert(HttpServletRequest request) {
// grant_type (REQUIRED)
String grantType = request.getParameter(OAuth2ParameterNames.GRANT_TYPE);
if (!AuthorizationGrantType.AUTHORIZATION_CODE.getValue().equals(grantType)) {
return null;
}
Authentication clientPrincipal = SecurityContextHolder.getContext().getAuthentication();
MultiValueMap<String, String> parameters = OAuth2EndpointUtils.getParameters(request);
// code (REQUIRED)
String code = parameters.getFirst(OAuth2ParameterNames.CODE);
if (!StringUtils.hasText(code) || parameters.get(OAuth2ParameterNames.CODE).size() != 1) {
throwError(OAuth2ErrorCodes.INVALID_REQUEST, OAuth2ParameterNames.CODE);
}
// redirect_uri (REQUIRED)
// Required only if the "redirect_uri" parameter was included in the authorization request
String redirectUri = parameters.getFirst(OAuth2ParameterNames.REDIRECT_URI);
if (StringUtils.hasText(redirectUri) && parameters.get(OAuth2ParameterNames.REDIRECT_URI).size() != 1) {
throwError(OAuth2ErrorCodes.INVALID_REQUEST, OAuth2ParameterNames.REDIRECT_URI);
}
// @formatter:off
Map<String, Object> additionalParameters = parameters.entrySet().stream().filter(e -> !e.getKey().equals(OAuth2ParameterNames.GRANT_TYPE) && !e.getKey().equals(OAuth2ParameterNames.CLIENT_ID) && !e.getKey().equals(OAuth2ParameterNames.CODE) && !e.getKey().equals(OAuth2ParameterNames.REDIRECT_URI)).collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().get(0)));
// @formatter:on
return new OAuth2AuthorizationCodeAuthenticationToken(code, clientPrincipal, redirectUri, additionalParameters);
}
}
private static clreplaced RefreshTokenAuthenticationConverter implements AuthenticationConverter {
@Override
public Authentication convert(HttpServletRequest request) {
// grant_type (REQUIRED)
String grantType = request.getParameter(OAuth2ParameterNames.GRANT_TYPE);
if (!AuthorizationGrantType.REFRESH_TOKEN.getValue().equals(grantType)) {
return null;
}
Authentication clientPrincipal = SecurityContextHolder.getContext().getAuthentication();
MultiValueMap<String, String> parameters = OAuth2EndpointUtils.getParameters(request);
// refresh_token (REQUIRED)
String refreshToken = parameters.getFirst(OAuth2ParameterNames.REFRESH_TOKEN);
if (!StringUtils.hasText(refreshToken) || parameters.get(OAuth2ParameterNames.REFRESH_TOKEN).size() != 1) {
throwError(OAuth2ErrorCodes.INVALID_REQUEST, OAuth2ParameterNames.REFRESH_TOKEN);
}
// scope (OPTIONAL)
String scope = parameters.getFirst(OAuth2ParameterNames.SCOPE);
if (StringUtils.hasText(scope) && parameters.get(OAuth2ParameterNames.SCOPE).size() != 1) {
throwError(OAuth2ErrorCodes.INVALID_REQUEST, OAuth2ParameterNames.SCOPE);
}
Set<String> requestedScopes = null;
if (StringUtils.hasText(scope)) {
requestedScopes = new HashSet<>(Arrays.asList(StringUtils.delimitedListToStringArray(scope, " ")));
}
// @formatter:off
Map<String, Object> additionalParameters = parameters.entrySet().stream().filter(e -> !e.getKey().equals(OAuth2ParameterNames.GRANT_TYPE) && !e.getKey().equals(OAuth2ParameterNames.REFRESH_TOKEN) && !e.getKey().equals(OAuth2ParameterNames.SCOPE)).collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().get(0)));
// @formatter:on
return new OAuth2RefreshTokenAuthenticationToken(refreshToken, clientPrincipal, requestedScopes, additionalParameters);
}
}
private static clreplaced ClientCredentialsAuthenticationConverter implements AuthenticationConverter {
@Override
public Authentication convert(HttpServletRequest request) {
// grant_type (REQUIRED)
String grantType = request.getParameter(OAuth2ParameterNames.GRANT_TYPE);
if (!AuthorizationGrantType.CLIENT_CREDENTIALS.getValue().equals(grantType)) {
return null;
}
Authentication clientPrincipal = SecurityContextHolder.getContext().getAuthentication();
MultiValueMap<String, String> parameters = OAuth2EndpointUtils.getParameters(request);
// scope (OPTIONAL)
String scope = parameters.getFirst(OAuth2ParameterNames.SCOPE);
if (StringUtils.hasText(scope) && parameters.get(OAuth2ParameterNames.SCOPE).size() != 1) {
throwError(OAuth2ErrorCodes.INVALID_REQUEST, OAuth2ParameterNames.SCOPE);
}
Set<String> requestedScopes = null;
if (StringUtils.hasText(scope)) {
requestedScopes = new HashSet<>(Arrays.asList(StringUtils.delimitedListToStringArray(scope, " ")));
}
// @formatter:off
Map<String, Object> additionalParameters = parameters.entrySet().stream().filter(e -> !e.getKey().equals(OAuth2ParameterNames.GRANT_TYPE) && !e.getKey().equals(OAuth2ParameterNames.SCOPE)).collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().get(0)));
// @formatter:on
return new OAuth2ClientCredentialsAuthenticationToken(clientPrincipal, requestedScopes, additionalParameters);
}
}
}
18
Source : OAuth2ClientAuthenticationFilter.java
with Apache License 2.0
from spring-projects-experimental
with Apache License 2.0
from spring-projects-experimental
/**
* A {@code Filter} that processes an authentication request for an OAuth 2.0 Client.
*
* @author Joe Grandja
* @author Patryk Kostrzewa
* @since 0.0.1
* @see AuthenticationManager
* @see OAuth2ClientAuthenticationProvider
* @see <a target="_blank" href="https://tools.ietf.org/html/rfc6749#section-2.3">Section 2.3 Client Authentication</a>
* @see <a target="_blank" href="https://tools.ietf.org/html/rfc6749#section-3.2.1">Section 3.2.1 Token Endpoint Client Authentication</a>
*/
public clreplaced OAuth2ClientAuthenticationFilter extends OncePerRequestFilter {
private final AuthenticationManager authenticationManager;
private final RequestMatcher requestMatcher;
private final HttpMessageConverter<OAuth2Error> errorHttpResponseConverter = new OAuth2ErrorHttpMessageConverter();
private AuthenticationConverter authenticationConverter;
private AuthenticationSuccessHandler authenticationSuccessHandler;
private AuthenticationFailureHandler authenticationFailureHandler;
/**
* Constructs an {@code OAuth2ClientAuthenticationFilter} using the provided parameters.
*
* @param authenticationManager the {@link AuthenticationManager} used for authenticating the client
* @param requestMatcher the {@link RequestMatcher} used for matching against the {@code HttpServletRequest}
*/
public OAuth2ClientAuthenticationFilter(AuthenticationManager authenticationManager, RequestMatcher requestMatcher) {
replacedert.notNull(authenticationManager, "authenticationManager cannot be null");
replacedert.notNull(requestMatcher, "requestMatcher cannot be null");
this.authenticationManager = authenticationManager;
this.requestMatcher = requestMatcher;
this.authenticationConverter = new DelegatingAuthenticationConverter(Arrays.asList(new ClientSecretBasicAuthenticationConverter(), new ClientSecretPostAuthenticationConverter(), new PublicClientAuthenticationConverter()));
this.authenticationSuccessHandler = this::onAuthenticationSuccess;
this.authenticationFailureHandler = this::onAuthenticationFailure;
}
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
if (this.requestMatcher.matches(request)) {
try {
Authentication authenticationRequest = this.authenticationConverter.convert(request);
if (authenticationRequest != null) {
Authentication authenticationResult = this.authenticationManager.authenticate(authenticationRequest);
this.authenticationSuccessHandler.onAuthenticationSuccess(request, response, authenticationResult);
}
} catch (OAuth2AuthenticationException failed) {
this.authenticationFailureHandler.onAuthenticationFailure(request, response, failed);
return;
}
}
filterChain.doFilter(request, response);
}
/**
* Sets the {@link AuthenticationConverter} used for converting a {@link HttpServletRequest} to an {@link OAuth2ClientAuthenticationToken}.
*
* @param authenticationConverter used for converting a {@link HttpServletRequest} to an {@link OAuth2ClientAuthenticationToken}
*/
public final void setAuthenticationConverter(AuthenticationConverter authenticationConverter) {
replacedert.notNull(authenticationConverter, "authenticationConverter cannot be null");
this.authenticationConverter = authenticationConverter;
}
/**
* Sets the {@link AuthenticationSuccessHandler} used for handling successful authentications.
*
* @param authenticationSuccessHandler the {@link AuthenticationSuccessHandler} used for handling successful authentications
*/
public final void setAuthenticationSuccessHandler(AuthenticationSuccessHandler authenticationSuccessHandler) {
replacedert.notNull(authenticationSuccessHandler, "authenticationSuccessHandler cannot be null");
this.authenticationSuccessHandler = authenticationSuccessHandler;
}
/**
* Sets the {@link AuthenticationFailureHandler} used for handling failed authentications.
*
* @param authenticationFailureHandler the {@link AuthenticationFailureHandler} used for handling failed authentications
*/
public final void setAuthenticationFailureHandler(AuthenticationFailureHandler authenticationFailureHandler) {
replacedert.notNull(authenticationFailureHandler, "authenticationFailureHandler cannot be null");
this.authenticationFailureHandler = authenticationFailureHandler;
}
private void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) {
SecurityContext context = SecurityContextHolder.createEmptyContext();
context.setAuthentication(authentication);
SecurityContextHolder.setContext(context);
}
private void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException failed) throws IOException {
SecurityContextHolder.clearContext();
// TODO
// The authorization server MAY return an HTTP 401 (Unauthorized) status code
// to indicate which HTTP authentication schemes are supported.
// If the client attempted to authenticate via the "Authorization" request header field,
// the authorization server MUST respond with an HTTP 401 (Unauthorized) status code and
// include the "WWW-Authenticate" response header field
// matching the authentication scheme used by the client.
OAuth2Error error = ((OAuth2AuthenticationException) failed).getError();
ServletServerHttpResponse httpResponse = new ServletServerHttpResponse(response);
if (OAuth2ErrorCodes.INVALID_CLIENT.equals(error.getErrorCode())) {
httpResponse.setStatusCode(HttpStatus.UNAUTHORIZED);
} else {
httpResponse.setStatusCode(HttpStatus.BAD_REQUEST);
}
this.errorHttpResponseConverter.write(error, null, httpResponse);
}
}
18
Source : SkipperClientConfiguration.java
with Apache License 2.0
from spring-cloud
with Apache License 2.0
from spring-cloud
public RestTemplate validateRestTemplate(RestTemplate restTemplate) {
boolean containsMappingJackson2HttpMessageConverter = false;
for (HttpMessageConverter<?> converter : restTemplate.getMessageConverters()) {
if (converter instanceof MappingJackson2HttpMessageConverter) {
containsMappingJackson2HttpMessageConverter = true;
}
}
if (!containsMappingJackson2HttpMessageConverter) {
throw new IllegalArgumentException("The RestTemplate does not contain a required " + "MappingJackson2HttpMessageConverter.");
}
return restTemplate;
}
18
Source : HttpMessageConverterExtractorTests.java
with Apache License 2.0
from SourceHot
with Apache License 2.0
from SourceHot
/**
* Test fixture for {@link HttpMessageConverter}.
*
* @author Arjen Poutsma
* @author Brian Clozel
* @author Sam Brannen
*/
public clreplaced HttpMessageConverterExtractorTests {
@SuppressWarnings("unchecked")
private final HttpMessageConverter<String> converter = mock(HttpMessageConverter.clreplaced);
private final HttpMessageConverterExtractor<?> extractor = new HttpMessageConverterExtractor<>(String.clreplaced, asList(converter));
private final MediaType contentType = MediaType.TEXT_PLAIN;
private final HttpHeaders responseHeaders = new HttpHeaders();
private final ClientHttpResponse response = mock(ClientHttpResponse.clreplaced);
@Test
public void constructorPreconditions() {
replacedertThatIllegalArgumentException().isThrownBy(() -> new HttpMessageConverterExtractor<>(String.clreplaced, (List<HttpMessageConverter<?>>) null)).withMessage("'messageConverters' must not be empty");
replacedertThatIllegalArgumentException().isThrownBy(() -> new HttpMessageConverterExtractor<>(String.clreplaced, Arrays.asList(null, this.converter))).withMessage("'messageConverters' must not contain null elements");
}
@Test
public void noContent() throws IOException {
given(response.getRawStatusCode()).willReturn(HttpStatus.NO_CONTENT.value());
Object result = extractor.extractData(response);
replacedertThat(result).isNull();
}
@Test
public void notModified() throws IOException {
given(response.getRawStatusCode()).willReturn(HttpStatus.NOT_MODIFIED.value());
Object result = extractor.extractData(response);
replacedertThat(result).isNull();
}
@Test
public void informational() throws IOException {
given(response.getRawStatusCode()).willReturn(HttpStatus.CONTINUE.value());
Object result = extractor.extractData(response);
replacedertThat(result).isNull();
}
@Test
public void zeroContentLength() throws IOException {
responseHeaders.setContentLength(0);
given(response.getRawStatusCode()).willReturn(HttpStatus.OK.value());
given(response.getHeaders()).willReturn(responseHeaders);
Object result = extractor.extractData(response);
replacedertThat(result).isNull();
}
@Test
public void emptyMessageBody() throws IOException {
given(response.getRawStatusCode()).willReturn(HttpStatus.OK.value());
given(response.getHeaders()).willReturn(responseHeaders);
given(response.getBody()).willReturn(new ByteArrayInputStream("".getBytes()));
Object result = extractor.extractData(response);
replacedertThat(result).isNull();
}
// gh-22265
@Test
public void nullMessageBody() throws IOException {
given(response.getRawStatusCode()).willReturn(HttpStatus.OK.value());
given(response.getHeaders()).willReturn(responseHeaders);
given(response.getBody()).willReturn(null);
Object result = extractor.extractData(response);
replacedertThat(result).isNull();
}
@Test
public void normal() throws IOException {
responseHeaders.setContentType(contentType);
String expected = "Foo";
given(response.getRawStatusCode()).willReturn(HttpStatus.OK.value());
given(response.getHeaders()).willReturn(responseHeaders);
given(response.getBody()).willReturn(new ByteArrayInputStream(expected.getBytes()));
given(converter.canRead(String.clreplaced, contentType)).willReturn(true);
given(converter.read(eq(String.clreplaced), any(HttpInputMessage.clreplaced))).willReturn(expected);
Object result = extractor.extractData(response);
replacedertThat(result).isEqualTo(expected);
}
@Test
public void cannotRead() throws IOException {
responseHeaders.setContentType(contentType);
given(response.getRawStatusCode()).willReturn(HttpStatus.OK.value());
given(response.getHeaders()).willReturn(responseHeaders);
given(response.getBody()).willReturn(new ByteArrayInputStream("Foobar".getBytes()));
given(converter.canRead(String.clreplaced, contentType)).willReturn(false);
replacedertThatExceptionOfType(RestClientException.clreplaced).isThrownBy(() -> extractor.extractData(response));
}
@Test
@SuppressWarnings("unchecked")
public void generics() throws IOException {
responseHeaders.setContentType(contentType);
String expected = "Foo";
ParameterizedTypeReference<List<String>> reference = new ParameterizedTypeReference<List<String>>() {
};
Type type = reference.getType();
GenericHttpMessageConverter<String> converter = mock(GenericHttpMessageConverter.clreplaced);
HttpMessageConverterExtractor<?> extractor = new HttpMessageConverterExtractor<List<String>>(type, asList(converter));
given(response.getRawStatusCode()).willReturn(HttpStatus.OK.value());
given(response.getHeaders()).willReturn(responseHeaders);
given(response.getBody()).willReturn(new ByteArrayInputStream(expected.getBytes()));
given(converter.canRead(type, null, contentType)).willReturn(true);
given(converter.read(eq(type), eq(null), any(HttpInputMessage.clreplaced))).willReturn(expected);
Object result = extractor.extractData(response);
replacedertThat(result).isEqualTo(expected);
}
// SPR-13592
@Test
public void converterThrowsIOException() throws IOException {
responseHeaders.setContentType(contentType);
given(response.getRawStatusCode()).willReturn(HttpStatus.OK.value());
given(response.getHeaders()).willReturn(responseHeaders);
given(response.getBody()).willReturn(new ByteArrayInputStream("Foobar".getBytes()));
given(converter.canRead(String.clreplaced, contentType)).willReturn(true);
given(converter.read(eq(String.clreplaced), any(HttpInputMessage.clreplaced))).willThrow(IOException.clreplaced);
replacedertThatExceptionOfType(RestClientException.clreplaced).isThrownBy(() -> extractor.extractData(response)).withMessageContaining("Error while extracting response for type [clreplaced java.lang.String] and content type [text/plain]").withCauseInstanceOf(IOException.clreplaced);
}
// SPR-13592
@Test
public void converterThrowsHttpMessageNotReadableException() throws IOException {
responseHeaders.setContentType(contentType);
given(response.getRawStatusCode()).willReturn(HttpStatus.OK.value());
given(response.getHeaders()).willReturn(responseHeaders);
given(response.getBody()).willReturn(new ByteArrayInputStream("Foobar".getBytes()));
given(converter.canRead(String.clreplaced, contentType)).willThrow(HttpMessageNotReadableException.clreplaced);
replacedertThatExceptionOfType(RestClientException.clreplaced).isThrownBy(() -> extractor.extractData(response)).withMessageContaining("Error while extracting response for type [clreplaced java.lang.String] and content type [text/plain]").withCauseInstanceOf(HttpMessageNotReadableException.clreplaced);
}
}
18
Source : CustomAuthenticationEntryPoint.java
with GNU General Public License v3.0
from sermore
with GNU General Public License v3.0
from sermore
@Component
public clreplaced CustomAuthenticationEntryPoint implements AuthenticationEntryPoint {
private final HttpMessageConverter<String> messageConverter;
private final ObjectMapper mapper;
public CustomAuthenticationEntryPoint(ObjectMapper mapper) {
this.messageConverter = new StringHttpMessageConverter();
this.mapper = mapper;
}
@Override
public void commence(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, AuthenticationException e) throws IOException {
ApiError apiError = new ApiError(UNAUTHORIZED);
apiError.setMessage(e.getMessage());
apiError.setDebugMessage(e.getMessage());
ServerHttpResponse outputMessage = new ServletServerHttpResponse(httpServletResponse);
outputMessage.setStatusCode(HttpStatus.UNAUTHORIZED);
messageConverter.write(mapper.writeValuereplacedtring(apiError), MediaType.APPLICATION_JSON, outputMessage);
}
}
18
Source : AnnotationMethodHandlerExceptionResolver.java
with Apache License 2.0
from langtianya
with Apache License 2.0
from langtianya
/**
* Implementation of the {@link org.springframework.web.servlet.HandlerExceptionResolver} interface that handles
* exceptions through the {@link ExceptionHandler} annotation.
*
* <p>This exception resolver is enabled by default in the {@link org.springframework.web.servlet.DispatcherServlet}.
*
* @author Arjen Poutsma
* @author Juergen Hoeller
* @since 3.0
* @deprecated as of Spring 3.2, in favor of
* {@link org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver ExceptionHandlerExceptionResolver}
*/
@Deprecated
public clreplaced AnnotationMethodHandlerExceptionResolver extends AbstractHandlerExceptionResolver {
/**
* Arbitrary {@link Method} reference, indicating no method found in the cache.
*/
private static final Method NO_METHOD_FOUND = ClreplacedUtils.getMethodIfAvailable(System.clreplaced, "currentTimeMillis");
private final Map<Clreplaced<?>, Map<Clreplaced<? extends Throwable>, Method>> exceptionHandlerCache = new ConcurrentHashMap<Clreplaced<?>, Map<Clreplaced<? extends Throwable>, Method>>(64);
private WebArgumentResolver[] customArgumentResolvers;
private HttpMessageConverter<?>[] messageConverters = new HttpMessageConverter<?>[] { new ByteArrayHttpMessageConverter(), new StringHttpMessageConverter(), new SourceHttpMessageConverter<Source>(), new org.springframework.http.converter.xml.XmlAwareFormHttpMessageConverter() };
/**
* Set a custom ArgumentResolvers to use for special method parameter types.
* <p>Such a custom ArgumentResolver will kick in first, having a chance to resolve
* an argument value before the standard argument handling kicks in.
*/
public void setCustomArgumentResolver(WebArgumentResolver argumentResolver) {
this.customArgumentResolvers = new WebArgumentResolver[] { argumentResolver };
}
/**
* Set one or more custom ArgumentResolvers to use for special method parameter types.
* <p>Any such custom ArgumentResolver will kick in first, having a chance to resolve
* an argument value before the standard argument handling kicks in.
*/
public void setCustomArgumentResolvers(WebArgumentResolver[] argumentResolvers) {
this.customArgumentResolvers = argumentResolvers;
}
/**
* Set the message body converters to use.
* <p>These converters are used to convert from and to HTTP requests and responses.
*/
public void setMessageConverters(HttpMessageConverter<?>[] messageConverters) {
this.messageConverters = messageConverters;
}
@Override
protected ModelAndView doResolveException(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
if (handler != null) {
Method handlerMethod = findBestExceptionHandlerMethod(handler, ex);
if (handlerMethod != null) {
ServletWebRequest webRequest = new ServletWebRequest(request, response);
try {
Object[] args = resolveHandlerArguments(handlerMethod, handler, webRequest, ex);
if (logger.isDebugEnabled()) {
logger.debug("Invoking request handler method: " + handlerMethod);
}
Object retVal = doInvokeMethod(handlerMethod, handler, args);
return getModelAndView(handlerMethod, retVal, webRequest);
} catch (Exception invocationEx) {
logger.error("Invoking request method resulted in exception : " + handlerMethod, invocationEx);
}
}
}
return null;
}
/**
* Finds the handler method that matches the thrown exception best.
* @param handler the handler object
* @param thrownException the exception to be handled
* @return the best matching method; or {@code null} if none is found
*/
private Method findBestExceptionHandlerMethod(Object handler, final Exception thrownException) {
final Clreplaced<?> handlerType = ClreplacedUtils.getUserClreplaced(handler);
final Clreplaced<? extends Throwable> thrownExceptionType = thrownException.getClreplaced();
Method handlerMethod = null;
Map<Clreplaced<? extends Throwable>, Method> handlers = this.exceptionHandlerCache.get(handlerType);
if (handlers != null) {
handlerMethod = handlers.get(thrownExceptionType);
if (handlerMethod != null) {
return (handlerMethod == NO_METHOD_FOUND ? null : handlerMethod);
}
} else {
handlers = new ConcurrentHashMap<Clreplaced<? extends Throwable>, Method>(16);
this.exceptionHandlerCache.put(handlerType, handlers);
}
final Map<Clreplaced<? extends Throwable>, Method> matchedHandlers = new HashMap<Clreplaced<? extends Throwable>, Method>();
ReflectionUtils.doWithMethods(handlerType, new ReflectionUtils.MethodCallback() {
@Override
public void doWith(Method method) {
method = ClreplacedUtils.getMostSpecificMethod(method, handlerType);
List<Clreplaced<? extends Throwable>> handledExceptions = getHandledExceptions(method);
for (Clreplaced<? extends Throwable> handledException : handledExceptions) {
if (handledException.isreplacedignableFrom(thrownExceptionType)) {
if (!matchedHandlers.containsKey(handledException)) {
matchedHandlers.put(handledException, method);
} else {
Method oldMappedMethod = matchedHandlers.get(handledException);
if (!oldMappedMethod.equals(method)) {
throw new IllegalStateException("Ambiguous exception handler mapped for " + handledException + "]: {" + oldMappedMethod + ", " + method + "}.");
}
}
}
}
}
});
handlerMethod = getBestMatchingMethod(matchedHandlers, thrownException);
handlers.put(thrownExceptionType, (handlerMethod == null ? NO_METHOD_FOUND : handlerMethod));
return handlerMethod;
}
/**
* Returns all the exception clreplacedes handled by the given method.
* <p>The default implementation looks for exceptions in the annotation,
* or - if that annotation element is empty - any exceptions listed in the method parameters if the method
* is annotated with {@code @ExceptionHandler}.
* @param method the method
* @return the handled exceptions
*/
@SuppressWarnings("unchecked")
protected List<Clreplaced<? extends Throwable>> getHandledExceptions(Method method) {
List<Clreplaced<? extends Throwable>> result = new ArrayList<Clreplaced<? extends Throwable>>();
ExceptionHandler exceptionHandler = AnnotationUtils.findAnnotation(method, ExceptionHandler.clreplaced);
if (exceptionHandler != null) {
if (!ObjectUtils.isEmpty(exceptionHandler.value())) {
result.addAll(Arrays.asList(exceptionHandler.value()));
} else {
for (Clreplaced<?> param : method.getParameterTypes()) {
if (Throwable.clreplaced.isreplacedignableFrom(param)) {
result.add((Clreplaced<? extends Throwable>) param);
}
}
}
}
return result;
}
/**
* Uses the {@link ExceptionDepthComparator} to find the best matching method.
* @return the best matching method, or {@code null} if none found
*/
private Method getBestMatchingMethod(Map<Clreplaced<? extends Throwable>, Method> resolverMethods, Exception thrownException) {
if (resolverMethods.isEmpty()) {
return null;
}
Clreplaced<? extends Throwable> closestMatch = ExceptionDepthComparator.findClosestMatch(resolverMethods.keySet(), thrownException);
Method method = resolverMethods.get(closestMatch);
return ((method == null) || (NO_METHOD_FOUND == method)) ? null : method;
}
/**
* Resolves the arguments for the given method. Delegates to {@link #resolveCommonArgument}.
*/
private Object[] resolveHandlerArguments(Method handlerMethod, Object handler, NativeWebRequest webRequest, Exception thrownException) throws Exception {
Clreplaced<?>[] paramTypes = handlerMethod.getParameterTypes();
Object[] args = new Object[paramTypes.length];
Clreplaced<?> handlerType = handler.getClreplaced();
for (int i = 0; i < args.length; i++) {
MethodParameter methodParam = new SynthesizingMethodParameter(handlerMethod, i);
GenericTypeResolver.resolveParameterType(methodParam, handlerType);
Clreplaced<?> paramType = methodParam.getParameterType();
Object argValue = resolveCommonArgument(methodParam, webRequest, thrownException);
if (argValue != WebArgumentResolver.UNRESOLVED) {
args[i] = argValue;
} else {
throw new IllegalStateException("Unsupported argument [" + paramType.getName() + "] for @ExceptionHandler method: " + handlerMethod);
}
}
return args;
}
/**
* Resolves common method arguments. Delegates to registered {@link #setCustomArgumentResolver(WebArgumentResolver)
* argumentResolvers} first, then checking {@link #resolveStandardArgument}.
* @param methodParameter the method parameter
* @param webRequest the request
* @param thrownException the exception thrown
* @return the argument value, or {@link WebArgumentResolver#UNRESOLVED}
*/
protected Object resolveCommonArgument(MethodParameter methodParameter, NativeWebRequest webRequest, Exception thrownException) throws Exception {
// Invoke custom argument resolvers if present...
if (this.customArgumentResolvers != null) {
for (WebArgumentResolver argumentResolver : this.customArgumentResolvers) {
Object value = argumentResolver.resolveArgument(methodParameter, webRequest);
if (value != WebArgumentResolver.UNRESOLVED) {
return value;
}
}
}
// Resolution of standard parameter types...
Clreplaced<?> paramType = methodParameter.getParameterType();
Object value = resolveStandardArgument(paramType, webRequest, thrownException);
if (value != WebArgumentResolver.UNRESOLVED && !ClreplacedUtils.isreplacedignableValue(paramType, value)) {
throw new IllegalStateException("Standard argument type [" + paramType.getName() + "] resolved to incompatible value of type [" + (value != null ? value.getClreplaced() : null) + "]. Consider declaring the argument type in a less specific fashion.");
}
return value;
}
/**
* Resolves standard method arguments. The default implementation handles {@link NativeWebRequest},
* {@link ServletRequest}, {@link ServletResponse}, {@link HttpSession}, {@link Principal},
* {@link Locale}, request {@link InputStream}, request {@link Reader}, response {@link OutputStream},
* response {@link Writer}, and the given {@code thrownException}.
* @param parameterType the method parameter type
* @param webRequest the request
* @param thrownException the exception thrown
* @return the argument value, or {@link WebArgumentResolver#UNRESOLVED}
*/
protected Object resolveStandardArgument(Clreplaced<?> parameterType, NativeWebRequest webRequest, Exception thrownException) throws Exception {
if (parameterType.isInstance(thrownException)) {
return thrownException;
} else if (WebRequest.clreplaced.isreplacedignableFrom(parameterType)) {
return webRequest;
}
HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.clreplaced);
HttpServletResponse response = webRequest.getNativeResponse(HttpServletResponse.clreplaced);
if (ServletRequest.clreplaced.isreplacedignableFrom(parameterType)) {
return request;
} else if (ServletResponse.clreplaced.isreplacedignableFrom(parameterType)) {
return response;
} else if (HttpSession.clreplaced.isreplacedignableFrom(parameterType)) {
return request.getSession();
} else if (Principal.clreplaced.isreplacedignableFrom(parameterType)) {
return request.getUserPrincipal();
} else if (Locale.clreplaced == parameterType) {
return RequestContextUtils.getLocale(request);
} else if (InputStream.clreplaced.isreplacedignableFrom(parameterType)) {
return request.getInputStream();
} else if (Reader.clreplaced.isreplacedignableFrom(parameterType)) {
return request.getReader();
} else if (OutputStream.clreplaced.isreplacedignableFrom(parameterType)) {
return response.getOutputStream();
} else if (Writer.clreplaced.isreplacedignableFrom(parameterType)) {
return response.getWriter();
} else {
return WebArgumentResolver.UNRESOLVED;
}
}
private Object doInvokeMethod(Method method, Object target, Object[] args) throws Exception {
ReflectionUtils.makeAccessible(method);
try {
return method.invoke(target, args);
} catch (InvocationTargetException ex) {
ReflectionUtils.rethrowException(ex.getTargetException());
}
throw new IllegalStateException("Should never get here");
}
@SuppressWarnings("unchecked")
private ModelAndView getModelAndView(Method handlerMethod, Object returnValue, ServletWebRequest webRequest) throws Exception {
ResponseStatus responseStatus = AnnotatedElementUtils.findMergedAnnotation(handlerMethod, ResponseStatus.clreplaced);
if (responseStatus != null) {
HttpStatus statusCode = responseStatus.code();
String reason = responseStatus.reason();
if (!StringUtils.hasText(reason)) {
webRequest.getResponse().setStatus(statusCode.value());
} else {
webRequest.getResponse().sendError(statusCode.value(), reason);
}
}
if (returnValue != null && AnnotationUtils.findAnnotation(handlerMethod, ResponseBody.clreplaced) != null) {
return handleResponseBody(returnValue, webRequest);
}
if (returnValue instanceof ModelAndView) {
return (ModelAndView) returnValue;
} else if (returnValue instanceof Model) {
return new ModelAndView().addAllObjects(((Model) returnValue).asMap());
} else if (returnValue instanceof Map) {
return new ModelAndView().addAllObjects((Map<String, Object>) returnValue);
} else if (returnValue instanceof View) {
return new ModelAndView((View) returnValue);
} else if (returnValue instanceof String) {
return new ModelAndView((String) returnValue);
} else if (returnValue == null) {
return new ModelAndView();
} else {
throw new IllegalArgumentException("Invalid handler method return value: " + returnValue);
}
}
@SuppressWarnings({ "unchecked", "rawtypes", "resource" })
private ModelAndView handleResponseBody(Object returnValue, ServletWebRequest webRequest) throws ServletException, IOException {
HttpInputMessage inputMessage = new ServletServerHttpRequest(webRequest.getRequest());
List<MediaType> acceptedMediaTypes = inputMessage.getHeaders().getAccept();
if (acceptedMediaTypes.isEmpty()) {
acceptedMediaTypes = Collections.singletonList(MediaType.ALL);
}
MediaType.sortByQualityValue(acceptedMediaTypes);
HttpOutputMessage outputMessage = new ServletServerHttpResponse(webRequest.getResponse());
Clreplaced<?> returnValueType = returnValue.getClreplaced();
if (this.messageConverters != null) {
for (MediaType acceptedMediaType : acceptedMediaTypes) {
for (HttpMessageConverter messageConverter : this.messageConverters) {
if (messageConverter.canWrite(returnValueType, acceptedMediaType)) {
messageConverter.write(returnValue, acceptedMediaType, outputMessage);
return new ModelAndView();
}
}
}
}
if (logger.isWarnEnabled()) {
logger.warn("Could not find HttpMessageConverter that supports return type [" + returnValueType + "] and " + acceptedMediaTypes);
}
return null;
}
}
18
Source : TestSupport.java
with Apache License 2.0
from exchange-core
with Apache License 2.0
from exchange-core
@Slf4j
public clreplaced TestSupport {
protected MockMvc mockMvc;
protected MediaType applicationJson = new MediaType(MediaType.APPLICATION_JSON.getType(), MediaType.APPLICATION_JSON.getSubtype(), Charset.forName("utf8"));
@PostConstruct
public void setup() throws Exception {
this.mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
// this.mockMvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).addFilters((servletRequest, servletResponse, filterChain) -> {
//
// log.info("servletRequest={}", servletRequest);
// log.info("servletResponse={}", servletResponse);
// log.info("filterChain={}", filterChain);
//
// }).build();
}
protected HttpMessageConverter mappingJackson2HttpMessageConverter;
@Autowired
protected WebApplicationContext webApplicationContext;
@Autowired
public void setConverters(HttpMessageConverters converters) {
mappingJackson2HttpMessageConverter = converters.getConverters().stream().filter(converter -> converter instanceof MappingJackson2HttpMessageConverter).findFirst().orElseThrow((() -> new IllegalStateException("the JSON message converter can not be null")));
}
protected String json(Object object) throws IOException {
MockHttpOutputMessage mockHttpOutputMessage = new MockHttpOutputMessage();
// noinspection unchecked
mappingJackson2HttpMessageConverter.write(object, MediaType.APPLICATION_JSON, mockHttpOutputMessage);
return mockHttpOutputMessage.getBodyreplacedtring();
}
}
18
Source : MessageConverterAddingPostProcessor.java
with BSD 3-Clause "New" or "Revised" License
from dhis2
with BSD 3-Clause "New" or "Revised" License
from dhis2
@Component
public clreplaced MessageConverterAddingPostProcessor implements BeanPostProcessor {
private HttpMessageConverter<?> messageConverter = new DataStreamSerializableMessageConverter();
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
return bean;
}
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
if (!(bean instanceof RequestMappingHandlerAdapter)) {
return bean;
}
RequestMappingHandlerAdapter handlerAdapter = (RequestMappingHandlerAdapter) bean;
List<HttpMessageConverter<?>> converters = handlerAdapter.getMessageConverters();
converters.add(0, messageConverter);
handlerAdapter.setMessageConverters(converters);
return handlerAdapter;
}
}
18
Source : RestConfig.java
with Apache License 2.0
from ctripcorp
with Apache License 2.0
from ctripcorp
@Bean
public HttpMessageConverters customConverters() {
try {
HttpMessageConverter<Message> converter = newCustomProtobufMessageConverter();
return new HttpMessageConverters(converter);
} catch (Exception e) {
throw new IllegalStateException("cannot construct custom protobuf converter", e);
}
}
18
Source : FeignConfig.java
with Apache License 2.0
from adorsys
with Apache License 2.0
from adorsys
@Bean
public Encoder feignEncoder(ObjectMapper objectMapper) {
HttpMessageConverter jacksonConverter = new MappingJackson2HttpMessageConverter(objectMapper);
ObjectFactory<HttpMessageConverters> objectFactory = () -> new HttpMessageConverters(jacksonConverter);
return new SpringEncoder(objectFactory);
}
17
Source : HttpMessageConvertersTests.java
with Apache License 2.0
from yuanmabiji
with Apache License 2.0
from yuanmabiji
@Test
public void convertersAreAddedToFormPartConverter() {
HttpMessageConverter<?> converter1 = mock(HttpMessageConverter.clreplaced);
HttpMessageConverter<?> converter2 = mock(HttpMessageConverter.clreplaced);
List<HttpMessageConverter<?>> converters = new HttpMessageConverters(converter1, converter2).getConverters();
List<HttpMessageConverter<?>> partConverters = extractFormPartConverters(converters);
replacedertThat(partConverters.get(0)).isEqualTo(converter1);
replacedertThat(partConverters.get(1)).isEqualTo(converter2);
}
17
Source : HypermediaAutoConfigurationTests.java
with Apache License 2.0
from yuanmabiji
with Apache License 2.0
from yuanmabiji
@Test
public void supportedMediaTypesOfTypeConstrainedConvertersIsCustomized() {
this.context = new AnnotationConfigWebApplicationContext();
this.context.setServletContext(new MockServletContext());
this.context.register(BaseConfig.clreplaced);
this.context.refresh();
RequestMappingHandlerAdapter handlerAdapter = this.context.getBean(RequestMappingHandlerAdapter.clreplaced);
for (HttpMessageConverter<?> converter : handlerAdapter.getMessageConverters()) {
if (converter instanceof TypeConstrainedMappingJackson2HttpMessageConverter) {
replacedertThat(converter.getSupportedMediaTypes()).contains(MediaType.APPLICATION_JSON, MediaTypes.HAL_JSON);
}
}
}
17
Source : RestTemplateBuilderTests.java
with Apache License 2.0
from yuanmabiji
with Apache License 2.0
from yuanmabiji
/**
* Tests for {@link RestTemplateBuilder}.
*
* @author Stephane Nicoll
* @author Phillip Webb
* @author Andy Wilkinson
* @author Dmytro Nosan
*/
public clreplaced RestTemplateBuilderTests {
private RestTemplateBuilder builder = new RestTemplateBuilder();
@Mock
private HttpMessageConverter<Object> messageConverter;
@Mock
private ClientHttpRequestInterceptor interceptor;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
}
@Test
public void createWhenCustomizersAreNullShouldThrowException() {
RestTemplateCustomizer[] customizers = null;
replacedertThatIllegalArgumentException().isThrownBy(() -> new RestTemplateBuilder(customizers)).withMessageContaining("Customizers must not be null");
}
@Test
public void createWithCustomizersShouldApplyCustomizers() {
RestTemplateCustomizer customizer = mock(RestTemplateCustomizer.clreplaced);
RestTemplate template = new RestTemplateBuilder(customizer).build();
verify(customizer).customize(template);
}
@Test
public void buildShouldDetectRequestFactory() {
RestTemplate restTemplate = this.builder.build();
replacedertThat(restTemplate.getRequestFactory()).isInstanceOf(HttpComponentsClientHttpRequestFactory.clreplaced);
}
@Test
public void detectRequestFactoryWhenFalseShouldDisableDetection() {
RestTemplate restTemplate = this.builder.detectRequestFactory(false).build();
replacedertThat(restTemplate.getRequestFactory()).isInstanceOf(SimpleClientHttpRequestFactory.clreplaced);
}
@Test
public void rootUriShouldApply() {
RestTemplate restTemplate = this.builder.rootUri("http://example.com").build();
MockRestServiceServer server = MockRestServiceServer.bindTo(restTemplate).build();
server.expect(requestTo("http://example.com/hello")).andRespond(withSuccess());
restTemplate.getForEnreplacedy("/hello", String.clreplaced);
server.verify();
}
@Test
public void rootUriShouldApplyAfterUriTemplateHandler() {
UriTemplateHandler uriTemplateHandler = mock(UriTemplateHandler.clreplaced);
RestTemplate template = this.builder.uriTemplateHandler(uriTemplateHandler).rootUri("http://example.com").build();
UriTemplateHandler handler = template.getUriTemplateHandler();
handler.expand("/hello");
replacedertThat(handler).isInstanceOf(RootUriTemplateHandler.clreplaced);
verify(uriTemplateHandler).expand("http://example.com/hello");
}
@Test
public void messageConvertersWhenConvertersAreNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.messageConverters((HttpMessageConverter<?>[]) null)).withMessageContaining("MessageConverters must not be null");
}
@Test
public void messageConvertersCollectionWhenConvertersAreNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.messageConverters((Set<HttpMessageConverter<?>>) null)).withMessageContaining("MessageConverters must not be null");
}
@Test
public void messageConvertersShouldApply() {
RestTemplate template = this.builder.messageConverters(this.messageConverter).build();
replacedertThat(template.getMessageConverters()).containsOnly(this.messageConverter);
}
@Test
public void messageConvertersShouldReplaceExisting() {
RestTemplate template = this.builder.messageConverters(new ResourceHttpMessageConverter()).messageConverters(Collections.singleton(this.messageConverter)).build();
replacedertThat(template.getMessageConverters()).containsOnly(this.messageConverter);
}
@Test
public void additionalMessageConvertersWhenConvertersAreNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.additionalMessageConverters((HttpMessageConverter<?>[]) null)).withMessageContaining("MessageConverters must not be null");
}
@Test
public void additionalMessageConvertersCollectionWhenConvertersAreNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.additionalMessageConverters((Set<HttpMessageConverter<?>>) null)).withMessageContaining("MessageConverters must not be null");
}
@Test
public void additionalMessageConvertersShouldAddToExisting() {
HttpMessageConverter<?> resourceConverter = new ResourceHttpMessageConverter();
RestTemplate template = this.builder.messageConverters(resourceConverter).additionalMessageConverters(this.messageConverter).build();
replacedertThat(template.getMessageConverters()).containsOnly(resourceConverter, this.messageConverter);
}
@Test
public void defaultMessageConvertersShouldSetDefaultList() {
RestTemplate template = new RestTemplate(Collections.singletonList(new StringHttpMessageConverter()));
this.builder.defaultMessageConverters().configure(template);
replacedertThat(template.getMessageConverters()).hreplacedameSizeAs(new RestTemplate().getMessageConverters());
}
@Test
public void defaultMessageConvertersShouldClearExisting() {
RestTemplate template = new RestTemplate(Collections.singletonList(new StringHttpMessageConverter()));
this.builder.additionalMessageConverters(this.messageConverter).defaultMessageConverters().configure(template);
replacedertThat(template.getMessageConverters()).hreplacedameSizeAs(new RestTemplate().getMessageConverters());
}
@Test
public void interceptorsWhenInterceptorsAreNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.interceptors((ClientHttpRequestInterceptor[]) null)).withMessageContaining("interceptors must not be null");
}
@Test
public void interceptorsCollectionWhenInterceptorsAreNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.interceptors((Set<ClientHttpRequestInterceptor>) null)).withMessageContaining("interceptors must not be null");
}
@Test
public void interceptorsShouldApply() {
RestTemplate template = this.builder.interceptors(this.interceptor).build();
replacedertThat(template.getInterceptors()).containsOnly(this.interceptor);
}
@Test
public void interceptorsShouldReplaceExisting() {
RestTemplate template = this.builder.interceptors(mock(ClientHttpRequestInterceptor.clreplaced)).interceptors(Collections.singleton(this.interceptor)).build();
replacedertThat(template.getInterceptors()).containsOnly(this.interceptor);
}
@Test
public void additionalInterceptorsWhenInterceptorsAreNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.additionalInterceptors((ClientHttpRequestInterceptor[]) null)).withMessageContaining("interceptors must not be null");
}
@Test
public void additionalInterceptorsCollectionWhenInterceptorsAreNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.additionalInterceptors((Set<ClientHttpRequestInterceptor>) null)).withMessageContaining("interceptors must not be null");
}
@Test
public void additionalInterceptorsShouldAddToExisting() {
ClientHttpRequestInterceptor interceptor = mock(ClientHttpRequestInterceptor.clreplaced);
RestTemplate template = this.builder.interceptors(interceptor).additionalInterceptors(this.interceptor).build();
replacedertThat(template.getInterceptors()).containsOnly(interceptor, this.interceptor);
}
@Test
public void requestFactoryClreplacedWhenFactoryIsNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.requestFactory((Clreplaced<ClientHttpRequestFactory>) null)).withMessageContaining("RequestFactory must not be null");
}
@Test
public void requestFactoryClreplacedShouldApply() {
RestTemplate template = this.builder.requestFactory(SimpleClientHttpRequestFactory.clreplaced).build();
replacedertThat(template.getRequestFactory()).isInstanceOf(SimpleClientHttpRequestFactory.clreplaced);
}
@Test
public void requestFactoryPackagePrivateClreplacedShouldApply() {
RestTemplate template = this.builder.requestFactory(TestClientHttpRequestFactory.clreplaced).build();
replacedertThat(template.getRequestFactory()).isInstanceOf(TestClientHttpRequestFactory.clreplaced);
}
@Test
public void requestFactoryWhenSupplierIsNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.requestFactory((Supplier<ClientHttpRequestFactory>) null)).withMessageContaining("RequestFactory Supplier must not be null");
}
@Test
public void requestFactoryShouldApply() {
ClientHttpRequestFactory requestFactory = mock(ClientHttpRequestFactory.clreplaced);
RestTemplate template = this.builder.requestFactory(() -> requestFactory).build();
replacedertThat(template.getRequestFactory()).isSameAs(requestFactory);
}
@Test
public void uriTemplateHandlerWhenHandlerIsNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.uriTemplateHandler(null)).withMessageContaining("UriTemplateHandler must not be null");
}
@Test
public void uriTemplateHandlerShouldApply() {
UriTemplateHandler uriTemplateHandler = mock(UriTemplateHandler.clreplaced);
RestTemplate template = this.builder.uriTemplateHandler(uriTemplateHandler).build();
replacedertThat(template.getUriTemplateHandler()).isSameAs(uriTemplateHandler);
}
@Test
public void errorHandlerWhenHandlerIsNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.errorHandler(null)).withMessageContaining("ErrorHandler must not be null");
}
@Test
public void errorHandlerShouldApply() {
ResponseErrorHandler errorHandler = mock(ResponseErrorHandler.clreplaced);
RestTemplate template = this.builder.errorHandler(errorHandler).build();
replacedertThat(template.getErrorHandler()).isSameAs(errorHandler);
}
@Test
public void basicAuthenticationShouldApply() {
RestTemplate template = this.builder.basicAuthentication("spring", "boot").build();
ClientHttpRequestInterceptor interceptor = template.getInterceptors().get(0);
replacedertThat(interceptor).isInstanceOf(BasicAuthenticationInterceptor.clreplaced);
replacedertThat(interceptor).extracting("username").containsExactly("spring");
replacedertThat(interceptor).extracting("preplacedword").containsExactly("boot");
}
@Test
@Deprecated
public void basicAuthorizationShouldApply() {
RestTemplate template = this.builder.basicAuthorization("spring", "boot").build();
ClientHttpRequestInterceptor interceptor = template.getInterceptors().get(0);
replacedertThat(interceptor).isInstanceOf(BasicAuthenticationInterceptor.clreplaced);
replacedertThat(interceptor).extracting("username").containsExactly("spring");
replacedertThat(interceptor).extracting("preplacedword").containsExactly("boot");
}
@Test
public void customizersWhenCustomizersAreNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.customizers((RestTemplateCustomizer[]) null)).withMessageContaining("RestTemplateCustomizers must not be null");
}
@Test
public void customizersCollectionWhenCustomizersAreNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.customizers((Set<RestTemplateCustomizer>) null)).withMessageContaining("RestTemplateCustomizers must not be null");
}
@Test
public void customizersShouldApply() {
RestTemplateCustomizer customizer = mock(RestTemplateCustomizer.clreplaced);
RestTemplate template = this.builder.customizers(customizer).build();
verify(customizer).customize(template);
}
@Test
public void customizersShouldBeAppliedLast() {
RestTemplate template = spy(new RestTemplate());
this.builder.additionalCustomizers((restTemplate) -> verify(restTemplate).setRequestFactory(any(ClientHttpRequestFactory.clreplaced)));
this.builder.configure(template);
}
@Test
public void customizersShouldReplaceExisting() {
RestTemplateCustomizer customizer1 = mock(RestTemplateCustomizer.clreplaced);
RestTemplateCustomizer customizer2 = mock(RestTemplateCustomizer.clreplaced);
RestTemplate template = this.builder.customizers(customizer1).customizers(Collections.singleton(customizer2)).build();
verifyZeroInteractions(customizer1);
verify(customizer2).customize(template);
}
@Test
public void additionalCustomizersWhenCustomizersAreNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.additionalCustomizers((RestTemplateCustomizer[]) null)).withMessageContaining("RestTemplateCustomizers must not be null");
}
@Test
public void additionalCustomizersCollectionWhenCustomizersAreNullShouldThrowException() {
replacedertThatIllegalArgumentException().isThrownBy(() -> this.builder.additionalCustomizers((Set<RestTemplateCustomizer>) null)).withMessageContaining("RestTemplateCustomizers must not be null");
}
@Test
public void additionalCustomizersShouldAddToExisting() {
RestTemplateCustomizer customizer1 = mock(RestTemplateCustomizer.clreplaced);
RestTemplateCustomizer customizer2 = mock(RestTemplateCustomizer.clreplaced);
RestTemplate template = this.builder.customizers(customizer1).additionalCustomizers(customizer2).build();
verify(customizer1).customize(template);
verify(customizer2).customize(template);
}
@Test
public void customizerShouldBeAppliedAtTheEnd() {
ResponseErrorHandler errorHandler = mock(ResponseErrorHandler.clreplaced);
ClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory();
this.builder.interceptors(this.interceptor).messageConverters(this.messageConverter).rootUri("http://localhost:8080").errorHandler(errorHandler).basicAuthentication("spring", "boot").requestFactory(() -> requestFactory).customizers((restTemplate) -> {
replacedertThat(restTemplate.getInterceptors()).hreplacedize(2).contains(this.interceptor).anyMatch((ic) -> ic instanceof BasicAuthenticationInterceptor);
replacedertThat(restTemplate.getMessageConverters()).contains(this.messageConverter);
replacedertThat(restTemplate.getUriTemplateHandler()).isInstanceOf(RootUriTemplateHandler.clreplaced);
replacedertThat(restTemplate.getErrorHandler()).isEqualTo(errorHandler);
ClientHttpRequestFactory actualRequestFactory = restTemplate.getRequestFactory();
replacedertThat(actualRequestFactory).isInstanceOf(InterceptingClientHttpRequestFactory.clreplaced);
replacedertThat(actualRequestFactory).hasFieldOrPropertyWithValue("requestFactory", requestFactory);
}).build();
}
@Test
public void buildShouldReturnRestTemplate() {
RestTemplate template = this.builder.build();
replacedertThat(template.getClreplaced()).isEqualTo(RestTemplate.clreplaced);
}
@Test
public void buildClreplacedShouldReturnClreplacedInstance() {
RestTemplateSubclreplaced template = this.builder.build(RestTemplateSubclreplaced.clreplaced);
replacedertThat(template.getClreplaced()).isEqualTo(RestTemplateSubclreplaced.clreplaced);
}
@Test
public void configureShouldApply() {
RestTemplate template = new RestTemplate();
this.builder.configure(template);
replacedertThat(template.getRequestFactory()).isInstanceOf(HttpComponentsClientHttpRequestFactory.clreplaced);
}
@Test
public void connectTimeoutCanBeNullToUseDefault() {
ClientHttpRequestFactory requestFactory = this.builder.requestFactory(SimpleClientHttpRequestFactory.clreplaced).setConnectTimeout(null).build().getRequestFactory();
replacedertThat(requestFactory).hasFieldOrPropertyWithValue("connectTimeout", -1);
}
@Test
public void readTimeoutCanBeNullToUseDefault() {
ClientHttpRequestFactory requestFactory = this.builder.requestFactory(SimpleClientHttpRequestFactory.clreplaced).setReadTimeout(null).build().getRequestFactory();
replacedertThat(requestFactory).hasFieldOrPropertyWithValue("readTimeout", -1);
}
@Test
public void connectTimeoutCanBeConfiguredOnHttpComponentsRequestFactory() {
ClientHttpRequestFactory requestFactory = this.builder.requestFactory(HttpComponentsClientHttpRequestFactory.clreplaced).setConnectTimeout(Duration.ofMillis(1234)).build().getRequestFactory();
replacedertThat(((RequestConfig) ReflectionTestUtils.getField(requestFactory, "requestConfig")).getConnectTimeout()).isEqualTo(1234);
}
@Test
public void readTimeoutCanBeConfiguredOnHttpComponentsRequestFactory() {
ClientHttpRequestFactory requestFactory = this.builder.requestFactory(HttpComponentsClientHttpRequestFactory.clreplaced).setReadTimeout(Duration.ofMillis(1234)).build().getRequestFactory();
replacedertThat(((RequestConfig) ReflectionTestUtils.getField(requestFactory, "requestConfig")).getSocketTimeout()).isEqualTo(1234);
}
@Test
public void connectTimeoutCanBeConfiguredOnSimpleRequestFactory() {
ClientHttpRequestFactory requestFactory = this.builder.requestFactory(SimpleClientHttpRequestFactory.clreplaced).setConnectTimeout(Duration.ofMillis(1234)).build().getRequestFactory();
replacedertThat(requestFactory).hasFieldOrPropertyWithValue("connectTimeout", 1234);
}
@Test
public void readTimeoutCanBeConfiguredOnSimpleRequestFactory() {
ClientHttpRequestFactory requestFactory = this.builder.requestFactory(SimpleClientHttpRequestFactory.clreplaced).setReadTimeout(Duration.ofMillis(1234)).build().getRequestFactory();
replacedertThat(requestFactory).hasFieldOrPropertyWithValue("readTimeout", 1234);
}
@Test
public void connectTimeoutCanBeConfiguredOnOkHttp3RequestFactory() {
ClientHttpRequestFactory requestFactory = this.builder.requestFactory(OkHttp3ClientHttpRequestFactory.clreplaced).setConnectTimeout(Duration.ofMillis(1234)).build().getRequestFactory();
replacedertThat(ReflectionTestUtils.getField(ReflectionTestUtils.getField(requestFactory, "client"), "connectTimeout")).isEqualTo(1234);
}
@Test
public void readTimeoutCanBeConfiguredOnOkHttp3RequestFactory() {
ClientHttpRequestFactory requestFactory = this.builder.requestFactory(OkHttp3ClientHttpRequestFactory.clreplaced).setReadTimeout(Duration.ofMillis(1234)).build().getRequestFactory();
replacedertThat(ReflectionTestUtils.getField(ReflectionTestUtils.getField(requestFactory, "client"), "readTimeout")).isEqualTo(1234);
}
@Test
public void connectTimeoutCanBeConfiguredOnAWrappedRequestFactory() {
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
this.builder.requestFactory(() -> new BufferingClientHttpRequestFactory(requestFactory)).setConnectTimeout(Duration.ofMillis(1234)).build();
replacedertThat(requestFactory).hasFieldOrPropertyWithValue("connectTimeout", 1234);
}
@Test
public void readTimeoutCanBeConfiguredOnAWrappedRequestFactory() {
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
this.builder.requestFactory(() -> new BufferingClientHttpRequestFactory(requestFactory)).setReadTimeout(Duration.ofMillis(1234)).build();
replacedertThat(requestFactory).hasFieldOrPropertyWithValue("readTimeout", 1234);
}
@Test
public void unwrappingDoesNotAffectRequestFactoryThatIsSetOnTheBuiltTemplate() {
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
RestTemplate template = this.builder.requestFactory(() -> new BufferingClientHttpRequestFactory(requestFactory)).build();
replacedertThat(template.getRequestFactory()).isInstanceOf(BufferingClientHttpRequestFactory.clreplaced);
}
@Test
@SuppressWarnings("deprecation")
public void connectTimeoutCanBeSetWithInteger() {
ClientHttpRequestFactory requestFactory = this.builder.requestFactory(SimpleClientHttpRequestFactory.clreplaced).setConnectTimeout(1234).build().getRequestFactory();
replacedertThat(requestFactory).hasFieldOrPropertyWithValue("connectTimeout", 1234);
}
@Test
@SuppressWarnings("deprecation")
public void readTimeoutCanBeSetWithInteger() {
ClientHttpRequestFactory requestFactory = this.builder.requestFactory(SimpleClientHttpRequestFactory.clreplaced).setReadTimeout(1234).build().getRequestFactory();
replacedertThat(requestFactory).hasFieldOrPropertyWithValue("readTimeout", 1234);
}
public static clreplaced RestTemplateSubclreplaced extends RestTemplate {
}
static clreplaced TestClientHttpRequestFactory extends SimpleClientHttpRequestFactory {
}
}
17
Source : HttpEntityMethodProcessorMockTests.java
with MIT License
from Vip-Augus
with MIT License
from Vip-Augus
/**
* Test fixture for {@link HttpEnreplacedyMethodProcessor} delegating to a mock
* {@link HttpMessageConverter}.
*
* <p>Also see {@link HttpEnreplacedyMethodProcessorTests}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
* @author Brian Clozel
*/
public clreplaced HttpEnreplacedyMethodProcessorMockTests {
private static final ZoneId GMT = ZoneId.of("GMT");
private HttpEnreplacedyMethodProcessor processor;
private HttpMessageConverter<String> stringHttpMessageConverter;
private HttpMessageConverter<Resource> resourceMessageConverter;
private HttpMessageConverter<Object> resourceRegionMessageConverter;
private MethodParameter paramHttpEnreplacedy;
private MethodParameter paramRequestEnreplacedy;
private MethodParameter paramResponseEnreplacedy;
private MethodParameter paramInt;
private MethodParameter returnTypeResponseEnreplacedy;
private MethodParameter returnTypeResponseEnreplacedyProduces;
private MethodParameter returnTypeResponseEnreplacedyResource;
private MethodParameter returnTypeHttpEnreplacedy;
private MethodParameter returnTypeHttpEnreplacedySubclreplaced;
private MethodParameter returnTypeInt;
private ModelAndViewContainer mavContainer;
private MockHttpServletRequest servletRequest;
private MockHttpServletResponse servletResponse;
private ServletWebRequest webRequest;
@Before
@SuppressWarnings("unchecked")
public void setup() throws Exception {
stringHttpMessageConverter = mock(HttpMessageConverter.clreplaced);
given(stringHttpMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(TEXT_PLAIN));
resourceMessageConverter = mock(HttpMessageConverter.clreplaced);
given(resourceMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.ALL));
resourceRegionMessageConverter = mock(HttpMessageConverter.clreplaced);
given(resourceRegionMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.ALL));
processor = new HttpEnreplacedyMethodProcessor(Arrays.asList(stringHttpMessageConverter, resourceMessageConverter, resourceRegionMessageConverter));
Method handle1 = getClreplaced().getMethod("handle1", HttpEnreplacedy.clreplaced, ResponseEnreplacedy.clreplaced, Integer.TYPE, RequestEnreplacedy.clreplaced);
paramHttpEnreplacedy = new MethodParameter(handle1, 0);
paramRequestEnreplacedy = new MethodParameter(handle1, 3);
paramResponseEnreplacedy = new MethodParameter(handle1, 1);
paramInt = new MethodParameter(handle1, 2);
returnTypeResponseEnreplacedy = new MethodParameter(handle1, -1);
returnTypeResponseEnreplacedyProduces = new MethodParameter(getClreplaced().getMethod("handle4"), -1);
returnTypeHttpEnreplacedy = new MethodParameter(getClreplaced().getMethod("handle2", HttpEnreplacedy.clreplaced), -1);
returnTypeHttpEnreplacedySubclreplaced = new MethodParameter(getClreplaced().getMethod("handle2x", HttpEnreplacedy.clreplaced), -1);
returnTypeInt = new MethodParameter(getClreplaced().getMethod("handle3"), -1);
returnTypeResponseEnreplacedyResource = new MethodParameter(getClreplaced().getMethod("handle5"), -1);
mavContainer = new ModelAndViewContainer();
servletRequest = new MockHttpServletRequest("GET", "/foo");
servletResponse = new MockHttpServletResponse();
webRequest = new ServletWebRequest(servletRequest, servletResponse);
}
@Test
public void supportsParameter() {
replacedertTrue("HttpEnreplacedy parameter not supported", processor.supportsParameter(paramHttpEnreplacedy));
replacedertTrue("RequestEnreplacedy parameter not supported", processor.supportsParameter(paramRequestEnreplacedy));
replacedertFalse("ResponseEnreplacedy parameter supported", processor.supportsParameter(paramResponseEnreplacedy));
replacedertFalse("non-enreplacedy parameter supported", processor.supportsParameter(paramInt));
}
@Test
public void supportsReturnType() {
replacedertTrue("ResponseEnreplacedy return type not supported", processor.supportsReturnType(returnTypeResponseEnreplacedy));
replacedertTrue("HttpEnreplacedy return type not supported", processor.supportsReturnType(returnTypeHttpEnreplacedy));
replacedertTrue("Custom HttpEnreplacedy subclreplaced not supported", processor.supportsReturnType(returnTypeHttpEnreplacedySubclreplaced));
replacedertFalse("RequestEnreplacedy parameter supported", processor.supportsReturnType(paramRequestEnreplacedy));
replacedertFalse("non-ResponseBody return type supported", processor.supportsReturnType(returnTypeInt));
}
@Test
public void shouldResolveHttpEnreplacedyArgument() throws Exception {
String body = "Foo";
MediaType contentType = TEXT_PLAIN;
servletRequest.addHeader("Content-Type", contentType.toString());
servletRequest.setContent(body.getBytes(StandardCharsets.UTF_8));
given(stringHttpMessageConverter.canRead(String.clreplaced, contentType)).willReturn(true);
given(stringHttpMessageConverter.read(eq(String.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(body);
Object result = processor.resolveArgument(paramHttpEnreplacedy, mavContainer, webRequest, null);
replacedertTrue(result instanceof HttpEnreplacedy);
replacedertFalse("The requestHandled flag shouldn't change", mavContainer.isRequestHandled());
replacedertEquals("Invalid argument", body, ((HttpEnreplacedy<?>) result).getBody());
}
@Test
public void shouldResolveRequestEnreplacedyArgument() throws Exception {
String body = "Foo";
MediaType contentType = TEXT_PLAIN;
servletRequest.addHeader("Content-Type", contentType.toString());
servletRequest.setMethod("GET");
servletRequest.setServerName("www.example.com");
servletRequest.setServerPort(80);
servletRequest.setRequestURI("/path");
servletRequest.setContent(body.getBytes(StandardCharsets.UTF_8));
given(stringHttpMessageConverter.canRead(String.clreplaced, contentType)).willReturn(true);
given(stringHttpMessageConverter.read(eq(String.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(body);
Object result = processor.resolveArgument(paramRequestEnreplacedy, mavContainer, webRequest, null);
replacedertTrue(result instanceof RequestEnreplacedy);
replacedertFalse("The requestHandled flag shouldn't change", mavContainer.isRequestHandled());
RequestEnreplacedy<?> requestEnreplacedy = (RequestEnreplacedy<?>) result;
replacedertEquals("Invalid method", HttpMethod.GET, requestEnreplacedy.getMethod());
// using default port (which is 80), so do not need to append the port (-1 means ignore)
URI uri = new URI("http", null, "www.example.com", -1, "/path", null, null);
replacedertEquals("Invalid url", uri, requestEnreplacedy.getUrl());
replacedertEquals("Invalid argument", body, requestEnreplacedy.getBody());
}
@Test
public void shouldFailResolvingWhenConverterCannotRead() throws Exception {
MediaType contentType = TEXT_PLAIN;
servletRequest.setMethod("POST");
servletRequest.addHeader("Content-Type", contentType.toString());
given(stringHttpMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(contentType));
given(stringHttpMessageConverter.canRead(String.clreplaced, contentType)).willReturn(false);
replacedertThatExceptionOfType(HttpMediaTypeNotSupportedException.clreplaced).isThrownBy(() -> processor.resolveArgument(paramHttpEnreplacedy, mavContainer, webRequest, null));
}
@Test
public void shouldFailResolvingWhenContentTypeNotSupported() throws Exception {
servletRequest.setMethod("POST");
servletRequest.setContent("some content".getBytes(StandardCharsets.UTF_8));
replacedertThatExceptionOfType(HttpMediaTypeNotSupportedException.clreplaced).isThrownBy(() -> processor.resolveArgument(paramHttpEnreplacedy, mavContainer, webRequest, null));
}
@Test
public void shouldHandleReturnValue() throws Exception {
String body = "Foo";
ResponseEnreplacedy<String> returnValue = new ResponseEnreplacedy<>(body, HttpStatus.OK);
MediaType accepted = TEXT_PLAIN;
servletRequest.addHeader("Accept", accepted.toString());
initStringMessageConversion(accepted);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertTrue(mavContainer.isRequestHandled());
verify(stringHttpMessageConverter).write(eq(body), eq(accepted), isA(HttpOutputMessage.clreplaced));
}
@Test
public void shouldHandleReturnValueWithProducibleMediaType() throws Exception {
String body = "Foo";
ResponseEnreplacedy<String> returnValue = new ResponseEnreplacedy<>(body, HttpStatus.OK);
servletRequest.addHeader("Accept", "text/*");
servletRequest.setAttribute(PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE, Collections.singleton(MediaType.TEXT_HTML));
given(stringHttpMessageConverter.canWrite(String.clreplaced, MediaType.TEXT_HTML)).willReturn(true);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedyProduces, mavContainer, webRequest);
replacedertTrue(mavContainer.isRequestHandled());
verify(stringHttpMessageConverter).write(eq(body), eq(MediaType.TEXT_HTML), isA(HttpOutputMessage.clreplaced));
}
@Test
@SuppressWarnings("unchecked")
public void shouldHandleReturnValueWithResponseBodyAdvice() throws Exception {
servletRequest.addHeader("Accept", "text/*");
servletRequest.setAttribute(PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE, Collections.singleton(MediaType.TEXT_HTML));
ResponseEnreplacedy<String> returnValue = new ResponseEnreplacedy<>(HttpStatus.OK);
ResponseBodyAdvice<String> advice = mock(ResponseBodyAdvice.clreplaced);
given(advice.supports(any(), any())).willReturn(true);
given(advice.beforeBodyWrite(any(), any(), any(), any(), any(), any())).willReturn("Foo");
HttpEnreplacedyMethodProcessor processor = new HttpEnreplacedyMethodProcessor(Collections.singletonList(stringHttpMessageConverter), null, Collections.singletonList(advice));
reset(stringHttpMessageConverter);
given(stringHttpMessageConverter.canWrite(String.clreplaced, MediaType.TEXT_HTML)).willReturn(true);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertTrue(mavContainer.isRequestHandled());
verify(stringHttpMessageConverter).write(eq("Foo"), eq(MediaType.TEXT_HTML), isA(HttpOutputMessage.clreplaced));
}
@Test
public void shouldFailHandlingWhenContentTypeNotSupported() throws Exception {
String body = "Foo";
ResponseEnreplacedy<String> returnValue = new ResponseEnreplacedy<>(body, HttpStatus.OK);
MediaType accepted = MediaType.APPLICATION_ATOM_XML;
servletRequest.addHeader("Accept", accepted.toString());
given(stringHttpMessageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(stringHttpMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(TEXT_PLAIN));
replacedertThatExceptionOfType(HttpMediaTypeNotAcceptableException.clreplaced).isThrownBy(() -> processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest));
}
@Test
public void shouldFailHandlingWhenConverterCannotWrite() throws Exception {
String body = "Foo";
ResponseEnreplacedy<String> returnValue = new ResponseEnreplacedy<>(body, HttpStatus.OK);
MediaType accepted = TEXT_PLAIN;
servletRequest.addHeader("Accept", accepted.toString());
given(stringHttpMessageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(stringHttpMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(TEXT_PLAIN));
given(stringHttpMessageConverter.canWrite(String.clreplaced, accepted)).willReturn(false);
replacedertThatExceptionOfType(HttpMediaTypeNotAcceptableException.clreplaced).isThrownBy(() -> processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedyProduces, mavContainer, webRequest));
}
// SPR-9142
@Test
public void shouldFailHandlingWhenAcceptHeaderIllegal() throws Exception {
ResponseEnreplacedy<String> returnValue = new ResponseEnreplacedy<>("Body", HttpStatus.ACCEPTED);
servletRequest.addHeader("Accept", "01");
replacedertThatExceptionOfType(HttpMediaTypeNotAcceptableException.clreplaced).isThrownBy(() -> processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest));
}
@Test
public void shouldHandleResponseHeaderNoBody() throws Exception {
HttpHeaders headers = new HttpHeaders();
headers.set("headerName", "headerValue");
ResponseEnreplacedy<String> returnValue = new ResponseEnreplacedy<>(headers, HttpStatus.ACCEPTED);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertTrue(mavContainer.isRequestHandled());
replacedertEquals("headerValue", servletResponse.getHeader("headerName"));
}
@Test
public void shouldHandleResponseHeaderAndBody() throws Exception {
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.set("header", "headerValue");
ResponseEnreplacedy<String> returnValue = new ResponseEnreplacedy<>("body", responseHeaders, HttpStatus.ACCEPTED);
initStringMessageConversion(TEXT_PLAIN);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
ArgumentCaptor<HttpOutputMessage> outputMessage = ArgumentCaptor.forClreplaced(HttpOutputMessage.clreplaced);
verify(stringHttpMessageConverter).write(eq("body"), eq(TEXT_PLAIN), outputMessage.capture());
replacedertTrue(mavContainer.isRequestHandled());
replacedertEquals("headerValue", outputMessage.getValue().getHeaders().get("header").get(0));
}
@Test
public void shouldHandleLastModifiedWithHttp304() throws Exception {
long currentTime = new Date().getTime();
long oneMinuteAgo = currentTime - (1000 * 60);
ZonedDateTime dateTime = ofEpochMilli(currentTime).atZone(GMT);
servletRequest.addHeader(HttpHeaders.IF_MODIFIED_SINCE, RFC_1123_DATE_TIME.format(dateTime));
ResponseEnreplacedy<String> returnValue = ResponseEnreplacedy.ok().lastModified(oneMinuteAgo).body("body");
initStringMessageConversion(TEXT_PLAIN);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertConditionalResponse(HttpStatus.NOT_MODIFIED, null, null, oneMinuteAgo);
}
@Test
public void handleEtagWithHttp304() throws Exception {
String etagValue = "\"deadb33f8badf00d\"";
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, etagValue);
ResponseEnreplacedy<String> returnValue = ResponseEnreplacedy.ok().eTag(etagValue).body("body");
initStringMessageConversion(TEXT_PLAIN);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertConditionalResponse(HttpStatus.NOT_MODIFIED, null, etagValue, -1);
}
// SPR-14559
@Test
public void shouldHandleInvalidIfNoneMatchWithHttp200() throws Exception {
String etagValue = "\"deadb33f8badf00d\"";
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, "unquoted");
ResponseEnreplacedy<String> returnValue = ResponseEnreplacedy.ok().eTag(etagValue).body("body");
initStringMessageConversion(TEXT_PLAIN);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertConditionalResponse(HttpStatus.OK, "body", etagValue, -1);
}
@Test
public void shouldHandleETagAndLastModifiedWithHttp304() throws Exception {
long currentTime = new Date().getTime();
long oneMinuteAgo = currentTime - (1000 * 60);
String etagValue = "\"deadb33f8badf00d\"";
ZonedDateTime dateTime = ofEpochMilli(currentTime).atZone(GMT);
servletRequest.addHeader(HttpHeaders.IF_MODIFIED_SINCE, RFC_1123_DATE_TIME.format(dateTime));
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, etagValue);
ResponseEnreplacedy<String> returnValue = ResponseEnreplacedy.ok().eTag(etagValue).lastModified(oneMinuteAgo).body("body");
initStringMessageConversion(TEXT_PLAIN);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertConditionalResponse(HttpStatus.NOT_MODIFIED, null, etagValue, oneMinuteAgo);
}
@Test
public void shouldHandleNotModifiedResponse() throws Exception {
long currentTime = new Date().getTime();
long oneMinuteAgo = currentTime - (1000 * 60);
String etagValue = "\"deadb33f8badf00d\"";
ResponseEnreplacedy<String> returnValue = ResponseEnreplacedy.status(HttpStatus.NOT_MODIFIED).eTag(etagValue).lastModified(oneMinuteAgo).body("body");
initStringMessageConversion(TEXT_PLAIN);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertConditionalResponse(HttpStatus.NOT_MODIFIED, null, etagValue, oneMinuteAgo);
}
@Test
public void shouldHandleChangedETagAndLastModified() throws Exception {
long currentTime = new Date().getTime();
long oneMinuteAgo = currentTime - (1000 * 60);
String etagValue = "\"deadb33f8badf00d\"";
String changedEtagValue = "\"changed-etag-value\"";
ZonedDateTime dateTime = ofEpochMilli(currentTime).atZone(GMT);
servletRequest.addHeader(HttpHeaders.IF_MODIFIED_SINCE, RFC_1123_DATE_TIME.format(dateTime));
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, etagValue);
ResponseEnreplacedy<String> returnValue = ResponseEnreplacedy.ok().eTag(changedEtagValue).lastModified(oneMinuteAgo).body("body");
initStringMessageConversion(TEXT_PLAIN);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertConditionalResponse(HttpStatus.OK, null, changedEtagValue, oneMinuteAgo);
}
// SPR-13496
@Test
public void shouldHandleConditionalRequestIfNoneMatchWildcard() throws Exception {
String wildcardValue = "*";
String etagValue = "\"some-etag\"";
servletRequest.setMethod("POST");
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, wildcardValue);
ResponseEnreplacedy<String> returnValue = ResponseEnreplacedy.ok().eTag(etagValue).body("body");
initStringMessageConversion(TEXT_PLAIN);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertConditionalResponse(HttpStatus.OK, "body", etagValue, -1);
}
// SPR-13626
@Test
public void shouldHandleGetIfNoneMatchWildcard() throws Exception {
String wildcardValue = "*";
String etagValue = "\"some-etag\"";
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, wildcardValue);
ResponseEnreplacedy<String> returnValue = ResponseEnreplacedy.ok().eTag(etagValue).body("body");
initStringMessageConversion(TEXT_PLAIN);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertConditionalResponse(HttpStatus.OK, "body", etagValue, -1);
}
// SPR-13626
@Test
public void shouldHandleIfNoneMatchIfMatch() throws Exception {
String etagValue = "\"some-etag\"";
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, etagValue);
servletRequest.addHeader(HttpHeaders.IF_MATCH, "ifmatch");
ResponseEnreplacedy<String> returnValue = ResponseEnreplacedy.ok().eTag(etagValue).body("body");
initStringMessageConversion(TEXT_PLAIN);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertConditionalResponse(HttpStatus.NOT_MODIFIED, null, etagValue, -1);
}
// SPR-13626
@Test
public void shouldHandleIfNoneMatchIfUnmodifiedSince() throws Exception {
String etagValue = "\"some-etag\"";
servletRequest.addHeader(HttpHeaders.IF_NONE_MATCH, etagValue);
ZonedDateTime dateTime = ofEpochMilli(new Date().getTime()).atZone(GMT);
servletRequest.addHeader(HttpHeaders.IF_UNMODIFIED_SINCE, RFC_1123_DATE_TIME.format(dateTime));
ResponseEnreplacedy<String> returnValue = ResponseEnreplacedy.ok().eTag(etagValue).body("body");
initStringMessageConversion(TEXT_PLAIN);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertConditionalResponse(HttpStatus.NOT_MODIFIED, null, etagValue, -1);
}
@Test
public void shouldHandleResource() throws Exception {
ResponseEnreplacedy<Resource> returnValue = ResponseEnreplacedy.ok(new ByteArrayResource("Content".getBytes(StandardCharsets.UTF_8)));
given(resourceMessageConverter.canWrite(ByteArrayResource.clreplaced, null)).willReturn(true);
given(resourceMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.ALL));
given(resourceMessageConverter.canWrite(ByteArrayResource.clreplaced, APPLICATION_OCTET_STREAM)).willReturn(true);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedyResource, mavContainer, webRequest);
then(resourceMessageConverter).should(times(1)).write(any(ByteArrayResource.clreplaced), eq(APPLICATION_OCTET_STREAM), any(HttpOutputMessage.clreplaced));
replacedertEquals(200, servletResponse.getStatus());
}
@Test
public void shouldHandleResourceByteRange() throws Exception {
ResponseEnreplacedy<Resource> returnValue = ResponseEnreplacedy.ok(new ByteArrayResource("Content".getBytes(StandardCharsets.UTF_8)));
servletRequest.addHeader("Range", "bytes=0-5");
given(resourceRegionMessageConverter.canWrite(any(), eq(null))).willReturn(true);
given(resourceRegionMessageConverter.canWrite(any(), eq(APPLICATION_OCTET_STREAM))).willReturn(true);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedyResource, mavContainer, webRequest);
then(resourceRegionMessageConverter).should(times(1)).write(anyCollection(), eq(APPLICATION_OCTET_STREAM), argThat(outputMessage -> "bytes".equals(outputMessage.getHeaders().getFirst(HttpHeaders.ACCEPT_RANGES))));
replacedertEquals(206, servletResponse.getStatus());
}
@Test
public void handleReturnTypeResourceIllegalByteRange() throws Exception {
ResponseEnreplacedy<Resource> returnValue = ResponseEnreplacedy.ok(new ByteArrayResource("Content".getBytes(StandardCharsets.UTF_8)));
servletRequest.addHeader("Range", "illegal");
given(resourceRegionMessageConverter.canWrite(any(), eq(null))).willReturn(true);
given(resourceRegionMessageConverter.canWrite(any(), eq(APPLICATION_OCTET_STREAM))).willReturn(true);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedyResource, mavContainer, webRequest);
then(resourceRegionMessageConverter).should(never()).write(anyCollection(), eq(APPLICATION_OCTET_STREAM), any(HttpOutputMessage.clreplaced));
replacedertEquals(416, servletResponse.getStatus());
}
// SPR-16754
@Test
public void disableRangeSupportForStreamingResponses() throws Exception {
InputStream is = new ByteArrayInputStream("Content".getBytes(StandardCharsets.UTF_8));
InputStreamResource resource = new InputStreamResource(is, "test");
ResponseEnreplacedy<Resource> returnValue = ResponseEnreplacedy.ok(resource);
servletRequest.addHeader("Range", "bytes=0-5");
given(resourceMessageConverter.canWrite(any(), eq(null))).willReturn(true);
given(resourceMessageConverter.canWrite(any(), eq(APPLICATION_OCTET_STREAM))).willReturn(true);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedyResource, mavContainer, webRequest);
then(resourceMessageConverter).should(times(1)).write(any(InputStreamResource.clreplaced), eq(APPLICATION_OCTET_STREAM), any(HttpOutputMessage.clreplaced));
replacedertEquals(200, servletResponse.getStatus());
replacedertThat(servletResponse.getHeader(HttpHeaders.ACCEPT_RANGES), Matchers.isEmptyOrNullString());
}
// SPR-16921
@Test
public void disableRangeSupportIfContentRangePresent() throws Exception {
ResponseEnreplacedy<Resource> returnValue = ResponseEnreplacedy.status(HttpStatus.PARTIAL_CONTENT).header(HttpHeaders.RANGE, "bytes=0-5").body(new ByteArrayResource("Content".getBytes(StandardCharsets.UTF_8)));
given(resourceRegionMessageConverter.canWrite(any(), eq(null))).willReturn(true);
given(resourceRegionMessageConverter.canWrite(any(), eq(APPLICATION_OCTET_STREAM))).willReturn(true);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedyResource, mavContainer, webRequest);
then(resourceRegionMessageConverter).should(never()).write(anyCollection(), any(), any());
replacedertEquals(206, servletResponse.getStatus());
}
// SPR-14767
@Test
public void shouldHandleValidatorHeadersInputResponses() throws Exception {
servletRequest.setMethod("PUT");
String etagValue = "\"some-etag\"";
ResponseEnreplacedy<String> returnValue = ResponseEnreplacedy.ok().header(HttpHeaders.ETAG, etagValue).body("body");
initStringMessageConversion(TEXT_PLAIN);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertConditionalResponse(HttpStatus.OK, "body", etagValue, -1);
}
@Test
public void shouldNotFailPreconditionForPutRequests() throws Exception {
servletRequest.setMethod("PUT");
ZonedDateTime dateTime = ofEpochMilli(new Date().getTime()).atZone(GMT);
servletRequest.addHeader(HttpHeaders.IF_UNMODIFIED_SINCE, RFC_1123_DATE_TIME.format(dateTime));
long justModified = dateTime.plus(1, ChronoUnit.SECONDS).toEpochSecond() * 1000;
ResponseEnreplacedy<String> returnValue = ResponseEnreplacedy.ok().lastModified(justModified).body("body");
initStringMessageConversion(TEXT_PLAIN);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertConditionalResponse(HttpStatus.OK, null, null, justModified);
}
@Test
public void varyHeader() throws Exception {
String[] enreplacedyValues = { "Accept-Language", "User-Agent" };
String[] existingValues = {};
String[] expected = { "Accept-Language, User-Agent" };
testVaryHeader(enreplacedyValues, existingValues, expected);
}
@Test
public void varyHeaderWithExistingWildcard() throws Exception {
String[] enreplacedyValues = { "Accept-Language" };
String[] existingValues = { "*" };
String[] expected = { "*" };
testVaryHeader(enreplacedyValues, existingValues, expected);
}
@Test
public void varyHeaderWithExistingCommaValues() throws Exception {
String[] enreplacedyValues = { "Accept-Language", "User-Agent" };
String[] existingValues = { "Accept-Encoding", "Accept-Language" };
String[] expected = { "Accept-Encoding", "Accept-Language", "User-Agent" };
testVaryHeader(enreplacedyValues, existingValues, expected);
}
@Test
public void varyHeaderWithExistingCommaSeparatedValues() throws Exception {
String[] enreplacedyValues = { "Accept-Language", "User-Agent" };
String[] existingValues = { "Accept-Encoding, Accept-Language" };
String[] expected = { "Accept-Encoding, Accept-Language", "User-Agent" };
testVaryHeader(enreplacedyValues, existingValues, expected);
}
@Test
public void handleReturnValueVaryHeader() throws Exception {
String[] enreplacedyValues = { "Accept-Language", "User-Agent" };
String[] existingValues = { "Accept-Encoding, Accept-Language" };
String[] expected = { "Accept-Encoding, Accept-Language", "User-Agent" };
testVaryHeader(enreplacedyValues, existingValues, expected);
}
private void testVaryHeader(String[] enreplacedyValues, String[] existingValues, String[] expected) throws Exception {
ResponseEnreplacedy<String> returnValue = ResponseEnreplacedy.ok().varyBy(enreplacedyValues).body("Foo");
for (String value : existingValues) {
servletResponse.addHeader("Vary", value);
}
initStringMessageConversion(TEXT_PLAIN);
processor.handleReturnValue(returnValue, returnTypeResponseEnreplacedy, mavContainer, webRequest);
replacedertTrue(mavContainer.isRequestHandled());
replacedertEquals(Arrays.asList(expected), servletResponse.getHeaders("Vary"));
verify(stringHttpMessageConverter).write(eq("Foo"), eq(TEXT_PLAIN), isA(HttpOutputMessage.clreplaced));
}
private void initStringMessageConversion(MediaType accepted) {
given(stringHttpMessageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(stringHttpMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(TEXT_PLAIN));
given(stringHttpMessageConverter.canWrite(String.clreplaced, accepted)).willReturn(true);
}
private void replacedertResponseBody(String body) throws IOException {
ArgumentCaptor<HttpOutputMessage> outputMessage = ArgumentCaptor.forClreplaced(HttpOutputMessage.clreplaced);
verify(stringHttpMessageConverter).write(eq(body), eq(TEXT_PLAIN), outputMessage.capture());
}
private void replacedertConditionalResponse(HttpStatus status, String body, String etag, long lastModified) throws IOException {
replacedertEquals(status.value(), servletResponse.getStatus());
replacedertTrue(mavContainer.isRequestHandled());
if (body != null) {
replacedertResponseBody(body);
} else {
replacedertEquals(0, servletResponse.getContentAsByteArray().length);
}
if (etag != null) {
replacedertEquals(1, servletResponse.getHeaderValues(HttpHeaders.ETAG).size());
replacedertEquals(etag, servletResponse.getHeader(HttpHeaders.ETAG));
}
if (lastModified != -1) {
replacedertEquals(1, servletResponse.getHeaderValues(HttpHeaders.LAST_MODIFIED).size());
replacedertEquals(lastModified / 1000, servletResponse.getDateHeader(HttpHeaders.LAST_MODIFIED) / 1000);
}
}
@SuppressWarnings("unused")
public ResponseEnreplacedy<String> handle1(HttpEnreplacedy<String> httpEnreplacedy, ResponseEnreplacedy<String> enreplacedy, int i, RequestEnreplacedy<String> requestEnreplacedy) {
return enreplacedy;
}
@SuppressWarnings("unused")
public HttpEnreplacedy<?> handle2(HttpEnreplacedy<?> enreplacedy) {
return enreplacedy;
}
@SuppressWarnings("unused")
public CustomHttpEnreplacedy handle2x(HttpEnreplacedy<?> enreplacedy) {
return new CustomHttpEnreplacedy();
}
@SuppressWarnings("unused")
public int handle3() {
return 42;
}
@SuppressWarnings("unused")
@RequestMapping(produces = { "text/html", "application/xhtml+xml" })
public ResponseEnreplacedy<String> handle4() {
return null;
}
@SuppressWarnings("unused")
public ResponseEnreplacedy<Resource> handle5() {
return null;
}
@SuppressWarnings("unused")
public static clreplaced CustomHttpEnreplacedy extends HttpEnreplacedy<Object> {
}
}
17
Source : RestTemplateTests.java
with MIT License
from Vip-Augus
with MIT License
from Vip-Augus
/**
* @author Arjen Poutsma
* @author Rossen Stoyanchev
* @author Brian Clozel
*/
@SuppressWarnings("unchecked")
public clreplaced RestTemplateTests {
private RestTemplate template;
private ClientHttpRequestFactory requestFactory;
private ClientHttpRequest request;
private ClientHttpResponse response;
private ResponseErrorHandler errorHandler;
@SuppressWarnings("rawtypes")
private HttpMessageConverter converter;
@Before
public void setup() {
requestFactory = mock(ClientHttpRequestFactory.clreplaced);
request = mock(ClientHttpRequest.clreplaced);
response = mock(ClientHttpResponse.clreplaced);
errorHandler = mock(ResponseErrorHandler.clreplaced);
converter = mock(HttpMessageConverter.clreplaced);
template = new RestTemplate(Collections.singletonList(converter));
template.setRequestFactory(requestFactory);
template.setErrorHandler(errorHandler);
}
@Test
public void varArgsTemplateVariables() throws Exception {
mockSentRequest(GET, "https://example.com/hotels/42/bookings/21");
mockResponseStatus(HttpStatus.OK);
template.execute("https://example.com/hotels/{hotel}/bookings/{booking}", GET, null, null, "42", "21");
verify(response).close();
}
@Test
public void varArgsNullTemplateVariable() throws Exception {
mockSentRequest(GET, "https://example.com/-foo");
mockResponseStatus(HttpStatus.OK);
template.execute("https://example.com/{first}-{last}", GET, null, null, null, "foo");
verify(response).close();
}
@Test
public void mapTemplateVariables() throws Exception {
mockSentRequest(GET, "https://example.com/hotels/42/bookings/42");
mockResponseStatus(HttpStatus.OK);
Map<String, String> vars = Collections.singletonMap("hotel", "42");
template.execute("https://example.com/hotels/{hotel}/bookings/{hotel}", GET, null, null, vars);
verify(response).close();
}
@Test
public void mapNullTemplateVariable() throws Exception {
mockSentRequest(GET, "https://example.com/-foo");
mockResponseStatus(HttpStatus.OK);
Map<String, String> vars = new HashMap<>(2);
vars.put("first", null);
vars.put("last", "foo");
template.execute("https://example.com/{first}-{last}", GET, null, null, vars);
verify(response).close();
}
// SPR-15201
@Test
public void uriTemplateWithTrailingSlash() throws Exception {
String url = "https://example.com/spring/";
mockSentRequest(GET, url);
mockResponseStatus(HttpStatus.OK);
template.execute(url, GET, null, null);
verify(response).close();
}
@Test
public void errorHandling() throws Exception {
String url = "https://example.com";
mockSentRequest(GET, url);
mockResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR);
willThrow(new HttpServerErrorException(HttpStatus.INTERNAL_SERVER_ERROR)).given(errorHandler).handleError(new URI(url), GET, response);
try {
template.execute(url, GET, null, null);
fail("HttpServerErrorException expected");
} catch (HttpServerErrorException ex) {
// expected
}
verify(response).close();
}
@Test
public void getForObject() throws Exception {
String expected = "Hello World";
mockTextPlainHttpMessageConverter();
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(GET, "https://example.com", requestHeaders);
mockResponseStatus(HttpStatus.OK);
mockTextResponseBody("Hello World");
String result = template.getForObject("https://example.com", String.clreplaced);
replacedertEquals("Invalid GET result", expected, result);
replacedertEquals("Invalid Accept header", MediaType.TEXT_PLAIN_VALUE, requestHeaders.getFirst("Accept"));
verify(response).close();
}
@Test
public void getUnsupportedMediaType() throws Exception {
mockSentRequest(GET, "https://example.com/resource");
mockResponseStatus(HttpStatus.OK);
given(converter.canRead(String.clreplaced, null)).willReturn(true);
MediaType supportedMediaType = new MediaType("foo", "bar");
given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(supportedMediaType));
MediaType barBaz = new MediaType("bar", "baz");
mockResponseBody("Foo", new MediaType("bar", "baz"));
given(converter.canRead(String.clreplaced, barBaz)).willReturn(false);
try {
template.getForObject("https://example.com/{p}", String.clreplaced, "resource");
fail("UnsupportedMediaTypeException expected");
} catch (RestClientException ex) {
// expected
}
verify(response).close();
}
@Test
public void requestAvoidsDuplicateAcceptHeaderValues() throws Exception {
HttpMessageConverter firstConverter = mock(HttpMessageConverter.clreplaced);
given(firstConverter.canRead(any(), any())).willReturn(true);
given(firstConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
HttpMessageConverter secondConverter = mock(HttpMessageConverter.clreplaced);
given(secondConverter.canRead(any(), any())).willReturn(true);
given(secondConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(GET, "https://example.com/", requestHeaders);
mockResponseStatus(HttpStatus.OK);
mockTextResponseBody("Hello World");
template.setMessageConverters(Arrays.asList(firstConverter, secondConverter));
template.getForObject("https://example.com/", String.clreplaced);
replacedertEquals("Sent duplicate Accept header values", 1, requestHeaders.getAccept().size());
}
@Test
public void getForEnreplacedy() throws Exception {
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(GET, "https://example.com", requestHeaders);
mockTextPlainHttpMessageConverter();
mockResponseStatus(HttpStatus.OK);
String expected = "Hello World";
mockTextResponseBody(expected);
ResponseEnreplacedy<String> result = template.getForEnreplacedy("https://example.com", String.clreplaced);
replacedertEquals("Invalid GET result", expected, result.getBody());
replacedertEquals("Invalid Accept header", MediaType.TEXT_PLAIN_VALUE, requestHeaders.getFirst("Accept"));
replacedertEquals("Invalid Content-Type header", MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
replacedertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode());
verify(response).close();
}
@Test
public void getForObjectWithCustomUriTemplateHandler() throws Exception {
DefaultUriBuilderFactory uriTemplateHandler = new DefaultUriBuilderFactory();
template.setUriTemplateHandler(uriTemplateHandler);
mockSentRequest(GET, "https://example.com/hotels/1/pic/pics%2Flogo.png/size/150x150");
mockResponseStatus(HttpStatus.OK);
given(response.getHeaders()).willReturn(new HttpHeaders());
given(response.getBody()).willReturn(StreamUtils.emptyInput());
Map<String, String> uriVariables = new HashMap<>(2);
uriVariables.put("hotel", "1");
uriVariables.put("publicpath", "pics/logo.png");
uriVariables.put("scale", "150x150");
String url = "https://example.com/hotels/{hotel}/pic/{publicpath}/size/{scale}";
template.getForObject(url, String.clreplaced, uriVariables);
verify(response).close();
}
@Test
public void headForHeaders() throws Exception {
mockSentRequest(HEAD, "https://example.com");
mockResponseStatus(HttpStatus.OK);
HttpHeaders responseHeaders = new HttpHeaders();
given(response.getHeaders()).willReturn(responseHeaders);
HttpHeaders result = template.headForHeaders("https://example.com");
replacedertSame("Invalid headers returned", responseHeaders, result);
verify(response).close();
}
@Test
public void postForLocation() throws Exception {
mockSentRequest(POST, "https://example.com");
mockTextPlainHttpMessageConverter();
mockResponseStatus(HttpStatus.OK);
String helloWorld = "Hello World";
HttpHeaders responseHeaders = new HttpHeaders();
URI expected = new URI("https://example.com/hotels");
responseHeaders.setLocation(expected);
given(response.getHeaders()).willReturn(responseHeaders);
URI result = template.postForLocation("https://example.com", helloWorld);
replacedertEquals("Invalid POST result", expected, result);
verify(response).close();
}
@Test
public void postForLocationEnreplacedyContentType() throws Exception {
mockSentRequest(POST, "https://example.com");
mockTextPlainHttpMessageConverter();
mockResponseStatus(HttpStatus.OK);
String helloWorld = "Hello World";
HttpHeaders responseHeaders = new HttpHeaders();
URI expected = new URI("https://example.com/hotels");
responseHeaders.setLocation(expected);
given(response.getHeaders()).willReturn(responseHeaders);
HttpHeaders enreplacedyHeaders = new HttpHeaders();
enreplacedyHeaders.setContentType(MediaType.TEXT_PLAIN);
HttpEnreplacedy<String> enreplacedy = new HttpEnreplacedy<>(helloWorld, enreplacedyHeaders);
URI result = template.postForLocation("https://example.com", enreplacedy);
replacedertEquals("Invalid POST result", expected, result);
verify(response).close();
}
@Test
public void postForLocationEnreplacedyCustomHeader() throws Exception {
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(POST, "https://example.com", requestHeaders);
mockTextPlainHttpMessageConverter();
mockResponseStatus(HttpStatus.OK);
HttpHeaders responseHeaders = new HttpHeaders();
URI expected = new URI("https://example.com/hotels");
responseHeaders.setLocation(expected);
given(response.getHeaders()).willReturn(responseHeaders);
HttpHeaders enreplacedyHeaders = new HttpHeaders();
enreplacedyHeaders.set("MyHeader", "MyValue");
HttpEnreplacedy<String> enreplacedy = new HttpEnreplacedy<>("Hello World", enreplacedyHeaders);
URI result = template.postForLocation("https://example.com", enreplacedy);
replacedertEquals("Invalid POST result", expected, result);
replacedertEquals("No custom header set", "MyValue", requestHeaders.getFirst("MyHeader"));
verify(response).close();
}
@Test
public void postForLocationNoLocation() throws Exception {
mockSentRequest(POST, "https://example.com");
mockTextPlainHttpMessageConverter();
mockResponseStatus(HttpStatus.OK);
URI result = template.postForLocation("https://example.com", "Hello World");
replacedertNull("Invalid POST result", result);
verify(response).close();
}
@Test
public void postForLocationNull() throws Exception {
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(POST, "https://example.com", requestHeaders);
mockResponseStatus(HttpStatus.OK);
template.postForLocation("https://example.com", null);
replacedertEquals("Invalid content length", 0, requestHeaders.getContentLength());
verify(response).close();
}
@Test
public void postForObject() throws Exception {
mockTextPlainHttpMessageConverter();
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(POST, "https://example.com", requestHeaders);
mockResponseStatus(HttpStatus.OK);
String expected = "42";
mockResponseBody(expected, MediaType.TEXT_PLAIN);
String result = template.postForObject("https://example.com", "Hello World", String.clreplaced);
replacedertEquals("Invalid POST result", expected, result);
replacedertEquals("Invalid Accept header", MediaType.TEXT_PLAIN_VALUE, requestHeaders.getFirst("Accept"));
verify(response).close();
}
@Test
public void postForEnreplacedy() throws Exception {
mockTextPlainHttpMessageConverter();
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(POST, "https://example.com", requestHeaders);
mockResponseStatus(HttpStatus.OK);
String expected = "42";
mockResponseBody(expected, MediaType.TEXT_PLAIN);
ResponseEnreplacedy<String> result = template.postForEnreplacedy("https://example.com", "Hello World", String.clreplaced);
replacedertEquals("Invalid POST result", expected, result.getBody());
replacedertEquals("Invalid Content-Type", MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
replacedertEquals("Invalid Accept header", MediaType.TEXT_PLAIN_VALUE, requestHeaders.getFirst("Accept"));
replacedertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode());
verify(response).close();
}
@Test
public void postForObjectNull() throws Exception {
mockTextPlainHttpMessageConverter();
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(POST, "https://example.com", requestHeaders);
mockResponseStatus(HttpStatus.OK);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(MediaType.TEXT_PLAIN);
responseHeaders.setContentLength(10);
given(response.getHeaders()).willReturn(responseHeaders);
given(response.getBody()).willReturn(StreamUtils.emptyInput());
given(converter.read(String.clreplaced, response)).willReturn(null);
String result = template.postForObject("https://example.com", null, String.clreplaced);
replacedertNull("Invalid POST result", result);
replacedertEquals("Invalid content length", 0, requestHeaders.getContentLength());
verify(response).close();
}
@Test
public void postForEnreplacedyNull() throws Exception {
mockTextPlainHttpMessageConverter();
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(POST, "https://example.com", requestHeaders);
mockResponseStatus(HttpStatus.OK);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(MediaType.TEXT_PLAIN);
responseHeaders.setContentLength(10);
given(response.getHeaders()).willReturn(responseHeaders);
given(response.getBody()).willReturn(StreamUtils.emptyInput());
given(converter.read(String.clreplaced, response)).willReturn(null);
ResponseEnreplacedy<String> result = template.postForEnreplacedy("https://example.com", null, String.clreplaced);
replacedertFalse("Invalid POST result", result.hasBody());
replacedertEquals("Invalid Content-Type", MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
replacedertEquals("Invalid content length", 0, requestHeaders.getContentLength());
replacedertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode());
verify(response).close();
}
@Test
public void put() throws Exception {
mockTextPlainHttpMessageConverter();
mockSentRequest(PUT, "https://example.com");
mockResponseStatus(HttpStatus.OK);
template.put("https://example.com", "Hello World");
verify(response).close();
}
@Test
public void putNull() throws Exception {
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(PUT, "https://example.com", requestHeaders);
mockResponseStatus(HttpStatus.OK);
template.put("https://example.com", null);
replacedertEquals("Invalid content length", 0, requestHeaders.getContentLength());
verify(response).close();
}
@Test
public void patchForObject() throws Exception {
mockTextPlainHttpMessageConverter();
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(PATCH, "https://example.com", requestHeaders);
mockResponseStatus(HttpStatus.OK);
String expected = "42";
mockResponseBody("42", MediaType.TEXT_PLAIN);
String result = template.patchForObject("https://example.com", "Hello World", String.clreplaced);
replacedertEquals("Invalid POST result", expected, result);
replacedertEquals("Invalid Accept header", MediaType.TEXT_PLAIN_VALUE, requestHeaders.getFirst("Accept"));
verify(response).close();
}
@Test
public void patchForObjectNull() throws Exception {
mockTextPlainHttpMessageConverter();
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(PATCH, "https://example.com", requestHeaders);
mockResponseStatus(HttpStatus.OK);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(MediaType.TEXT_PLAIN);
responseHeaders.setContentLength(10);
given(response.getHeaders()).willReturn(responseHeaders);
given(response.getBody()).willReturn(StreamUtils.emptyInput());
String result = template.patchForObject("https://example.com", null, String.clreplaced);
replacedertNull("Invalid POST result", result);
replacedertEquals("Invalid content length", 0, requestHeaders.getContentLength());
verify(response).close();
}
@Test
public void delete() throws Exception {
mockSentRequest(DELETE, "https://example.com");
mockResponseStatus(HttpStatus.OK);
template.delete("https://example.com");
verify(response).close();
}
@Test
public void optionsForAllow() throws Exception {
mockSentRequest(OPTIONS, "https://example.com");
mockResponseStatus(HttpStatus.OK);
HttpHeaders responseHeaders = new HttpHeaders();
EnumSet<HttpMethod> expected = EnumSet.of(GET, POST);
responseHeaders.setAllow(expected);
given(response.getHeaders()).willReturn(responseHeaders);
Set<HttpMethod> result = template.optionsForAllow("https://example.com");
replacedertEquals("Invalid OPTIONS result", expected, result);
verify(response).close();
}
// SPR-9325, SPR-13860
@Test
public void ioException() throws Exception {
String url = "https://example.com/resource?access_token=123";
mockSentRequest(GET, url);
mockHttpMessageConverter(new MediaType("foo", "bar"), String.clreplaced);
given(request.execute()).willThrow(new IOException("Socket failure"));
try {
template.getForObject(url, String.clreplaced);
fail("RestClientException expected");
} catch (ResourceAccessException ex) {
replacedertEquals("I/O error on GET request for \"https://example.com/resource\": " + "Socket failure; nested exception is java.io.IOException: Socket failure", ex.getMessage());
}
}
// SPR-15900
@Test
public void ioExceptionWithEmptyQueryString() throws Exception {
// https://example.com/resource?
URI uri = new URI("https", "example.com", "/resource", "", null);
given(converter.canRead(String.clreplaced, null)).willReturn(true);
given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(parseMediaType("foo/bar")));
given(requestFactory.createRequest(uri, GET)).willReturn(request);
given(request.getHeaders()).willReturn(new HttpHeaders());
given(request.execute()).willThrow(new IOException("Socket failure"));
try {
template.getForObject(uri, String.clreplaced);
fail("RestClientException expected");
} catch (ResourceAccessException ex) {
replacedertEquals("I/O error on GET request for \"https://example.com/resource\": " + "Socket failure; nested exception is java.io.IOException: Socket failure", ex.getMessage());
}
}
@Test
public void exchange() throws Exception {
mockTextPlainHttpMessageConverter();
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(POST, "https://example.com", requestHeaders);
mockResponseStatus(HttpStatus.OK);
String expected = "42";
mockResponseBody(expected, MediaType.TEXT_PLAIN);
HttpHeaders enreplacedyHeaders = new HttpHeaders();
enreplacedyHeaders.set("MyHeader", "MyValue");
HttpEnreplacedy<String> enreplacedy = new HttpEnreplacedy<>("Hello World", enreplacedyHeaders);
ResponseEnreplacedy<String> result = template.exchange("https://example.com", POST, enreplacedy, String.clreplaced);
replacedertEquals("Invalid POST result", expected, result.getBody());
replacedertEquals("Invalid Content-Type", MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
replacedertEquals("Invalid Accept header", MediaType.TEXT_PLAIN_VALUE, requestHeaders.getFirst("Accept"));
replacedertEquals("Invalid custom header", "MyValue", requestHeaders.getFirst("MyHeader"));
replacedertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode());
verify(response).close();
}
@Test
@SuppressWarnings("rawtypes")
public void exchangeParameterizedType() throws Exception {
GenericHttpMessageConverter converter = mock(GenericHttpMessageConverter.clreplaced);
template.setMessageConverters(Collections.<HttpMessageConverter<?>>singletonList(converter));
ParameterizedTypeReference<List<Integer>> intList = new ParameterizedTypeReference<List<Integer>>() {
};
given(converter.canRead(intList.getType(), null, null)).willReturn(true);
given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
given(converter.canWrite(String.clreplaced, String.clreplaced, null)).willReturn(true);
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(POST, "https://example.com", requestHeaders);
List<Integer> expected = Collections.singletonList(42);
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(MediaType.TEXT_PLAIN);
responseHeaders.setContentLength(10);
mockResponseStatus(HttpStatus.OK);
given(response.getHeaders()).willReturn(responseHeaders);
given(response.getBody()).willReturn(new ByteArrayInputStream(Integer.toString(42).getBytes()));
given(converter.canRead(intList.getType(), null, MediaType.TEXT_PLAIN)).willReturn(true);
given(converter.read(eq(intList.getType()), eq(null), any(HttpInputMessage.clreplaced))).willReturn(expected);
HttpHeaders enreplacedyHeaders = new HttpHeaders();
enreplacedyHeaders.set("MyHeader", "MyValue");
HttpEnreplacedy<String> requestEnreplacedy = new HttpEnreplacedy<>("Hello World", enreplacedyHeaders);
ResponseEnreplacedy<List<Integer>> result = template.exchange("https://example.com", POST, requestEnreplacedy, intList);
replacedertEquals("Invalid POST result", expected, result.getBody());
replacedertEquals("Invalid Content-Type", MediaType.TEXT_PLAIN, result.getHeaders().getContentType());
replacedertEquals("Invalid Accept header", MediaType.TEXT_PLAIN_VALUE, requestHeaders.getFirst("Accept"));
replacedertEquals("Invalid custom header", "MyValue", requestHeaders.getFirst("MyHeader"));
replacedertEquals("Invalid status code", HttpStatus.OK, result.getStatusCode());
verify(response).close();
}
// SPR-15066
@Test
public void requestInterceptorCanAddExistingHeaderValueWithoutBody() throws Exception {
ClientHttpRequestInterceptor interceptor = (request, body, execution) -> {
request.getHeaders().add("MyHeader", "MyInterceptorValue");
return execution.execute(request, body);
};
template.setInterceptors(Collections.singletonList(interceptor));
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(POST, "https://example.com", requestHeaders);
mockResponseStatus(HttpStatus.OK);
HttpHeaders enreplacedyHeaders = new HttpHeaders();
enreplacedyHeaders.add("MyHeader", "MyEnreplacedyValue");
HttpEnreplacedy<Void> enreplacedy = new HttpEnreplacedy<>(null, enreplacedyHeaders);
template.exchange("https://example.com", POST, enreplacedy, Void.clreplaced);
replacedertThat(requestHeaders.get("MyHeader"), contains("MyEnreplacedyValue", "MyInterceptorValue"));
verify(response).close();
}
// SPR-15066
@Test
public void requestInterceptorCanAddExistingHeaderValueWithBody() throws Exception {
ClientHttpRequestInterceptor interceptor = (request, body, execution) -> {
request.getHeaders().add("MyHeader", "MyInterceptorValue");
return execution.execute(request, body);
};
template.setInterceptors(Collections.singletonList(interceptor));
MediaType contentType = MediaType.TEXT_PLAIN;
given(converter.canWrite(String.clreplaced, contentType)).willReturn(true);
HttpHeaders requestHeaders = new HttpHeaders();
mockSentRequest(POST, "https://example.com", requestHeaders);
mockResponseStatus(HttpStatus.OK);
HttpHeaders enreplacedyHeaders = new HttpHeaders();
enreplacedyHeaders.setContentType(contentType);
enreplacedyHeaders.add("MyHeader", "MyEnreplacedyValue");
HttpEnreplacedy<String> enreplacedy = new HttpEnreplacedy<>("Hello World", enreplacedyHeaders);
template.exchange("https://example.com", POST, enreplacedy, Void.clreplaced);
replacedertThat(requestHeaders.get("MyHeader"), contains("MyEnreplacedyValue", "MyInterceptorValue"));
verify(response).close();
}
private void mockSentRequest(HttpMethod method, String uri) throws Exception {
mockSentRequest(method, uri, new HttpHeaders());
}
private void mockSentRequest(HttpMethod method, String uri, HttpHeaders requestHeaders) throws Exception {
given(requestFactory.createRequest(new URI(uri), method)).willReturn(request);
given(request.getHeaders()).willReturn(requestHeaders);
}
private void mockResponseStatus(HttpStatus responseStatus) throws Exception {
given(request.execute()).willReturn(response);
given(errorHandler.hasError(response)).willReturn(responseStatus.isError());
given(response.getStatusCode()).willReturn(responseStatus);
given(response.getRawStatusCode()).willReturn(responseStatus.value());
given(response.getStatusText()).willReturn(responseStatus.getReasonPhrase());
}
private void mockTextPlainHttpMessageConverter() {
mockHttpMessageConverter(MediaType.TEXT_PLAIN, String.clreplaced);
}
private void mockHttpMessageConverter(MediaType mediaType, Clreplaced type) {
given(converter.canRead(type, null)).willReturn(true);
given(converter.canRead(type, mediaType)).willReturn(true);
given(converter.getSupportedMediaTypes()).willReturn(Collections.singletonList(mediaType));
given(converter.canRead(type, mediaType)).willReturn(true);
given(converter.canWrite(type, null)).willReturn(true);
given(converter.canWrite(type, mediaType)).willReturn(true);
}
private void mockTextResponseBody(String expectedBody) throws Exception {
mockResponseBody(expectedBody, MediaType.TEXT_PLAIN);
}
private void mockResponseBody(String expectedBody, MediaType mediaType) throws Exception {
HttpHeaders responseHeaders = new HttpHeaders();
responseHeaders.setContentType(mediaType);
responseHeaders.setContentLength(expectedBody.length());
given(response.getHeaders()).willReturn(responseHeaders);
given(response.getBody()).willReturn(new ByteArrayInputStream(expectedBody.getBytes()));
given(converter.read(eq(String.clreplaced), any(HttpInputMessage.clreplaced))).willReturn(expectedBody);
}
}
17
Source : WebMvcConfig.java
with Apache License 2.0
from Taskana
with Apache License 2.0
from Taskana
@Override
public void extendMessageConverters(List<HttpMessageConverter<?>> converters) {
for (HttpMessageConverter<?> converter : converters) {
if (converter instanceof MappingJackson2HttpMessageConverter) {
MappingJackson2HttpMessageConverter jacksonConverter = (MappingJackson2HttpMessageConverter) converter;
jacksonConverter.setPrettyPrint(true);
}
}
}
17
Source : RequestHandler.java
with MIT License
from ssssssss-team
with MIT License
from ssssssss-team
private Object readRequestBody(HttpServletRequest request) throws IOException {
if (configuration.getHttpMessageConverters() != null && request.getContentType() != null) {
MediaType mediaType = MediaType.valueOf(request.getContentType());
Clreplaced clazz = Object.clreplaced;
try {
for (HttpMessageConverter<?> converter : configuration.getHttpMessageConverters()) {
if (converter.canRead(clazz, mediaType)) {
return converter.read(clazz, new ServletServerHttpRequest(request));
}
}
} catch (HttpMessageNotReadableException ignored) {
return null;
}
}
return null;
}
17
Source : OAuth2RefreshTokenGrantTests.java
with Apache License 2.0
from spring-projects-experimental
with Apache License 2.0
from spring-projects-experimental
/**
* Integration tests for the OAuth 2.0 Refresh Token Grant.
*
* @author Alexey Nesterov
* @since 0.0.3
*/
public clreplaced OAuth2RefreshTokenGrantTests {
private static final String AUTHORITIES_CLAIM = "authorities";
private static RegisteredClientRepository registeredClientRepository;
private static OAuth2AuthorizationService authorizationService;
private static JWKSource<SecurityContext> jwkSource;
private static NimbusJwtDecoder jwtDecoder;
private static HttpMessageConverter<OAuth2AccessTokenResponse> accessTokenHttpResponseConverter = new OAuth2AccessTokenResponseHttpMessageConverter();
@Rule
public final SpringTestRule spring = new SpringTestRule();
@Autowired
private MockMvc mvc;
@BeforeClreplaced
public static void init() {
registeredClientRepository = mock(RegisteredClientRepository.clreplaced);
authorizationService = mock(OAuth2AuthorizationService.clreplaced);
JWKSet jwkSet = new JWKSet(TestJwks.DEFAULT_RSA_JWK);
jwkSource = (jwkSelector, securityContext) -> jwkSelector.select(jwkSet);
jwtDecoder = NimbusJwtDecoder.withPublicKey(TestKeys.DEFAULT_PUBLIC_KEY).build();
}
@Before
public void setup() {
reset(registeredClientRepository);
reset(authorizationService);
}
@Test
public void requestWhenRefreshTokenRequestValidThenReturnAccessTokenResponse() throws Exception {
this.spring.register(AuthorizationServerConfiguration.clreplaced).autowire();
RegisteredClient registeredClient = TestRegisteredClients.registeredClient().build();
when(registeredClientRepository.findByClientId(eq(registeredClient.getClientId()))).thenReturn(registeredClient);
OAuth2Authorization authorization = TestOAuth2Authorizations.authorization(registeredClient).build();
when(authorizationService.findByToken(eq(authorization.getRefreshToken().getToken().getTokenValue()), eq(OAuth2TokenType.REFRESH_TOKEN))).thenReturn(authorization);
MvcResult mvcResult = this.mvc.perform(post(OAuth2TokenEndpointFilter.DEFAULT_TOKEN_ENDPOINT_URI).params(getRefreshTokenRequestParameters(authorization)).header(HttpHeaders.AUTHORIZATION, "Basic " + encodeBasicAuth(registeredClient.getClientId(), registeredClient.getClientSecret()))).andExpect(status().isOk()).andExpect(header().string(HttpHeaders.CACHE_CONTROL, containsString("no-store"))).andExpect(header().string(HttpHeaders.PRAGMA, containsString("no-cache"))).andExpect(jsonPath("$.access_token").isNotEmpty()).andExpect(jsonPath("$.token_type").isNotEmpty()).andExpect(jsonPath("$.expires_in").isNotEmpty()).andExpect(jsonPath("$.refresh_token").isNotEmpty()).andExpect(jsonPath("$.scope").isNotEmpty()).andReturn();
verify(registeredClientRepository).findByClientId(eq(registeredClient.getClientId()));
verify(authorizationService).findByToken(eq(authorization.getRefreshToken().getToken().getTokenValue()), eq(OAuth2TokenType.REFRESH_TOKEN));
verify(authorizationService).save(any());
MockHttpServletResponse servletResponse = mvcResult.getResponse();
MockClientHttpResponse httpResponse = new MockClientHttpResponse(servletResponse.getContentAsByteArray(), HttpStatus.valueOf(servletResponse.getStatus()));
OAuth2AccessTokenResponse accessTokenResponse = accessTokenHttpResponseConverter.read(OAuth2AccessTokenResponse.clreplaced, httpResponse);
// replacedert user authorities was propagated as claim in JWT
Jwt jwt = jwtDecoder.decode(accessTokenResponse.getAccessToken().getTokenValue());
List<String> authoritiesClaim = jwt.getClaim(AUTHORITIES_CLAIM);
Authentication principal = authorization.getAttribute(Principal.clreplaced.getName());
Set<String> userAuthorities = principal.getAuthorities().stream().map(GrantedAuthority::getAuthority).collect(Collectors.toSet());
replacedertThat(authoritiesClaim).containsExactlyInAnyOrderElementsOf(userAuthorities);
}
private static MultiValueMap<String, String> getRefreshTokenRequestParameters(OAuth2Authorization authorization) {
MultiValueMap<String, String> parameters = new LinkedMultiValueMap<>();
parameters.set(OAuth2ParameterNames.GRANT_TYPE, AuthorizationGrantType.REFRESH_TOKEN.getValue());
parameters.set(OAuth2ParameterNames.REFRESH_TOKEN, authorization.getRefreshToken().getToken().getTokenValue());
return parameters;
}
private static String encodeBasicAuth(String clientId, String secret) throws Exception {
clientId = URLEncoder.encode(clientId, StandardCharsets.UTF_8.name());
secret = URLEncoder.encode(secret, StandardCharsets.UTF_8.name());
String credentialsString = clientId + ":" + secret;
byte[] encodedBytes = Base64.getEncoder().encode(credentialsString.getBytes(StandardCharsets.UTF_8));
return new String(encodedBytes, StandardCharsets.UTF_8);
}
@EnableWebSecurity
@Import(OAuth2AuthorizationServerConfiguration.clreplaced)
static clreplaced AuthorizationServerConfiguration {
@Bean
RegisteredClientRepository registeredClientRepository() {
return registeredClientRepository;
}
@Bean
OAuth2AuthorizationService authorizationService() {
return authorizationService;
}
@Bean
JWKSource<SecurityContext> jwkSource() {
return jwkSource;
}
@Bean
OAuth2TokenCustomizer<JwtEncodingContext> jwtCustomizer() {
return context -> {
if (AuthorizationGrantType.REFRESH_TOKEN.equals(context.getAuthorizationGrantType())) {
Authentication principal = context.getPrincipal();
Set<String> authorities = principal.getAuthorities().stream().map(GrantedAuthority::getAuthority).collect(Collectors.toSet());
context.getClaims().claim(AUTHORITIES_CLAIM, authorities);
}
};
}
}
}
17
Source : OAuth2TokenRevocationEndpointFilter.java
with Apache License 2.0
from spring-projects-experimental
with Apache License 2.0
from spring-projects-experimental
/**
* A {@code Filter} for the OAuth 2.0 Token Revocation endpoint.
*
* @author Vivek Babu
* @author Joe Grandja
* @see OAuth2TokenRevocationAuthenticationProvider
* @see <a target="_blank" href="https://tools.ietf.org/html/rfc7009#section-2">Section 2 Token Revocation</a>
* @see <a target="_blank" href="https://tools.ietf.org/html/rfc7009#section-2.1">Section 2.1 Revocation Request</a>
* @since 0.0.3
*/
public clreplaced OAuth2TokenRevocationEndpointFilter extends OncePerRequestFilter {
/**
* The default endpoint {@code URI} for token revocation requests.
*/
public static final String DEFAULT_TOKEN_REVOCATION_ENDPOINT_URI = "/oauth2/revoke";
private final AuthenticationManager authenticationManager;
private final RequestMatcher tokenRevocationEndpointMatcher;
private final Converter<HttpServletRequest, Authentication> tokenRevocationAuthenticationConverter = new DefaultTokenRevocationAuthenticationConverter();
private final HttpMessageConverter<OAuth2Error> errorHttpResponseConverter = new OAuth2ErrorHttpMessageConverter();
/**
* Constructs an {@code OAuth2TokenRevocationEndpointFilter} using the provided parameters.
*
* @param authenticationManager the authentication manager
*/
public OAuth2TokenRevocationEndpointFilter(AuthenticationManager authenticationManager) {
this(authenticationManager, DEFAULT_TOKEN_REVOCATION_ENDPOINT_URI);
}
/**
* Constructs an {@code OAuth2TokenRevocationEndpointFilter} using the provided parameters.
*
* @param authenticationManager the authentication manager
* @param tokenRevocationEndpointUri the endpoint {@code URI} for token revocation requests
*/
public OAuth2TokenRevocationEndpointFilter(AuthenticationManager authenticationManager, String tokenRevocationEndpointUri) {
replacedert.notNull(authenticationManager, "authenticationManager cannot be null");
replacedert.hasText(tokenRevocationEndpointUri, "tokenRevocationEndpointUri cannot be empty");
this.authenticationManager = authenticationManager;
this.tokenRevocationEndpointMatcher = new AntPathRequestMatcher(tokenRevocationEndpointUri, HttpMethod.POST.name());
}
@Override
protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
if (!this.tokenRevocationEndpointMatcher.matches(request)) {
filterChain.doFilter(request, response);
return;
}
try {
this.authenticationManager.authenticate(this.tokenRevocationAuthenticationConverter.convert(request));
response.setStatus(HttpStatus.OK.value());
} catch (OAuth2AuthenticationException ex) {
SecurityContextHolder.clearContext();
sendErrorResponse(response, ex.getError());
}
}
private void sendErrorResponse(HttpServletResponse response, OAuth2Error error) throws IOException {
ServletServerHttpResponse httpResponse = new ServletServerHttpResponse(response);
httpResponse.setStatusCode(HttpStatus.BAD_REQUEST);
this.errorHttpResponseConverter.write(error, null, httpResponse);
}
private static void throwError(String errorCode, String parameterName) {
OAuth2Error error = new OAuth2Error(errorCode, "OAuth 2.0 Token Revocation Parameter: " + parameterName, "https://tools.ietf.org/html/rfc7009#section-2.1");
throw new OAuth2AuthenticationException(error);
}
private static clreplaced DefaultTokenRevocationAuthenticationConverter implements Converter<HttpServletRequest, Authentication> {
@Override
public Authentication convert(HttpServletRequest request) {
Authentication clientPrincipal = SecurityContextHolder.getContext().getAuthentication();
MultiValueMap<String, String> parameters = OAuth2EndpointUtils.getParameters(request);
// token (REQUIRED)
String token = parameters.getFirst(OAuth2ParameterNames2.TOKEN);
if (!StringUtils.hasText(token) || parameters.get(OAuth2ParameterNames2.TOKEN).size() != 1) {
throwError(OAuth2ErrorCodes.INVALID_REQUEST, OAuth2ParameterNames2.TOKEN);
}
// token_type_hint (OPTIONAL)
String tokenTypeHint = parameters.getFirst(OAuth2ParameterNames2.TOKEN_TYPE_HINT);
if (StringUtils.hasText(tokenTypeHint) && parameters.get(OAuth2ParameterNames2.TOKEN_TYPE_HINT).size() != 1) {
throwError(OAuth2ErrorCodes.INVALID_REQUEST, OAuth2ParameterNames2.TOKEN_TYPE_HINT);
}
return new OAuth2TokenRevocationAuthenticationToken(token, clientPrincipal, tokenTypeHint);
}
}
}
17
Source : DataFlowTemplate.java
with Apache License 2.0
from spring-cloud
with Apache License 2.0
from spring-cloud
/**
* Will augment the provided {@link RestTemplate} with the Jackson
*
* Furthermore, this method will also register the {@link Jackson2HalModule}
*
* @param restTemplate Can be null. Instantiates a new {@link RestTemplate} if null
* @return RestTemplate with the required Jackson Mixins
*/
public static RestTemplate prepareRestTemplate(RestTemplate restTemplate) {
if (restTemplate == null) {
restTemplate = new RestTemplate();
}
restTemplate.setErrorHandler(new VndErrorResponseErrorHandler(restTemplate.getMessageConverters()));
boolean containsMappingJackson2HttpMessageConverter = false;
for (HttpMessageConverter<?> converter : restTemplate.getMessageConverters()) {
if (converter instanceof MappingJackson2HttpMessageConverter) {
containsMappingJackson2HttpMessageConverter = true;
final MappingJackson2HttpMessageConverter jacksonConverter = (MappingJackson2HttpMessageConverter) converter;
jacksonConverter.getObjectMapper().registerModule(new Jackson2HalModule());
}
}
if (!containsMappingJackson2HttpMessageConverter) {
throw new IllegalArgumentException("The RestTemplate does not contain a required MappingJackson2HttpMessageConverter.");
}
return restTemplate;
}
17
Source : RequestResponseBodyMethodProcessorMockTests.java
with Apache License 2.0
from SourceHot
with Apache License 2.0
from SourceHot
/**
* Test fixture for {@link RequestResponseBodyMethodProcessor} delegating to a
* mock HttpMessageConverter.
*
* <p>Also see {@link RequestResponseBodyMethodProcessorTests}.
*
* @author Arjen Poutsma
* @author Rossen Stoyanchev
* @author Juergen Hoeller
*/
public clreplaced RequestResponseBodyMethodProcessorMockTests {
private HttpMessageConverter<String> stringMessageConverter;
private HttpMessageConverter<Resource> resourceMessageConverter;
private HttpMessageConverter<Object> resourceRegionMessageConverter;
private RequestResponseBodyMethodProcessor processor;
private ModelAndViewContainer mavContainer;
private MockHttpServletRequest servletRequest;
private MockHttpServletResponse servletResponse;
private NativeWebRequest webRequest;
private MethodParameter paramRequestBodyString;
private MethodParameter paramInt;
private MethodParameter paramValidBean;
private MethodParameter paramStringNotRequired;
private MethodParameter paramOptionalString;
private MethodParameter returnTypeString;
private MethodParameter returnTypeInt;
private MethodParameter returnTypeStringProduces;
private MethodParameter returnTypeResource;
@BeforeEach
@SuppressWarnings("unchecked")
public void setup() throws Exception {
stringMessageConverter = mock(HttpMessageConverter.clreplaced);
given(stringMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
resourceMessageConverter = mock(HttpMessageConverter.clreplaced);
given(resourceMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.ALL));
resourceRegionMessageConverter = mock(HttpMessageConverter.clreplaced);
given(resourceRegionMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.ALL));
processor = new RequestResponseBodyMethodProcessor(Arrays.asList(stringMessageConverter, resourceMessageConverter, resourceRegionMessageConverter));
mavContainer = new ModelAndViewContainer();
servletRequest = new MockHttpServletRequest();
servletRequest.setMethod("POST");
servletResponse = new MockHttpServletResponse();
webRequest = new ServletWebRequest(servletRequest, servletResponse);
Method methodHandle1 = getClreplaced().getMethod("handle1", String.clreplaced, Integer.TYPE);
paramRequestBodyString = new MethodParameter(methodHandle1, 0);
paramInt = new MethodParameter(methodHandle1, 1);
paramValidBean = new MethodParameter(getClreplaced().getMethod("handle2", SimpleBean.clreplaced), 0);
paramStringNotRequired = new MethodParameter(getClreplaced().getMethod("handle3", String.clreplaced), 0);
paramOptionalString = new MethodParameter(getClreplaced().getMethod("handle4", Optional.clreplaced), 0);
returnTypeString = new MethodParameter(methodHandle1, -1);
returnTypeInt = new MethodParameter(getClreplaced().getMethod("handle5"), -1);
returnTypeStringProduces = new MethodParameter(getClreplaced().getMethod("handle6"), -1);
returnTypeResource = new MethodParameter(getClreplaced().getMethod("handle7"), -1);
}
@Test
public void supportsParameter() {
replacedertThat(processor.supportsParameter(paramRequestBodyString)).as("RequestBody parameter not supported").isTrue();
replacedertThat(processor.supportsParameter(paramInt)).as("non-RequestBody parameter supported").isFalse();
}
@Test
public void supportsReturnType() {
replacedertThat(processor.supportsReturnType(returnTypeString)).as("ResponseBody return type not supported").isTrue();
replacedertThat(processor.supportsReturnType(returnTypeInt)).as("non-ResponseBody return type supported").isFalse();
}
@Test
public void resolveArgument() throws Exception {
MediaType contentType = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Content-Type", contentType.toString());
String body = "Foo";
servletRequest.setContent(body.getBytes(StandardCharsets.UTF_8));
given(stringMessageConverter.canRead(String.clreplaced, contentType)).willReturn(true);
given(stringMessageConverter.read(eq(String.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(body);
Object result = processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, new ValidatingBinderFactory());
replacedertThat(result).as("Invalid argument").isEqualTo(body);
replacedertThat(mavContainer.isRequestHandled()).as("The requestHandled flag shouldn't change").isFalse();
}
@Test
public void resolveArgumentNotValid() throws Exception {
replacedertThatExceptionOfType(MethodArgumentNotValidException.clreplaced).isThrownBy(() -> testResolveArgumentWithValidation(new SimpleBean(null))).satisfies(ex -> {
BindingResult bindingResult = ex.getBindingResult();
replacedertThat(bindingResult.getObjectName()).isEqualTo("simpleBean");
replacedertThat(bindingResult.getErrorCount()).isEqualTo(1);
replacedertThat(bindingResult.getFieldError("name")).isNotNull();
});
}
@Test
public void resolveArgumentValid() throws Exception {
testResolveArgumentWithValidation(new SimpleBean("name"));
}
private void testResolveArgumentWithValidation(SimpleBean simpleBean) throws Exception {
MediaType contentType = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Content-Type", contentType.toString());
servletRequest.setContent("payload".getBytes(StandardCharsets.UTF_8));
@SuppressWarnings("unchecked")
HttpMessageConverter<SimpleBean> beanConverter = mock(HttpMessageConverter.clreplaced);
given(beanConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
given(beanConverter.canRead(SimpleBean.clreplaced, contentType)).willReturn(true);
given(beanConverter.read(eq(SimpleBean.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(simpleBean);
processor = new RequestResponseBodyMethodProcessor(Collections.singletonList(beanConverter));
processor.resolveArgument(paramValidBean, mavContainer, webRequest, new ValidatingBinderFactory());
}
@Test
public void resolveArgumentCannotRead() throws Exception {
MediaType contentType = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Content-Type", contentType.toString());
servletRequest.setContent("payload".getBytes(StandardCharsets.UTF_8));
given(stringMessageConverter.canRead(String.clreplaced, contentType)).willReturn(false);
replacedertThatExceptionOfType(HttpMediaTypeNotSupportedException.clreplaced).isThrownBy(() -> processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null));
}
@Test
public void resolveArgumentNoContentType() throws Exception {
servletRequest.setContent("payload".getBytes(StandardCharsets.UTF_8));
given(stringMessageConverter.canRead(String.clreplaced, MediaType.APPLICATION_OCTET_STREAM)).willReturn(false);
replacedertThatExceptionOfType(HttpMediaTypeNotSupportedException.clreplaced).isThrownBy(() -> processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null));
}
@Test
public void resolveArgumentInvalidContentType() throws Exception {
this.servletRequest.setContentType("bad");
servletRequest.setContent("payload".getBytes(StandardCharsets.UTF_8));
replacedertThatExceptionOfType(HttpMediaTypeNotSupportedException.clreplaced).isThrownBy(() -> processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, null));
}
// SPR-9942
@Test
public void resolveArgumentRequiredNoContent() throws Exception {
servletRequest.setContentType(MediaType.TEXT_PLAIN_VALUE);
servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(stringMessageConverter.read(eq(String.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn(null);
replacedertThatExceptionOfType(HttpMessageNotReadableException.clreplaced).isThrownBy(() -> processor.resolveArgument(paramRequestBodyString, mavContainer, webRequest, new ValidatingBinderFactory()));
}
@Test
public void resolveArgumentNotGetRequests() throws Exception {
servletRequest.setMethod("GET");
servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.APPLICATION_OCTET_STREAM)).willReturn(false);
replacedertThat(processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory())).isNull();
}
@Test
public void resolveArgumentNotRequiredWithContent() throws Exception {
servletRequest.setContentType("text/plain");
servletRequest.setContent("body".getBytes());
given(stringMessageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(stringMessageConverter.read(eq(String.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn("body");
replacedertThat(processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory())).isEqualTo("body");
}
@Test
public void resolveArgumentNotRequiredNoContent() throws Exception {
servletRequest.setContentType("text/plain");
servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
replacedertThat(processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory())).isNull();
}
// SPR-13417
@Test
public void resolveArgumentNotRequiredNoContentNoContentType() throws Exception {
servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.APPLICATION_OCTET_STREAM)).willReturn(false);
replacedertThat(processor.resolveArgument(paramStringNotRequired, mavContainer, webRequest, new ValidatingBinderFactory())).isNull();
}
@Test
public void resolveArgumentOptionalWithContent() throws Exception {
servletRequest.setContentType("text/plain");
servletRequest.setContent("body".getBytes());
given(stringMessageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(stringMessageConverter.read(eq(String.clreplaced), isA(HttpInputMessage.clreplaced))).willReturn("body");
replacedertThat(processor.resolveArgument(paramOptionalString, mavContainer, webRequest, new ValidatingBinderFactory())).isEqualTo(Optional.of("body"));
}
@Test
public void resolveArgumentOptionalNoContent() throws Exception {
servletRequest.setContentType("text/plain");
servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
replacedertThat(processor.resolveArgument(paramOptionalString, mavContainer, webRequest, new ValidatingBinderFactory())).isEqualTo(Optional.empty());
}
@Test
public void resolveArgumentOptionalNoContentNoContentType() throws Exception {
servletRequest.setContent(new byte[0]);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.TEXT_PLAIN)).willReturn(true);
given(stringMessageConverter.canRead(String.clreplaced, MediaType.APPLICATION_OCTET_STREAM)).willReturn(false);
replacedertThat(processor.resolveArgument(paramOptionalString, mavContainer, webRequest, new ValidatingBinderFactory())).isEqualTo(Optional.empty());
}
@Test
public void handleReturnValue() throws Exception {
MediaType accepted = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Accept", accepted.toString());
String body = "Foo";
given(stringMessageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(stringMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
given(stringMessageConverter.canWrite(String.clreplaced, accepted)).willReturn(true);
processor.handleReturnValue(body, returnTypeString, mavContainer, webRequest);
replacedertThat(mavContainer.isRequestHandled()).as("The requestHandled flag wasn't set").isTrue();
verify(stringMessageConverter).write(eq(body), eq(accepted), isA(HttpOutputMessage.clreplaced));
}
@Test
public void handleReturnValueProduces() throws Exception {
String body = "Foo";
servletRequest.addHeader("Accept", "text/*");
servletRequest.setAttribute(HandlerMapping.PRODUCIBLE_MEDIA_TYPES_ATTRIBUTE, Collections.singleton(MediaType.TEXT_HTML));
given(stringMessageConverter.canWrite(String.clreplaced, MediaType.TEXT_HTML)).willReturn(true);
processor.handleReturnValue(body, returnTypeStringProduces, mavContainer, webRequest);
replacedertThat(mavContainer.isRequestHandled()).isTrue();
verify(stringMessageConverter).write(eq(body), eq(MediaType.TEXT_HTML), isA(HttpOutputMessage.clreplaced));
}
@Test
public void handleReturnValueNotAcceptable() throws Exception {
MediaType accepted = MediaType.APPLICATION_ATOM_XML;
servletRequest.addHeader("Accept", accepted.toString());
given(stringMessageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(stringMessageConverter.getSupportedMediaTypes()).willReturn(Arrays.asList(MediaType.TEXT_PLAIN));
given(stringMessageConverter.canWrite(String.clreplaced, accepted)).willReturn(false);
replacedertThatExceptionOfType(HttpMediaTypeNotAcceptableException.clreplaced).isThrownBy(() -> processor.handleReturnValue("Foo", returnTypeString, mavContainer, webRequest));
}
@Test
public void handleReturnValueNotAcceptableProduces() throws Exception {
MediaType accepted = MediaType.TEXT_PLAIN;
servletRequest.addHeader("Accept", accepted.toString());
given(stringMessageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(stringMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.TEXT_PLAIN));
given(stringMessageConverter.canWrite(String.clreplaced, accepted)).willReturn(false);
replacedertThatExceptionOfType(HttpMediaTypeNotAcceptableException.clreplaced).isThrownBy(() -> processor.handleReturnValue("Foo", returnTypeStringProduces, mavContainer, webRequest));
}
@Test
public void handleReturnTypeResource() throws Exception {
Resource returnValue = new ByteArrayResource("Content".getBytes(StandardCharsets.UTF_8));
given(resourceMessageConverter.canWrite(ByteArrayResource.clreplaced, null)).willReturn(true);
given(resourceMessageConverter.getSupportedMediaTypes()).willReturn(Collections.singletonList(MediaType.ALL));
given(resourceMessageConverter.canWrite(ByteArrayResource.clreplaced, MediaType.APPLICATION_OCTET_STREAM)).willReturn(true);
processor.handleReturnValue(returnValue, returnTypeResource, mavContainer, webRequest);
then(resourceMessageConverter).should(times(1)).write(any(ByteArrayResource.clreplaced), eq(MediaType.APPLICATION_OCTET_STREAM), any(HttpOutputMessage.clreplaced));
replacedertThat(servletResponse.getStatus()).isEqualTo(200);
}
// SPR-9841
@Test
public void handleReturnValueMediaTypeSuffix() throws Exception {
String body = "Foo";
MediaType accepted = MediaType.APPLICATION_XHTML_XML;
List<MediaType> supported = Collections.singletonList(MediaType.valueOf("application/*+xml"));
servletRequest.addHeader("Accept", accepted);
given(stringMessageConverter.canWrite(String.clreplaced, null)).willReturn(true);
given(stringMessageConverter.getSupportedMediaTypes()).willReturn(supported);
given(stringMessageConverter.canWrite(String.clreplaced, accepted)).willReturn(true);
processor.handleReturnValue(body, returnTypeStringProduces, mavContainer, webRequest);
replacedertThat(mavContainer.isRequestHandled()).isTrue();
verify(stringMessageConverter).write(eq(body), eq(accepted), isA(HttpOutputMessage.clreplaced));
}
@Test
public void handleReturnTypeResourceByteRange() throws Exception {
Resource returnValue = new ByteArrayResource("Content".getBytes(StandardCharsets.UTF_8));
servletRequest.addHeader("Range", "bytes=0-5");
given(resourceRegionMessageConverter.canWrite(any(), eq(null))).willReturn(true);
given(resourceRegionMessageConverter.canWrite(any(), eq(MediaType.APPLICATION_OCTET_STREAM))).willReturn(true);
processor.handleReturnValue(returnValue, returnTypeResource, mavContainer, webRequest);
then(resourceRegionMessageConverter).should(times(1)).write(anyCollection(), eq(MediaType.APPLICATION_OCTET_STREAM), argThat(outputMessage -> "bytes".equals(outputMessage.getHeaders().getFirst(HttpHeaders.ACCEPT_RANGES))));
replacedertThat(servletResponse.getStatus()).isEqualTo(206);
}
@Test
public void handleReturnTypeResourceIllegalByteRange() throws Exception {
Resource returnValue = new ByteArrayResource("Content".getBytes(StandardCharsets.UTF_8));
servletRequest.addHeader("Range", "illegal");
given(resourceRegionMessageConverter.canWrite(any(), eq(null))).willReturn(true);
given(resourceRegionMessageConverter.canWrite(any(), eq(MediaType.APPLICATION_OCTET_STREAM))).willReturn(true);
processor.handleReturnValue(returnValue, returnTypeResource, mavContainer, webRequest);
then(resourceRegionMessageConverter).should(never()).write(anyCollection(), eq(MediaType.APPLICATION_OCTET_STREAM), any(HttpOutputMessage.clreplaced));
replacedertThat(servletResponse.getStatus()).isEqualTo(416);
}
@SuppressWarnings("unused")
@ResponseBody
public String handle1(@RequestBody String s, int i) {
return s;
}
@SuppressWarnings("unused")
public void handle2(@Valid @RequestBody SimpleBean b) {
}
@SuppressWarnings("unused")
public void handle3(@RequestBody(required = false) String s) {
}
@SuppressWarnings("unused")
public void handle4(@RequestBody Optional<String> s) {
}
@SuppressWarnings("unused")
public int handle5() {
return 42;
}
@SuppressWarnings("unused")
@ResponseBody
public String handle6() {
return null;
}
@SuppressWarnings("unused")
@ResponseBody
public Resource handle7() {
return null;
}
private final clreplaced ValidatingBinderFactory implements WebDataBinderFactory {
@Override
public WebDataBinder createBinder(NativeWebRequest webRequest, @Nullable Object target, String objectName) throws Exception {
LocalValidatorFactoryBean validator = new LocalValidatorFactoryBean();
validator.afterPropertiesSet();
WebDataBinder dataBinder = new WebDataBinder(target, objectName);
dataBinder.setValidator(validator);
return dataBinder;
}
}
@SuppressWarnings("unused")
private static clreplaced SimpleBean {
@NotNull
private final String name;
public SimpleBean(String name) {
this.name = name;
}
public String getName() {
return name;
}
}
}
See More Examples