private Message<String> startSession(String id) { this.messageHandler.start(); Message<String> connectMessage = createConnectMessage(id, new TestPrincipal("joe"), null); this.messageHandler.setTaskScheduler(this.taskScheduler); this.messageHandler.handleMessage(connectMessage); verify(this.clientOutChannel, times(1)).send(this.messageCaptor.capture()); reset(this.clientOutChannel); return connectMessage; }
@Before public void setup() { this.protocolHandler = new StompSubProtocolHandler(); this.channel = Mockito.mock(MessageChannel.class); this.messageCaptor = ArgumentCaptor.forClass(Message.class); when(this.channel.send(any())).thenReturn(true); this.session = new TestWebSocketSession(); this.session.setId("s1"); this.session.setPrincipal(new TestPrincipal("joe")); }
@Override public Message<?> preSend(Message<?> message, MessageChannel channel) { TestPrincipal user = new TestPrincipal(name); MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class).setUser(user); return message; } }
@Test public void readWriteIntervalCalculation() throws Exception { this.messageHandler.setHeartbeatValue(new long[] {1, 1}); this.messageHandler.setTaskScheduler(this.taskScheduler); this.messageHandler.start(); ArgumentCaptor<Runnable> taskCaptor = ArgumentCaptor.forClass(Runnable.class); verify(this.taskScheduler).scheduleWithFixedDelay(taskCaptor.capture(), eq(1L)); Runnable heartbeatTask = taskCaptor.getValue(); assertNotNull(heartbeatTask); String id = "sess1"; TestPrincipal user = new TestPrincipal("joe"); Message<String> connectMessage = createConnectMessage(id, user, new long[] {10000, 10000}); this.messageHandler.handleMessage(connectMessage); Thread.sleep(10); heartbeatTask.run(); verify(this.clientOutChannel, times(1)).send(this.messageCaptor.capture()); List<Message<?>> messages = this.messageCaptor.getAllValues(); assertEquals(1, messages.size()); assertEquals(SimpMessageType.CONNECT_ACK, messages.get(0).getHeaders().get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER)); }
@Test public void handleUnsubscribe() { TestPrincipal user = new TestPrincipal("joe"); Message<?> message = createMessage(SimpMessageType.UNSUBSCRIBE, user, "123", "/user/queue/foo"); UserDestinationResult actual = this.resolver.resolveDestination(message); assertEquals(1, actual.getTargetDestinations().size()); assertEquals("/queue/foo-user123", actual.getTargetDestinations().iterator().next()); }
@Test public void writeInactivity() throws Exception { this.messageHandler.setHeartbeatValue(new long[] {1, 0}); this.messageHandler.setTaskScheduler(this.taskScheduler); this.messageHandler.start(); ArgumentCaptor<Runnable> taskCaptor = ArgumentCaptor.forClass(Runnable.class); verify(this.taskScheduler).scheduleWithFixedDelay(taskCaptor.capture(), eq(1L)); Runnable heartbeatTask = taskCaptor.getValue(); assertNotNull(heartbeatTask); String id = "sess1"; TestPrincipal user = new TestPrincipal("joe"); Message<String> connectMessage = createConnectMessage(id, user, new long[] {0, 1}); this.messageHandler.handleMessage(connectMessage); Thread.sleep(10); heartbeatTask.run(); verify(this.clientOutChannel, times(2)).send(this.messageCaptor.capture()); List<Message<?>> messages = this.messageCaptor.getAllValues(); assertEquals(2, messages.size()); MessageHeaders headers = messages.get(0).getHeaders(); assertEquals(SimpMessageType.CONNECT_ACK, headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER)); headers = messages.get(1).getHeaders(); assertEquals(SimpMessageType.HEARTBEAT, headers.get(SimpMessageHeaderAccessor.MESSAGE_TYPE_HEADER)); assertEquals(id, headers.get(SimpMessageHeaderAccessor.SESSION_ID_HEADER)); assertEquals(user, headers.get(SimpMessageHeaderAccessor.USER_HEADER)); }
@Test // SPR-11325 public void handleSubscribeOneUserMultipleSessions() { TestSimpUser simpUser = new TestSimpUser("joe"); simpUser.addSessions(new TestSimpSession("123"), new TestSimpSession("456")); when(this.registry.getUser("joe")).thenReturn(simpUser); TestPrincipal user = new TestPrincipal("joe"); Message<?> message = createMessage(SimpMessageType.SUBSCRIBE, user, "456", "/user/queue/foo"); UserDestinationResult actual = this.resolver.resolveDestination(message); assertEquals(1, actual.getTargetDestinations().size()); assertEquals("/queue/foo-user456", actual.getTargetDestinations().iterator().next()); }
@Test public void handleMessageEncodedUserName() { String userName = "http://joe.openid.example.org/"; TestSimpUser simpUser = new TestSimpUser(userName); simpUser.addSessions(new TestSimpSession("openid123")); when(this.registry.getUser(userName)).thenReturn(simpUser); String destination = "/user/" + StringUtils.replace(userName, "/", "%2F") + "/queue/foo"; Message<?> message = createMessage(SimpMessageType.MESSAGE, new TestPrincipal("joe"), null, destination); UserDestinationResult actual = this.resolver.resolveDestination(message); assertEquals(1, actual.getTargetDestinations().size()); assertEquals("/queue/foo-useropenid123", actual.getTargetDestinations().iterator().next()); }
@Test // SPR-14044 public void handleSubscribeForDestinationWithoutLeadingSlash() { this.resolver.setRemoveLeadingSlash(true); TestPrincipal user = new TestPrincipal("joe"); String destination = "/user/jms.queue.call"; Message<?> message = createMessage(SimpMessageType.SUBSCRIBE, user, "123", destination); UserDestinationResult actual = this.resolver.resolveDestination(message); assertEquals(1, actual.getTargetDestinations().size()); assertEquals("jms.queue.call-user123", actual.getTargetDestinations().iterator().next()); assertEquals(destination, actual.getSubscribeDestination()); }
@Test // SPR-14044 public void handleMessageForDestinationWithDotSeparator() { this.resolver.setRemoveLeadingSlash(true); TestPrincipal user = new TestPrincipal("joe"); String destination = "/user/joe/jms.queue.call"; Message<?> message = createMessage(SimpMessageType.MESSAGE, user, "123", destination); UserDestinationResult actual = this.resolver.resolveDestination(message); assertEquals(1, actual.getTargetDestinations().size()); assertEquals("jms.queue.call-user123", actual.getTargetDestinations().iterator().next()); assertEquals("/user/jms.queue.call", actual.getSubscribeDestination()); }
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 // SPR-12444 public void handleMessageToOtherUser() { TestSimpUser otherSimpUser = new TestSimpUser("anna"); otherSimpUser.addSessions(new TestSimpSession("456")); when(this.registry.getUser("anna")).thenReturn(otherSimpUser); TestPrincipal user = new TestPrincipal("joe"); TestPrincipal otherUser = new TestPrincipal("anna"); String sourceDestination = "/user/anna/queue/foo"; Message<?> message = createMessage(SimpMessageType.MESSAGE, user, "456", sourceDestination); UserDestinationResult actual = this.resolver.resolveDestination(message); assertEquals(sourceDestination, actual.getSourceDestination()); assertEquals(1, actual.getTargetDestinations().size()); assertEquals("/queue/foo-user456", actual.getTargetDestinations().iterator().next()); assertEquals("/user/queue/foo", actual.getSubscribeDestination()); assertEquals(otherUser.getName(), actual.getUser()); }
@Test public void handleSubscribe() { TestPrincipal user = new TestPrincipal("joe"); String sourceDestination = "/user/queue/foo"; Message<?> message = createMessage(SimpMessageType.SUBSCRIBE, user, "123", sourceDestination); UserDestinationResult actual = this.resolver.resolveDestination(message); assertEquals(sourceDestination, actual.getSourceDestination()); assertEquals(1, actual.getTargetDestinations().size()); assertEquals("/queue/foo-user123", actual.getTargetDestinations().iterator().next()); assertEquals(sourceDestination, actual.getSubscribeDestination()); assertEquals(user.getName(), actual.getUser()); }
@Test public void handleMessageToClientWithSimpHeartbeat() { SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor.create(SimpMessageType.HEARTBEAT); accessor.setSessionId("s1"); accessor.setUser(new TestPrincipal("joe")); Message<byte[]> ackMessage = MessageBuilder.createMessage(EMPTY_PAYLOAD, accessor.getMessageHeaders()); this.protocolHandler.handleMessageToClient(this.session, ackMessage); assertEquals(1, this.session.getSentMessages().size()); TextMessage actual = (TextMessage) this.session.getSentMessages().get(0); assertEquals("\n", actual.getPayload()); }
@Test public void handleMessage() { TestPrincipal user = new TestPrincipal("joe"); String sourceDestination = "/user/joe/queue/foo"; Message<?> message = createMessage(SimpMessageType.MESSAGE, user, "123", sourceDestination); UserDestinationResult actual = this.resolver.resolveDestination(message); assertEquals(sourceDestination, actual.getSourceDestination()); assertEquals(1, actual.getTargetDestinations().size()); assertEquals("/queue/foo-user123", actual.getTargetDestinations().iterator().next()); assertEquals("/user/queue/foo", actual.getSubscribeDestination()); assertEquals(user.getName(), actual.getUser()); }
@Test public void getLogMessageWithValuesSet() { SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor.create(); accessor.setDestination("/destination"); accessor.setSubscriptionId("subscription"); accessor.setSessionId("session"); accessor.setUser(new TestPrincipal("user")); accessor.setSessionAttributes(Collections.<String, Object>singletonMap("key", "value")); assertEquals("MESSAGE destination=/destination subscriptionId=subscription " + "session=session user=user attributes[1] payload=p", accessor.getShortLogMessage("p")); }
@Test public void getDetailedLogMessageWithValuesSet() { SimpMessageHeaderAccessor accessor = SimpMessageHeaderAccessor.create(); accessor.setDestination("/destination"); accessor.setSubscriptionId("subscription"); accessor.setSessionId("session"); accessor.setUser(new TestPrincipal("user")); accessor.setSessionAttributes(Collections.<String, Object>singletonMap("key", "value")); accessor.setNativeHeader("nativeKey", "nativeValue"); assertEquals("MESSAGE destination=/destination subscriptionId=subscription " + "session=session user=user attributes={key=value} nativeHeaders=" + "{nativeKey=[nativeValue]} payload=p", accessor.getDetailedLogMessage("p")); }
private Message<byte[]> message(StompCommand command, String sessionId, String user, String destination) { StompHeaderAccessor accessor = StompHeaderAccessor.create(command); if (sessionId != null) { accessor.setSessionId(sessionId); } if (user != null) { accessor.setUser(new TestPrincipal(user)); } if (destination != null) { accessor.setDestination(destination); } accessor.setLeaveMutable(true); return MessageBuilder.createMessage(new byte[0], accessor.getMessageHeaders()); }
private Message<?> createWith(SimpMessageType type, String user, String sessionId, String destination) { SimpMessageHeaderAccessor headers = SimpMessageHeaderAccessor.create(type); if (destination != null) { headers.setDestination(destination); } if (user != null) { headers.setUser(new TestPrincipal(user)); } if (sessionId != null) { headers.setSessionId(sessionId); } return MessageBuilder.withPayload(new byte[0]).setHeaders(headers).build(); }
@Test public void ignoreMessage() { // no destination TestPrincipal user = new TestPrincipal("joe"); Message<?> message = createMessage(SimpMessageType.MESSAGE, user, "123", null); UserDestinationResult actual = this.resolver.resolveDestination(message); assertNull(actual); // not a user destination message = createMessage(SimpMessageType.MESSAGE, user, "123", "/queue/foo"); actual = this.resolver.resolveDestination(message); assertNull(actual); // subscribe + not a user destination message = createMessage(SimpMessageType.SUBSCRIBE, user, "123", "/queue/foo"); actual = this.resolver.resolveDestination(message); assertNull(actual); // no match on message type message = createMessage(SimpMessageType.CONNECT, user, "123", "user/joe/queue/foo"); actual = this.resolver.resolveDestination(message); assertNull(actual); }