@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(); }
@Test public void encodeConnectWithLoginAndPasscode() throws UnsupportedEncodingException { MultiValueMap<String, String> extHeaders = new LinkedMultiValueMap<>(); extHeaders.add(StompHeaderAccessor.STOMP_LOGIN_HEADER, "joe"); extHeaders.add(StompHeaderAccessor.STOMP_PASSCODE_HEADER, "joe123"); StompHeaderAccessor headerAccessor = StompHeaderAccessor.create(StompCommand.CONNECT, extHeaders); Message<byte[]> message = MessageBuilder.createMessage(new byte[0], headerAccessor.getMessageHeaders()); byte[] bytes = new StompEncoder().encode(message); assertEquals("CONNECT\nlogin:joe\npasscode:joe123\n\n\0", new String(bytes, "UTF-8")); }
private Message<String> createMessage(String destination, String payload) { SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.create(SimpMessageType.MESSAGE); headers.setDestination(destination); return MessageBuilder.createMessage(payload, headers.getMessageHeaders()); }
@Test public void encodeFrameWithHeadersBody() { StompHeaderAccessor headers = StompHeaderAccessor.create(StompCommand.SEND); headers.addNativeHeader("a", "alpha"); Message<byte[]> frame = MessageBuilder.createMessage( "Message body".getBytes(), headers.getMessageHeaders()); assertEquals("SEND\na:alpha\ncontent-length:12\n\nMessage body\0", new String(encoder.encode(frame))); }
@Test public void encodeFrameWithNoHeadersAndNoBody() { StompHeaderAccessor headers = StompHeaderAccessor.create(StompCommand.DISCONNECT); Message<byte[]> frame = MessageBuilder.createMessage(new byte[0], headers.getMessageHeaders()); assertEquals("DISCONNECT\n\n\0", new String(encoder.encode(frame))); }
private Message<?> unsubscribeMessage(String sessionId, String subscriptionId) { SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor.create(SimpMessageType.UNSUBSCRIBE); accessor.setSessionId(sessionId); accessor.setSubscriptionId(subscriptionId); return MessageBuilder.createMessage("", accessor.getMessageHeaders()); }
public static MessageExchangeBuilder disconnectWithReceipt(String sessionId, String receiptId) { StompHeaderAccessor headers = StompHeaderAccessor.create(StompCommand.DISCONNECT); headers.setSessionId(sessionId); headers.setReceipt(receiptId); Message<?> message = MessageBuilder.createMessage(new byte[0], headers.getMessageHeaders()); MessageExchangeBuilder builder = new MessageExchangeBuilder(message); builder.expected.add(new StompReceiptFrameMessageMatcher(sessionId, receiptId)); return builder; }
@Test public void toNativeHeadersContentType() { SimpMessageHeaderAccessor simpHeaderAccessor = SimpMessageHeaderAccessor.create(); simpHeaderAccessor.setContentType(MimeType.valueOf("application/atom+xml")); Message<byte[]> message = MessageBuilder.createMessage(new byte[0], simpHeaderAccessor.getMessageHeaders()); StompHeaderAccessor stompHeaderAccessor = StompHeaderAccessor.wrap(message); Map<String, List<String>> map = stompHeaderAccessor.toNativeHeaderMap(); assertEquals("application/atom+xml", map.get(StompHeaderAccessor.STOMP_CONTENT_TYPE_HEADER).get(0)); }
@Test public void heartbeatNotSupportedByServer() { this.session.afterConnected(this.connection); verify(this.connection).send(any()); this.connectHeaders.setHeartbeat(new long[] {10000, 10000}); StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.CONNECTED); accessor.setVersion("1.2"); accessor.setHeartbeat(0, 0); accessor.setLeaveMutable(true); this.session.handleMessage(MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders())); verifyNoMoreInteractions(this.connection); }
@Test public void handleMessageToClientWithConnectedFrame() { StompHeaderAccessor headers = StompHeaderAccessor.create(StompCommand.CONNECTED); Message<byte[]> message = MessageBuilder.createMessage(EMPTY_PAYLOAD, headers.getMessageHeaders()); this.protocolHandler.handleMessageToClient(this.session, message); assertEquals(1, this.session.getSentMessages().size()); WebSocketMessage<?> textMessage = this.session.getSentMessages().get(0); assertEquals("CONNECTED\n" + "user-name:joe\n" + "\n" + "\u0000", textMessage.getPayload()); }
private Message<byte[]> connectMessage(String sessionId, String user) { StompHeaderAccessor headers = StompHeaderAccessor.create(StompCommand.CONNECT); headers.setSessionId(sessionId); headers.setUser(new TestPrincipal(user)); return MessageBuilder.createMessage(new byte[0], headers.getMessageHeaders()); }
@Test public void getAccessor() { StompHeaderAccessor headerAccessor = StompHeaderAccessor.create(StompCommand.CONNECT); Message<byte[]> message = MessageBuilder.createMessage(new byte[0], headerAccessor.getMessageHeaders()); assertSame(headerAccessor, MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class)); }
@Test public void doSendWithStompHeaders() { StompHeaderAccessor accessor = StompHeaderAccessor.create(StompCommand.SUBSCRIBE); accessor.setDestination("/user/queue/foo"); Message<?> message = MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders()); this.messagingTemplate.doSend("/queue/foo-user123", message); List<Message<byte[]>> messages = this.messageChannel.getMessages(); Message<byte[]> sentMessage = messages.get(0); MessageHeaderAccessor sentAccessor = MessageHeaderAccessor.getAccessor(sentMessage, MessageHeaderAccessor.class); assertEquals(StompHeaderAccessor.class, sentAccessor.getClass()); assertEquals("/queue/foo-user123", ((StompHeaderAccessor) sentAccessor).getDestination()); }
@Test public void getMutableAccessorNewInstanceMatchingType() { TestMessageHeaderAccessor expected = new TestMessageHeaderAccessor(); Message<?> message = MessageBuilder.createMessage("payload", expected.getMessageHeaders()); MessageHeaderAccessor actual = MessageHeaderAccessor.getMutableAccessor(message); assertNotNull(actual); assertTrue(actual.isMutable()); assertEquals(TestMessageHeaderAccessor.class, actual.getClass()); }
private Message<?> subscribeMessage(String sessionId, String subscriptionId, String dest, String selector) { SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor.create(SimpMessageType.SUBSCRIBE); accessor.setSessionId(sessionId); accessor.setSubscriptionId(subscriptionId); if (dest != null) { accessor.setDestination(dest); } if (selector != null) { accessor.setNativeHeader("selector", selector); } return MessageBuilder.createMessage("", accessor.getMessageHeaders()); }
@Test public void handleClientMessageProcessingErrorWithReceipt() throws Exception { String receiptId = "123"; StompHeaderAccessor clientHeaderAccessor = StompHeaderAccessor.create(StompCommand.SEND); clientHeaderAccessor.setReceipt(receiptId); MessageHeaders clientHeaders = clientHeaderAccessor.getMessageHeaders(); Message<byte[]> clientMessage = MessageBuilder.createMessage(new byte[0], clientHeaders); Message<byte[]> actual = this.handler.handleClientMessageProcessingError(clientMessage, new Exception()); StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(actual, StompHeaderAccessor.class); assertNotNull(accessor); assertEquals(receiptId, accessor.getReceiptId()); }
@Test public void testBuildMessageWithDefaultMutability() { MessageHeaderAccessor accessor = new MessageHeaderAccessor(); MessageHeaders headers = accessor.getMessageHeaders(); Message<?> message = MessageBuilder.createMessage("foo", headers); this.thrown.expect(IllegalStateException.class); this.thrown.expectMessage("Already immutable"); accessor.setHeader("foo", "bar"); assertSame(accessor, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class)); }
@Test public void setAttributesFromMessageWithMissingSessionAttributes() { this.thrown.expect(IllegalStateException.class); this.thrown.expectMessage(startsWith("No session attributes in")); SimpMessageHeaderAccessor headerAccessor = SimpMessageHeaderAccessor.create(); headerAccessor.setSessionId("session1"); Message<?> message = MessageBuilder.createMessage("", headerAccessor.getMessageHeaders()); SimpAttributesContextHolder.setAttributesFromMessage(message); }
@Test public void testBuildMessageWithMutableHeaders() { MessageHeaderAccessor accessor = new MessageHeaderAccessor(); accessor.setLeaveMutable(true); MessageHeaders headers = accessor.getMessageHeaders(); Message<?> message = MessageBuilder.createMessage("payload", headers); accessor.setHeader("foo", "bar"); assertEquals("bar", headers.get("foo")); assertSame(accessor, MessageHeaderAccessor.getAccessor(message, MessageHeaderAccessor.class)); }
@Test public void destinationExcluded() throws Exception { this.brokerRelay.start(); SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.create(SimpMessageType.MESSAGE); headers.setSessionId("sess1"); headers.setDestination("/user/daisy/foo"); this.brokerRelay.handleMessage(MessageBuilder.createMessage(new byte[0], headers.getMessageHeaders())); assertEquals(1, this.tcpClient.getSentMessages().size()); StompHeaderAccessor headers1 = this.tcpClient.getSentHeaders(0); assertEquals(StompCommand.CONNECT, headers1.getCommand()); assertEquals(StompBrokerRelayMessageHandler.SYSTEM_SESSION_ID, headers1.getSessionId()); }