org.springframework.http.converter.HttpMessageConverter

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 7

19 Source : HttpMessageConvertersTests.java
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

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

/**
 * 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

/**
 * 配置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

/**
 * 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

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

/**
 * 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

@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

@Override
public HttpMessageConverters getObject() {
    HttpMessageConverter jacksonConverter = new MappingJackson2HttpMessageConverter(objectMapper());
    return new HttpMessageConverters(jacksonConverter);
}

19 Source : TitusProtobufHttpMessageConverter.java
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

/**
 * 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

/**
 * 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

@Bean
public HttpMessageConverters customConverters() {
    HttpMessageConverter<?> additional = new MappingJackson2HttpMessageConverter();
    return new HttpMessageConverters(additional);
}

19 Source : WxApiMessageConverterExtractor.java
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

@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

/**
 * 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

/**
 * {@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

@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

@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

@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

@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

@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

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

@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

/**
 * 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

/**
 * 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

/**
 * 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

/**
 * 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

/**
 * 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

/**
 * 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

/**
 * 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

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

/**
 * 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

@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

/**
 * 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

@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

@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

@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

@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

@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

@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

/**
 * 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

/**
 * 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

/**
 * @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

@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

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

/**
 * 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

/**
 * 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

/**
 * 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

/**
 * 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