@Test(expected = IllegalArgumentException.class) public void testIdHeaderValueReadOnly() { UUID id = UUID.randomUUID(); MessageBuilder.withPayload("test").setHeader(MessageHeaders.ID, id); }
@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(); }
@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(); }
@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); }
@Test(expected = IllegalArgumentException.class) public void testTimestampValueReadOnly() { Long timestamp = 12345L; MessageBuilder.withPayload("test").setHeader(MessageHeaders.TIMESTAMP, timestamp).build(); }
private Message<?> createMessage(SimpMessageType messageType, String destination, Map<String, Object> headers) { SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor.create(messageType); accessor.setSessionId("session1"); accessor.setSessionAttributes(new HashMap<>()); accessor.setDestination(destination); if (headers != null) { for (Map.Entry<String, Object> entry : headers.entrySet()) { accessor.setHeader(entry.getKey(), entry.getValue()); } } return MessageBuilder.withPayload(new byte[0]).setHeaders(accessor).build(); }
@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 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 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)); }
private Message<?> createInputMessage(String sessId, String subsId, String dest, Principal principal) { SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.create(); headers.setSessionId(sessId); headers.setSubscriptionId(subsId); headers.setDestination(dest); headers.setUser(principal); return MessageBuilder.withPayload(new byte[0]).copyHeaders(headers.toMap()).build(); }
@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)); }