@Override protected Object preProcessResponse(Object result) { MethodParameter returnType = getHandlerMethod().getReturnType(); if (result instanceof Message) { return MessageBuilder.fromMessage((Message<?>) result) .setHeader(AbstractMessageSendingTemplate.CONVERSION_HINT_HEADER, returnType).build(); } return MessageBuilder.withPayload(result).setHeader( AbstractMessageSendingTemplate.CONVERSION_HINT_HEADER, returnType).build(); }
@Override public Message<?> toMessage(Object payload, @Nullable MessageHeaders headers) { if (headers != null) { MessageHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(headers, MessageHeaderAccessor.class); if (accessor != null && accessor.isMutable()) { return MessageBuilder.createMessage(payload, accessor.getMessageHeaders()); } } return MessageBuilder.withPayload(payload).copyHeaders(headers).build(); }
private Message<byte[]> message(SimpMessageType messageType) { MessageBuilder<byte[]> builder = MessageBuilder.withPayload(new byte[0]); if (messageType != null) { builder.setHeader(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER, messageType); } return builder.build(); }
@Test(expected = MessageConversionException.class) public void fromMessageValidXmlWithUnknownProperty() throws IOException { String payload = "<myBean><age>42</age><myBean>"; Message<?> message = MessageBuilder.withPayload(payload.getBytes(StandardCharsets.UTF_8)).build(); this.converter.fromMessage(message, MyBean.class); }
@Test public void resolveNotRequired() throws Exception { Message<?> emptyByteArrayMessage = MessageBuilder.withPayload(new byte[0]).build(); assertNull(this.resolver.resolveArgument(this.paramAnnotatedNotRequired, emptyByteArrayMessage)); Message<?> emptyStringMessage = MessageBuilder.withPayload("").build(); assertNull(this.resolver.resolveArgument(this.paramAnnotatedNotRequired, emptyStringMessage)); Message<?> notEmptyMessage = MessageBuilder.withPayload("ABC".getBytes()).build(); assertEquals("ABC", this.resolver.resolveArgument(this.paramAnnotatedNotRequired, notEmptyMessage)); }
@Test public void resolveNonAnnotatedParameter() throws Exception { Message<?> notEmptyMessage = MessageBuilder.withPayload("ABC".getBytes()).build(); assertEquals("ABC", this.resolver.resolveArgument(this.paramNotAnnotated, notEmptyMessage)); Message<?> emptyStringMessage = MessageBuilder.withPayload("").build(); thrown.expect(MethodArgumentNotValidException.class); this.resolver.resolveArgument(this.paramValidated, emptyStringMessage); }
@Test public void fromMessageNoContentTypeHeader() { Message<byte[]> message = MessageBuilder.withPayload("ABC".getBytes()).build(); assertEquals("ABC", this.converter.fromMessage(message, String.class)); }
@Test(expected = MessageHandlingException.class) public void resolveArgumentNotFound() throws Exception { Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).build(); this.resolver.resolveArgument(this.paramAnnotated, message); }
@Test(expected = MessageHandlingException.class) public void resolveArgumentNotFound() throws Exception { Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).build(); this.resolver.resolveArgument(this.paramRequired, message); }
@JsonView(Summary.class) public Message<SampleResponse> replyJacksonMessageAndJsonView(Message<String> input) { return MessageBuilder.withPayload(createSampleResponse(input.getPayload())) .setHeader("foo", "bar").build(); }
@Test public void createIdRegenerated() { Message<String> message1 = MessageBuilder.withPayload("test") .setHeader("foo", "bar").build(); Message<String> message2 = MessageBuilder.fromMessage(message1).setHeader("another", 1).build(); assertEquals("bar", message2.getHeaders().get("foo")); assertNotSame(message1.getHeaders().getId(), message2.getHeaders().getId()); }
@Test public void resolveRequiredEmptyNonAnnotatedParameter() throws Exception { Message<?> message = MessageBuilder.withPayload("").build(); thrown.expect(MethodArgumentNotValidException.class); // Required but empty this.resolver.resolveArgument(this.paramNotAnnotated, message); }
@Test public void supportsMimeTypeNotSpecified() { Message<String> message = MessageBuilder.withPayload("ABC").build(); assertEquals("success-from", this.converter.fromMessage(message, String.class)); }
@Test public void fromMessageCharset() { String payload = "H\u00e9llo W\u00f6rld"; Message<byte[]> message = MessageBuilder.withPayload(payload.getBytes(StandardCharsets.ISO_8859_1)) .setHeader(MessageHeaders.CONTENT_TYPE, new MimeType("text", "plain", StandardCharsets.ISO_8859_1)).build(); assertEquals(payload, this.converter.fromMessage(message, String.class)); }
@Test public void fromMessage() throws Exception { String payload = "<myBean><name>Foo</name></myBean>"; Message<?> message = MessageBuilder.withPayload(payload.getBytes(StandardCharsets.UTF_8)).build(); MyBean actual = (MyBean) this.converter.fromMessage(message, MyBean.class); assertNotNull(actual); assertEquals("Foo", actual.getName()); }
@Test public void supportsMimeTypeNotSupported() { Message<String> message = MessageBuilder.withPayload( "ABC").setHeader(MessageHeaders.CONTENT_TYPE, MimeTypeUtils.APPLICATION_JSON).build(); assertNull(this.converter.fromMessage(message, String.class)); }
@Test public void supportsTargetClass() { Message<String> message = MessageBuilder.withPayload("ABC").build(); assertEquals("success-from", this.converter.fromMessage(message, String.class)); assertNull(this.converter.fromMessage(message, Integer.class)); }
@Test // SPR-11326 public void resolveArgumentNativeHeader() throws Exception { TestMessageHeaderAccessor headers = new TestMessageHeaderAccessor(); headers.setNativeHeader("param1", "foo"); Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).setHeaders(headers).build(); assertEquals("foo", this.resolver.resolveArgument(this.paramRequired, message)); }
@Test public void resolveArgumentNativeHeaderAmbiguity() throws Exception { TestMessageHeaderAccessor headers = new TestMessageHeaderAccessor(); headers.setHeader("param1", "foo"); headers.setNativeHeader("param1", "native-foo"); Message<byte[]> message = MessageBuilder.withPayload(new byte[0]).setHeaders(headers).build(); assertEquals("foo", this.resolver.resolveArgument(this.paramRequired, message)); assertEquals("native-foo", this.resolver.resolveArgument(this.paramNativeHeader, message)); }
@Test public void simpleObject() throws Exception { Session session = mock(Session.class); Serializable payload = mock(Serializable.class); ObjectMessage jmsMessage = mock(ObjectMessage.class); given(session.createObjectMessage(payload)).willReturn(jmsMessage); this.converter.toMessage(MessageBuilder.withPayload(payload).build(), session); verify(session).createObjectMessage(payload); }