Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Polish WebSocket/STOMP Java config

Browse Source 
Ensure configuration provided for WebSocketHandler's (eg interceptors,
or HandshakeHandler) are passed on to the SockJsService if congiured.

Better separate Servlet-specific parts of the configuration to make it
more obvious where non-Servlet alternatives could fit in.

Add more tests.

Improve WebSocket integration tests.
This commit is contained in:
Rossen Stoyanchev
2013-08-30 23:23:56 -04:00
parent 5d69700515
commit e21bbdd933
19 changed files with 1105 additions and 366 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
spring-websocket/src/test/java/org/springframework/web/socket/AbstractWebSocketIntegrationTests.java
View File

@@ -25,6 +25,7 @@ import org.junit.runners.Parameterized.Parameter;
import org.springframework.context.Lifecycle;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.socket.client.WebSocketClient;
import org.springframework.web.socket.server.DefaultHandshakeHandler;
import org.springframework.web.socket.server.HandshakeHandler;
@@ -52,14 +53,26 @@ public abstract class AbstractWebSocketIntegrationTests {
@Parameter(1)
public WebSocketClient webSocketClient;
protected AnnotationConfigWebApplicationContext wac;
@Before
public void setup() throws Exception {
this.wac = new AnnotationConfigWebApplicationContext();
this.wac.register(getAnnotatedConfigClasses());
this.wac.register(upgradeStrategyConfigTypes.get(this.server.getClass()));
if (this.webSocketClient instanceof Lifecycle) {
((Lifecycle) this.webSocketClient).start();
}
this.server.init(this.wac);
this.server.start();
}
protected abstract Class<?>[] getAnnotatedConfigClasses();
@After
public void teardown() throws Exception {
try {
@@ -76,10 +89,6 @@ public abstract class AbstractWebSocketIntegrationTests {
return "ws://localhost:" + this.server.getPort();
}
protected Class<?> getUpgradeStrategyConfigClass() {
return upgradeStrategyConfigTypes.get(this.server.getClass());
}
static abstract class AbstractRequestUpgradeStrategyConfig {

210
spring-websocket/src/test/java/org/springframework/web/socket/server/config/AbstractWebSocketHandlerRegistrationTests.java Normal file
View File

@@ -0,0 +1,210 @@
/*
* Copyright 2002-2013 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.socket.server.config;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket.adapter.TextWebSocketHandlerAdapter;
import org.springframework.web.socket.server.DefaultHandshakeHandler;
import org.springframework.web.socket.server.HandshakeHandler;
import org.springframework.web.socket.server.HandshakeInterceptor;
import org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor;
import org.springframework.web.socket.sockjs.SockJsService;
import org.springframework.web.socket.sockjs.transport.TransportType;
import org.springframework.web.socket.sockjs.transport.handler.DefaultSockJsService;
import org.springframework.web.socket.sockjs.transport.handler.WebSocketTransportHandler;
import static org.junit.Assert.*;
/**
* Test fixture for {@link AbstractWebSocketHandlerRegistration}.
*
* @author Rossen Stoyanchev
*/
public class AbstractWebSocketHandlerRegistrationTests {
private TestWebSocketHandlerRegistration registration;
private TaskScheduler taskScheduler;
@Before
public void setup() {
this.taskScheduler = Mockito.mock(TaskScheduler.class);
this.registration = new TestWebSocketHandlerRegistration(taskScheduler);
}
@Test
public void minimal() {
WebSocketHandler wsHandler = new TextWebSocketHandlerAdapter();
this.registration.addHandler(wsHandler, "/foo", "/bar");
List<Mapping> mappings = this.registration.getMappings();
assertEquals(2, mappings.size());
Mapping m1 = mappings.get(0);
assertEquals(wsHandler, m1.webSocketHandler);
assertEquals("/foo", m1.path);
Mapping m2 = mappings.get(1);
assertEquals(wsHandler, m2.webSocketHandler);
assertEquals("/bar", m2.path);
}
@Test
public void interceptors() {
WebSocketHandler wsHandler = new TextWebSocketHandlerAdapter();
HttpSessionHandshakeInterceptor interceptor = new HttpSessionHandshakeInterceptor();
this.registration.addHandler(wsHandler, "/foo").addInterceptors(interceptor);
List<Mapping> mappings = this.registration.getMappings();
assertEquals(1, mappings.size());
Mapping m1 = mappings.get(0);
assertEquals(wsHandler, m1.webSocketHandler);
assertEquals("/foo", m1.path);
assertArrayEquals(new HandshakeInterceptor[] { interceptor }, m1.interceptors);
}
@Test
public void interceptorsPassedToSockJsRegistration() {
WebSocketHandler wsHandler = new TextWebSocketHandlerAdapter();
HttpSessionHandshakeInterceptor interceptor = new HttpSessionHandshakeInterceptor();
this.registration.addHandler(wsHandler, "/foo").addInterceptors(interceptor).withSockJS();
List<Mapping> mappings = this.registration.getMappings();
assertEquals(1, mappings.size());
Mapping m1 = mappings.get(0);
assertEquals(wsHandler, m1.webSocketHandler);
assertEquals("/foo/**", m1.path);
assertNotNull(m1.sockJsService);
assertEquals(Arrays.asList(interceptor), m1.sockJsService.getHandshakeInterceptors());
}
@Test
public void handshakeHandler() {
WebSocketHandler wsHandler = new TextWebSocketHandlerAdapter();
HandshakeHandler handshakeHandler = new DefaultHandshakeHandler();
this.registration.addHandler(wsHandler, "/foo").setHandshakeHandler(handshakeHandler);
List<Mapping> mappings = this.registration.getMappings();
assertEquals(1, mappings.size());
Mapping m1 = mappings.get(0);
assertEquals(wsHandler, m1.webSocketHandler);
assertEquals("/foo", m1.path);
assertSame(handshakeHandler, m1.handshakeHandler);
}
@Test
public void handshakeHandlerPassedToSockJsRegistration() {
WebSocketHandler wsHandler = new TextWebSocketHandlerAdapter();
HandshakeHandler handshakeHandler = new DefaultHandshakeHandler();
this.registration.addHandler(wsHandler, "/foo").setHandshakeHandler(handshakeHandler).withSockJS();
List<Mapping> mappings = this.registration.getMappings();
assertEquals(1, mappings.size());
Mapping m1 = mappings.get(0);
assertEquals(wsHandler, m1.webSocketHandler);
assertEquals("/foo/**", m1.path);
assertNotNull(m1.sockJsService);
WebSocketTransportHandler transportHandler =
(WebSocketTransportHandler) m1.sockJsService.getTransportHandlers().get(TransportType.WEBSOCKET);
assertSame(handshakeHandler, transportHandler.getHandshakeHandler());
}
private static class TestWebSocketHandlerRegistration extends AbstractWebSocketHandlerRegistration<List<Mapping>> {
public TestWebSocketHandlerRegistration(TaskScheduler sockJsTaskScheduler) {
super(sockJsTaskScheduler);
}
@Override
protected List<Mapping> createMappings() {
return new ArrayList<>();
}
@Override
protected void addSockJsServiceMapping(List<Mapping> mappings, SockJsService sockJsService,
WebSocketHandler wsHandler, String pathPattern) {
mappings.add(new Mapping(wsHandler, pathPattern, sockJsService));
}
@Override
protected void addWebSocketHandlerMapping(List<Mapping> mappings,
WebSocketHandler wsHandler, HandshakeHandler handshakeHandler,
HandshakeInterceptor[] interceptors, String path) {
mappings.add(new Mapping(wsHandler, path, handshakeHandler, interceptors));
}
}
private static class Mapping {
private final WebSocketHandler webSocketHandler;
private final String path;
private final HandshakeHandler handshakeHandler;
private final HandshakeInterceptor[] interceptors;
private final DefaultSockJsService sockJsService;
public Mapping(WebSocketHandler handler, String path, SockJsService sockJsService) {
this.webSocketHandler = handler;
this.path = path;
this.handshakeHandler = null;
this.interceptors = null;
this.sockJsService = (DefaultSockJsService) sockJsService;
}
public Mapping(WebSocketHandler h, String path, HandshakeHandler hh, HandshakeInterceptor[] interceptors) {
this.webSocketHandler = h;
this.path = path;
this.handshakeHandler = hh;
this.interceptors = interceptors;
this.sockJsService = null;
}
}
}

22
spring-websocket/src/test/java/org/springframework/web/socket/server/config/WebSocketConfigurationTests.java
View File

@@ -27,7 +27,6 @@ import org.junit.runners.Parameterized.Parameters;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
import org.springframework.web.socket.AbstractWebSocketIntegrationTests;
import org.springframework.web.socket.JettyTestServer;
import org.springframework.web.socket.WebSocketSession;
@@ -54,33 +53,26 @@ public class WebSocketConfigurationTests extends AbstractWebSocketIntegrationTes
};
@Override
protected Class<?>[] getAnnotatedConfigClasses() {
return new Class<?>[] { TestWebSocketConfigurer.class };
}
@Test
public void registerWebSocketHandler() throws Exception {
AnnotationConfigWebApplicationContext cxt = new AnnotationConfigWebApplicationContext();
cxt.register(TestWebSocketConfigurer.class, getUpgradeStrategyConfigClass());
this.server.init(cxt);
this.server.start();
this.webSocketClient.doHandshake(new WebSocketHandlerAdapter(), getWsBaseUrl() + "/ws");
TestWebSocketHandler serverHandler = cxt.getBean(TestWebSocketHandler.class);
TestWebSocketHandler serverHandler = this.wac.getBean(TestWebSocketHandler.class);
assertTrue(serverHandler.latch.await(2, TimeUnit.SECONDS));
}
@Test
public void registerWebSocketHandlerWithSockJS() throws Exception {
AnnotationConfigWebApplicationContext cxt = new AnnotationConfigWebApplicationContext();
cxt.register(TestWebSocketConfigurer.class, getUpgradeStrategyConfigClass());
this.server.init(cxt);
this.server.start();
this.webSocketClient.doHandshake(new WebSocketHandlerAdapter(), getWsBaseUrl() + "/sockjs/websocket");
TestWebSocketHandler serverHandler = cxt.getBean(TestWebSocketHandler.class);
TestWebSocketHandler serverHandler = this.wac.getBean(TestWebSocketHandler.class);
assertTrue(serverHandler.latch.await(2, TimeUnit.SECONDS));
}