MirrorMirror
/
Signal-Server
mirror of https://github.com/signalapp/Signal-Server.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Migrate websocket-resources test to JUnit 5 and .editorconfig

This commit is contained in:
Chris Eager 2021-08-13 14:33:30 -05:00 committed by Chris Eager
parent 19f7b207b7
commit bd820e6d2e
2 changed files with 237 additions and 190 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

359
websocket-resources/src/test/java/org/whispersystems/websocket/WebSocketResourceProviderTest.java
View File

@ -4,6 +4,16 @@
*/ */
package org.whispersystems.websocket; package org.whispersystems.websocket;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.anyInt;
import static org.mockito.Mockito.anyString;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import com.fasterxml.jackson.annotation.JsonProperty; import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonProcessingException; import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.ObjectMapper;
@ -12,27 +22,15 @@ import com.google.protobuf.InvalidProtocolBufferException;
import io.dropwizard.auth.Auth; import io.dropwizard.auth.Auth;
import io.dropwizard.jersey.DropwizardResourceConfig; import io.dropwizard.jersey.DropwizardResourceConfig;
import io.dropwizard.jersey.jackson.JacksonMessageBodyProvider; import io.dropwizard.jersey.jackson.JacksonMessageBodyProvider;
import org.eclipse.jetty.websocket.api.CloseStatus; import java.io.OutputStream;
import org.eclipse.jetty.websocket.api.RemoteEndpoint; import java.nio.ByteBuffer;
import org.eclipse.jetty.websocket.api.Session; import java.security.Principal;
import org.eclipse.jetty.websocket.api.UpgradeRequest; import java.util.Arrays;
import org.eclipse.jetty.websocket.api.WriteCallback; import java.util.LinkedList;
import org.glassfish.jersey.server.ApplicationHandler; import java.util.List;
import org.glassfish.jersey.server.ContainerRequest; import java.util.Map;
import org.glassfish.jersey.server.ContainerResponse; import java.util.Optional;
import org.glassfish.jersey.server.ResourceConfig; import java.util.concurrent.CompletableFuture;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.stubbing.Answer;
import org.whispersystems.websocket.auth.WebsocketAuthValueFactoryProvider;
import org.whispersystems.websocket.logging.WebsocketRequestLog;
import org.whispersystems.websocket.messages.protobuf.ProtobufWebSocketMessageFactory;
import org.whispersystems.websocket.messages.protobuf.SubProtocol;
import org.whispersystems.websocket.session.WebSocketSession;
import org.whispersystems.websocket.session.WebSocketSessionContext;
import org.whispersystems.websocket.session.WebSocketSessionContextValueFactoryProvider;
import org.whispersystems.websocket.setup.WebSocketConnectListener;
import javax.validation.Valid; import javax.validation.Valid;
import javax.validation.constraints.Min; import javax.validation.constraints.Min;
import javax.validation.constraints.NotEmpty; import javax.validation.constraints.NotEmpty;
@ -48,41 +46,42 @@ import javax.ws.rs.core.MultivaluedMap;
import javax.ws.rs.core.Response; import javax.ws.rs.core.Response;
import javax.ws.rs.ext.ExceptionMapper; import javax.ws.rs.ext.ExceptionMapper;
import javax.ws.rs.ext.Provider; import javax.ws.rs.ext.Provider;
import java.io.OutputStream; import org.eclipse.jetty.websocket.api.CloseStatus;
import java.nio.ByteBuffer; import org.eclipse.jetty.websocket.api.RemoteEndpoint;
import java.security.Principal; import org.eclipse.jetty.websocket.api.Session;
import java.util.Arrays; import org.eclipse.jetty.websocket.api.UpgradeRequest;
import java.util.LinkedList; import org.eclipse.jetty.websocket.api.WriteCallback;
import java.util.List; import org.glassfish.jersey.server.ApplicationHandler;
import java.util.Map; import org.glassfish.jersey.server.ContainerRequest;
import java.util.Optional; import org.glassfish.jersey.server.ContainerResponse;
import java.util.concurrent.CompletableFuture; import org.glassfish.jersey.server.ResourceConfig;
import org.junit.jupiter.api.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.stubbing.Answer;
import org.whispersystems.websocket.auth.WebsocketAuthValueFactoryProvider;
import org.whispersystems.websocket.logging.WebsocketRequestLog;
import org.whispersystems.websocket.messages.protobuf.ProtobufWebSocketMessageFactory;
import org.whispersystems.websocket.messages.protobuf.SubProtocol;
import org.whispersystems.websocket.session.WebSocketSession;
import org.whispersystems.websocket.session.WebSocketSessionContext;
import org.whispersystems.websocket.session.WebSocketSessionContextValueFactoryProvider;
import org.whispersystems.websocket.setup.WebSocketConnectListener;
import static org.assertj.core.api.Assertions.assertThat; class WebSocketResourceProviderTest {
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.anyInt;
import static org.mockito.Mockito.anyString;
import static org.mockito.Mockito.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
public class WebSocketResourceProviderTest {
@Test @Test
public void testOnConnect() { void testOnConnect() {
ApplicationHandler applicationHandler = mock(ApplicationHandler.class ); ApplicationHandler applicationHandler = mock(ApplicationHandler.class);
WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class ); WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class);
WebSocketConnectListener connectListener = mock(WebSocketConnectListener.class); WebSocketConnectListener connectListener = mock(WebSocketConnectListener.class);
WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1",
applicationHandler, requestLog, applicationHandler, requestLog,
new TestPrincipal("fooz"), new TestPrincipal("fooz"),
new ProtobufWebSocketMessageFactory(), new ProtobufWebSocketMessageFactory(),
Optional.of(connectListener), Optional.of(connectListener),
30000 ); 30000);
Session session = mock(Session.class ); Session session = mock(Session.class);
UpgradeRequest request = mock(UpgradeRequest.class); UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request); when(session.getUpgradeRequest()).thenReturn(request);
@ -93,21 +92,23 @@ public class WebSocketResourceProviderTest {
verify(session, never()).close(); verify(session, never()).close();
verify(session, never()).close(any(CloseStatus.class)); verify(session, never()).close(any(CloseStatus.class));
ArgumentCaptor<WebSocketSessionContext> contextArgumentCaptor = ArgumentCaptor.forClass(WebSocketSessionContext.class); ArgumentCaptor<WebSocketSessionContext> contextArgumentCaptor = ArgumentCaptor.forClass(
WebSocketSessionContext.class);
verify(connectListener).onWebSocketConnect(contextArgumentCaptor.capture()); verify(connectListener).onWebSocketConnect(contextArgumentCaptor.capture());
assertThat(contextArgumentCaptor.getValue().getAuthenticated(TestPrincipal.class).getName()).isEqualTo("fooz"); assertThat(contextArgumentCaptor.getValue().getAuthenticated(TestPrincipal.class).getName()).isEqualTo("fooz");
} }
@Test @Test
public void testMockedRouteMessageSuccess() throws Exception { void testMockedRouteMessageSuccess() throws Exception {
ApplicationHandler applicationHandler = mock(ApplicationHandler.class ); ApplicationHandler applicationHandler = mock(ApplicationHandler.class);
WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class); WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class);
WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler, requestLog, new TestPrincipal("foo"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000); WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler,
requestLog, new TestPrincipal("foo"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000);
Session session = mock(Session.class ); Session session = mock(Session.class);
RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class); RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
UpgradeRequest request = mock(UpgradeRequest.class); UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request); when(session.getUpgradeRequest()).thenReturn(request);
when(session.getRemote()).thenReturn(remoteEndpoint); when(session.getRemote()).thenReturn(remoteEndpoint);
@ -145,12 +146,13 @@ public class WebSocketResourceProviderTest {
verify(session, never()).close(); verify(session, never()).close();
verify(session, never()).close(any(CloseStatus.class)); verify(session, never()).close(any(CloseStatus.class));
byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/bar", new LinkedList<>(), Optional.of("hello world!".getBytes())).toByteArray(); byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/bar",
new LinkedList<>(), Optional.of("hello world!".getBytes())).toByteArray();
provider.onWebSocketBinary(message, 0, message.length); provider.onWebSocketBinary(message, 0, message.length);
ArgumentCaptor<ContainerRequest> requestCaptor = ArgumentCaptor.forClass(ContainerRequest.class); ArgumentCaptor<ContainerRequest> requestCaptor = ArgumentCaptor.forClass(ContainerRequest.class);
ArgumentCaptor<ByteBuffer> responseCaptor = ArgumentCaptor.forClass(ByteBuffer.class ); ArgumentCaptor<ByteBuffer> responseCaptor = ArgumentCaptor.forClass(ByteBuffer.class);
verify(applicationHandler).apply(requestCaptor.capture(), any(OutputStream.class)); verify(applicationHandler).apply(requestCaptor.capture(), any(OutputStream.class));
@ -163,27 +165,31 @@ public class WebSocketResourceProviderTest {
verify(requestLog).log(eq("127.0.0.1"), eq(bundledRequest), eq(response)); verify(requestLog).log(eq("127.0.0.1"), eq(bundledRequest), eq(response));
verify(remoteEndpoint).sendBytesByFuture(responseCaptor.capture()); verify(remoteEndpoint).sendBytesByFuture(responseCaptor.capture());
SubProtocol.WebSocketMessage responseMessageContainer = SubProtocol.WebSocketMessage.parseFrom(responseCaptor.getValue().array()); SubProtocol.WebSocketMessage responseMessageContainer = SubProtocol.WebSocketMessage.parseFrom(
responseCaptor.getValue().array());
assertThat(responseMessageContainer.getResponse().getId()).isEqualTo(111L); assertThat(responseMessageContainer.getResponse().getId()).isEqualTo(111L);
assertThat(responseMessageContainer.getResponse().getStatus()).isEqualTo(200); assertThat(responseMessageContainer.getResponse().getStatus()).isEqualTo(200);
assertThat(responseMessageContainer.getResponse().getMessage()).isEqualTo("OK"); assertThat(responseMessageContainer.getResponse().getMessage()).isEqualTo("OK");
assertThat(responseMessageContainer.getResponse().getBody()).isEqualTo(ByteString.copyFrom("hello world!".getBytes())); assertThat(responseMessageContainer.getResponse().getBody()).isEqualTo(
ByteString.copyFrom("hello world!".getBytes()));
} }
@Test @Test
public void testMockedRouteMessageFailure() throws Exception { void testMockedRouteMessageFailure() throws Exception {
ApplicationHandler applicationHandler = mock(ApplicationHandler.class ); ApplicationHandler applicationHandler = mock(ApplicationHandler.class);
WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class); WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class);
WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler, requestLog, new TestPrincipal("foo"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000); WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler,
requestLog, new TestPrincipal("foo"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000);
Session session = mock(Session.class ); Session session = mock(Session.class);
RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class); RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
UpgradeRequest request = mock(UpgradeRequest.class); UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request); when(session.getUpgradeRequest()).thenReturn(request);
when(session.getRemote()).thenReturn(remoteEndpoint); when(session.getRemote()).thenReturn(remoteEndpoint);
when(applicationHandler.apply(any(ContainerRequest.class), any(OutputStream.class))).thenReturn(CompletableFuture.failedFuture(new IllegalStateException("foo"))); when(applicationHandler.apply(any(ContainerRequest.class), any(OutputStream.class))).thenReturn(
CompletableFuture.failedFuture(new IllegalStateException("foo")));
provider.onWebSocketConnect(session); provider.onWebSocketConnect(session);
@ -191,7 +197,8 @@ public class WebSocketResourceProviderTest {
verify(session, never()).close(); verify(session, never()).close();
verify(session, never()).close(any(CloseStatus.class)); verify(session, never()).close(any(CloseStatus.class));
byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/bar", new LinkedList<>(), Optional.of("hello world!".getBytes())).toByteArray(); byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/bar",
new LinkedList<>(), Optional.of("hello world!".getBytes())).toByteArray();
provider.onWebSocketBinary(message, 0, message.length); provider.onWebSocketBinary(message, 0, message.length);
@ -209,34 +216,37 @@ public class WebSocketResourceProviderTest {
verify(remoteEndpoint).sendBytesByFuture(responseCaptor.capture()); verify(remoteEndpoint).sendBytesByFuture(responseCaptor.capture());
SubProtocol.WebSocketMessage responseMessageContainer = SubProtocol.WebSocketMessage.parseFrom(responseCaptor.getValue().array()); SubProtocol.WebSocketMessage responseMessageContainer = SubProtocol.WebSocketMessage.parseFrom(
responseCaptor.getValue().array());
assertThat(responseMessageContainer.getResponse().getStatus()).isEqualTo(500); assertThat(responseMessageContainer.getResponse().getStatus()).isEqualTo(500);
assertThat(responseMessageContainer.getResponse().getMessage()).isEqualTo("Error response"); assertThat(responseMessageContainer.getResponse().getMessage()).isEqualTo("Error response");
assertThat(responseMessageContainer.getResponse().hasBody()).isFalse(); assertThat(responseMessageContainer.getResponse().hasBody()).isFalse();
} }
@Test @Test
public void testActualRouteMessageSuccess() throws InvalidProtocolBufferException { void testActualRouteMessageSuccess() throws InvalidProtocolBufferException {
ResourceConfig resourceConfig = new DropwizardResourceConfig(); ResourceConfig resourceConfig = new DropwizardResourceConfig();
resourceConfig.register(new TestResource()); resourceConfig.register(new TestResource());
resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder()); resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder());
resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class)); resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class));
resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper())); resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper()));
ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig); ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig);
WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class); WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class);
WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler, requestLog, new TestPrincipal("foo"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000); WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler,
requestLog, new TestPrincipal("foo"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000);
Session session = mock(Session.class ); Session session = mock(Session.class);
RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class); RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
UpgradeRequest request = mock(UpgradeRequest.class); UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request); when(session.getUpgradeRequest()).thenReturn(request);
when(session.getRemote()).thenReturn(remoteEndpoint); when(session.getRemote()).thenReturn(remoteEndpoint);
provider.onWebSocketConnect(session); provider.onWebSocketConnect(session);
byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/v1/test/hello", new LinkedList<>(), Optional.empty()).toByteArray(); byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/v1/test/hello",
new LinkedList<>(), Optional.empty()).toByteArray();
provider.onWebSocketBinary(message, 0, message.length); provider.onWebSocketBinary(message, 0, message.length);
@ -253,28 +263,29 @@ public class WebSocketResourceProviderTest {
} }
@Test @Test
public void testActualRouteMessageNotFound() throws InvalidProtocolBufferException { void testActualRouteMessageNotFound() throws InvalidProtocolBufferException {
ResourceConfig resourceConfig = new DropwizardResourceConfig(); ResourceConfig resourceConfig = new DropwizardResourceConfig();
resourceConfig.register(new TestResource()); resourceConfig.register(new TestResource());
resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder()); resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder());
resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class)); resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class));
resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper())); resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper()));
ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig);
WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class);
WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler,
requestLog, new TestPrincipal("foo"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000);
ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig); Session session = mock(Session.class);
WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class);
WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler, requestLog, new TestPrincipal("foo"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000);
Session session = mock(Session.class );
RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class); RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
UpgradeRequest request = mock(UpgradeRequest.class); UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request); when(session.getUpgradeRequest()).thenReturn(request);
when(session.getRemote()).thenReturn(remoteEndpoint); when(session.getRemote()).thenReturn(remoteEndpoint);
provider.onWebSocketConnect(session); provider.onWebSocketConnect(session);
byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/v1/test/doesntexist", new LinkedList<>(), Optional.empty()).toByteArray(); byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET",
"/v1/test/doesntexist", new LinkedList<>(), Optional.empty()).toByteArray();
provider.onWebSocketBinary(message, 0, message.length); provider.onWebSocketBinary(message, 0, message.length);
@ -291,27 +302,30 @@ public class WebSocketResourceProviderTest {
} }
@Test @Test
public void testActualRouteMessageAuthorized() throws InvalidProtocolBufferException { void testActualRouteMessageAuthorized() throws InvalidProtocolBufferException {
ResourceConfig resourceConfig = new DropwizardResourceConfig(); ResourceConfig resourceConfig = new DropwizardResourceConfig();
resourceConfig.register(new TestResource()); resourceConfig.register(new TestResource());
resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder()); resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder());
resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class)); resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class));
resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper())); resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper()));
ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig); ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig);
WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class); WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class);
WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler, requestLog, new TestPrincipal("authorizedUserName"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000); WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler,
requestLog, new TestPrincipal("authorizedUserName"), new ProtobufWebSocketMessageFactory(), Optional.empty(),
30000);
Session session = mock(Session.class ); Session session = mock(Session.class);
RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class); RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
UpgradeRequest request = mock(UpgradeRequest.class); UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request); when(session.getUpgradeRequest()).thenReturn(request);
when(session.getRemote()).thenReturn(remoteEndpoint); when(session.getRemote()).thenReturn(remoteEndpoint);
provider.onWebSocketConnect(session); provider.onWebSocketConnect(session);
byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/v1/test/world", new LinkedList<>(), Optional.empty()).toByteArray(); byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/v1/test/world",
new LinkedList<>(), Optional.empty()).toByteArray();
provider.onWebSocketBinary(message, 0, message.length); provider.onWebSocketBinary(message, 0, message.length);
@ -328,27 +342,29 @@ public class WebSocketResourceProviderTest {
} }
@Test @Test
public void testActualRouteMessageUnauthorized() throws InvalidProtocolBufferException { void testActualRouteMessageUnauthorized() throws InvalidProtocolBufferException {
ResourceConfig resourceConfig = new DropwizardResourceConfig(); ResourceConfig resourceConfig = new DropwizardResourceConfig();
resourceConfig.register(new TestResource()); resourceConfig.register(new TestResource());
resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder()); resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder());
resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class)); resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class));
resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper())); resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper()));
ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig); ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig);
WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class); WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class);
WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler, requestLog, null, new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000); WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler,
requestLog, null, new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000);
Session session = mock(Session.class ); Session session = mock(Session.class);
RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class); RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
UpgradeRequest request = mock(UpgradeRequest.class); UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request); when(session.getUpgradeRequest()).thenReturn(request);
when(session.getRemote()).thenReturn(remoteEndpoint); when(session.getRemote()).thenReturn(remoteEndpoint);
provider.onWebSocketConnect(session); provider.onWebSocketConnect(session);
byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/v1/test/world", new LinkedList<>(), Optional.empty()).toByteArray(); byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/v1/test/world",
new LinkedList<>(), Optional.empty()).toByteArray();
provider.onWebSocketBinary(message, 0, message.length); provider.onWebSocketBinary(message, 0, message.length);
@ -364,27 +380,29 @@ public class WebSocketResourceProviderTest {
} }
@Test @Test
public void testActualRouteMessageOptionalAuthorizedPresent() throws InvalidProtocolBufferException { void testActualRouteMessageOptionalAuthorizedPresent() throws InvalidProtocolBufferException {
ResourceConfig resourceConfig = new DropwizardResourceConfig(); ResourceConfig resourceConfig = new DropwizardResourceConfig();
resourceConfig.register(new TestResource()); resourceConfig.register(new TestResource());
resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder()); resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder());
resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class)); resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class));
resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper())); resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper()));
ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig); ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig);
WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class); WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class);
WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler, requestLog, new TestPrincipal("something"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000); WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler,
requestLog, new TestPrincipal("something"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000);
Session session = mock(Session.class ); Session session = mock(Session.class);
RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class); RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
UpgradeRequest request = mock(UpgradeRequest.class); UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request); when(session.getUpgradeRequest()).thenReturn(request);
when(session.getRemote()).thenReturn(remoteEndpoint); when(session.getRemote()).thenReturn(remoteEndpoint);
provider.onWebSocketConnect(session); provider.onWebSocketConnect(session);
byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/v1/test/optional", new LinkedList<>(), Optional.empty()).toByteArray(); byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/v1/test/optional",
new LinkedList<>(), Optional.empty()).toByteArray();
provider.onWebSocketBinary(message, 0, message.length); provider.onWebSocketBinary(message, 0, message.length);
@ -401,27 +419,29 @@ public class WebSocketResourceProviderTest {
} }
@Test @Test
public void testActualRouteMessageOptionalAuthorizedEmpty() throws InvalidProtocolBufferException { void testActualRouteMessageOptionalAuthorizedEmpty() throws InvalidProtocolBufferException {
ResourceConfig resourceConfig = new DropwizardResourceConfig(); ResourceConfig resourceConfig = new DropwizardResourceConfig();
resourceConfig.register(new TestResource()); resourceConfig.register(new TestResource());
resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder()); resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder());
resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class)); resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class));
resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper())); resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper()));
ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig); ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig);
WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class); WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class);
WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler, requestLog, null, new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000); WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler,
requestLog, null, new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000);
Session session = mock(Session.class ); Session session = mock(Session.class);
RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class); RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
UpgradeRequest request = mock(UpgradeRequest.class); UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request); when(session.getUpgradeRequest()).thenReturn(request);
when(session.getRemote()).thenReturn(remoteEndpoint); when(session.getRemote()).thenReturn(remoteEndpoint);
provider.onWebSocketConnect(session); provider.onWebSocketConnect(session);
byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/v1/test/optional", new LinkedList<>(), Optional.empty()).toByteArray(); byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/v1/test/optional",
new LinkedList<>(), Optional.empty()).toByteArray();
provider.onWebSocketBinary(message, 0, message.length); provider.onWebSocketBinary(message, 0, message.length);
@ -438,27 +458,30 @@ public class WebSocketResourceProviderTest {
} }
@Test @Test
public void testActualRouteMessagePutAuthenticatedEntity() throws InvalidProtocolBufferException, JsonProcessingException { void testActualRouteMessagePutAuthenticatedEntity() throws InvalidProtocolBufferException, JsonProcessingException {
ResourceConfig resourceConfig = new DropwizardResourceConfig(); ResourceConfig resourceConfig = new DropwizardResourceConfig();
resourceConfig.register(new TestResource()); resourceConfig.register(new TestResource());
resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder()); resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder());
resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class)); resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class));
resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper())); resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper()));
ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig); ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig);
WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class); WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class);
WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler, requestLog, new TestPrincipal("gooduser"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000); WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler,
requestLog, new TestPrincipal("gooduser"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000);
Session session = mock(Session.class ); Session session = mock(Session.class);
RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class); RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
UpgradeRequest request = mock(UpgradeRequest.class); UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request); when(session.getUpgradeRequest()).thenReturn(request);
when(session.getRemote()).thenReturn(remoteEndpoint); when(session.getRemote()).thenReturn(remoteEndpoint);
provider.onWebSocketConnect(session); provider.onWebSocketConnect(session);
byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "PUT", "/v1/test/some/testparam", List.of("Content-Type: application/json"), Optional.of(new ObjectMapper().writeValueAsBytes(new TestResource.TestEntity("mykey", 1001)))).toByteArray(); byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "PUT",
"/v1/test/some/testparam", List.of("Content-Type: application/json"),
Optional.of(new ObjectMapper().writeValueAsBytes(new TestResource.TestEntity("mykey", 1001)))).toByteArray();
provider.onWebSocketBinary(message, 0, message.length); provider.onWebSocketBinary(message, 0, message.length);
@ -475,27 +498,31 @@ public class WebSocketResourceProviderTest {
} }
@Test @Test
public void testActualRouteMessagePutAuthenticatedBadEntity() throws InvalidProtocolBufferException, JsonProcessingException { void testActualRouteMessagePutAuthenticatedBadEntity()
throws InvalidProtocolBufferException, JsonProcessingException {
ResourceConfig resourceConfig = new DropwizardResourceConfig(); ResourceConfig resourceConfig = new DropwizardResourceConfig();
resourceConfig.register(new TestResource()); resourceConfig.register(new TestResource());
resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder()); resourceConfig.register(new WebSocketSessionContextValueFactoryProvider.Binder());
resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class)); resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class));
resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper())); resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper()));
ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig); ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig);
WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class); WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class);
WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler, requestLog, new TestPrincipal("gooduser"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000); WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler,
requestLog, new TestPrincipal("gooduser"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000);
Session session = mock(Session.class ); Session session = mock(Session.class);
RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class); RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
UpgradeRequest request = mock(UpgradeRequest.class); UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request); when(session.getUpgradeRequest()).thenReturn(request);
when(session.getRemote()).thenReturn(remoteEndpoint); when(session.getRemote()).thenReturn(remoteEndpoint);
provider.onWebSocketConnect(session); provider.onWebSocketConnect(session);
byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "PUT", "/v1/test/some/testparam", List.of("Content-Type: application/json"), Optional.of(new ObjectMapper().writeValueAsBytes(new TestResource.TestEntity("mykey", 5)))).toByteArray(); byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "PUT",
"/v1/test/some/testparam", List.of("Content-Type: application/json"),
Optional.of(new ObjectMapper().writeValueAsBytes(new TestResource.TestEntity("mykey", 5)))).toByteArray();
provider.onWebSocketBinary(message, 0, message.length); provider.onWebSocketBinary(message, 0, message.length);
@ -512,7 +539,7 @@ public class WebSocketResourceProviderTest {
} }
@Test @Test
public void testActualRouteMessageExceptionMapping() throws InvalidProtocolBufferException { void testActualRouteMessageExceptionMapping() throws InvalidProtocolBufferException {
ResourceConfig resourceConfig = new DropwizardResourceConfig(); ResourceConfig resourceConfig = new DropwizardResourceConfig();
resourceConfig.register(new TestResource()); resourceConfig.register(new TestResource());
resourceConfig.register(new TestExceptionMapper()); resourceConfig.register(new TestExceptionMapper());
@ -520,20 +547,22 @@ public class WebSocketResourceProviderTest {
resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class)); resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class));
resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper())); resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper()));
ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig); ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig);
WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class); WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class);
WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler, requestLog, new TestPrincipal("gooduser"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000); WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler,
requestLog, new TestPrincipal("gooduser"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000);
Session session = mock(Session.class ); Session session = mock(Session.class);
RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class); RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
UpgradeRequest request = mock(UpgradeRequest.class); UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request); when(session.getUpgradeRequest()).thenReturn(request);
when(session.getRemote()).thenReturn(remoteEndpoint); when(session.getRemote()).thenReturn(remoteEndpoint);
provider.onWebSocketConnect(session); provider.onWebSocketConnect(session);
byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/v1/test/exception/map", List.of("Content-Type: application/json"), Optional.empty()).toByteArray(); byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET",
"/v1/test/exception/map", List.of("Content-Type: application/json"), Optional.empty()).toByteArray();
provider.onWebSocketBinary(message, 0, message.length); provider.onWebSocketBinary(message, 0, message.length);
@ -549,7 +578,7 @@ public class WebSocketResourceProviderTest {
} }
@Test @Test
public void testActualRouteSessionContextInjection() throws InvalidProtocolBufferException { void testActualRouteSessionContextInjection() throws InvalidProtocolBufferException {
ResourceConfig resourceConfig = new DropwizardResourceConfig(); ResourceConfig resourceConfig = new DropwizardResourceConfig();
resourceConfig.register(new TestResource()); resourceConfig.register(new TestResource());
resourceConfig.register(new TestExceptionMapper()); resourceConfig.register(new TestExceptionMapper());
@ -557,20 +586,22 @@ public class WebSocketResourceProviderTest {
resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class)); resourceConfig.register(new WebsocketAuthValueFactoryProvider.Binder<>(TestPrincipal.class));
resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper())); resourceConfig.register(new JacksonMessageBodyProvider(new ObjectMapper()));
ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig); ApplicationHandler applicationHandler = new ApplicationHandler(resourceConfig);
WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class); WebsocketRequestLog requestLog = mock(WebsocketRequestLog.class);
WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler, requestLog, new TestPrincipal("gooduser"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000); WebSocketResourceProvider<TestPrincipal> provider = new WebSocketResourceProvider<>("127.0.0.1", applicationHandler,
requestLog, new TestPrincipal("gooduser"), new ProtobufWebSocketMessageFactory(), Optional.empty(), 30000);
Session session = mock(Session.class ); Session session = mock(Session.class);
RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class); RemoteEndpoint remoteEndpoint = mock(RemoteEndpoint.class);
UpgradeRequest request = mock(UpgradeRequest.class); UpgradeRequest request = mock(UpgradeRequest.class);
when(session.getUpgradeRequest()).thenReturn(request); when(session.getUpgradeRequest()).thenReturn(request);
when(session.getRemote()).thenReturn(remoteEndpoint); when(session.getRemote()).thenReturn(remoteEndpoint);
provider.onWebSocketConnect(session); provider.onWebSocketConnect(session);
byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/v1/test/keepalive", new LinkedList<>(), Optional.empty()).toByteArray(); byte[] message = new ProtobufWebSocketMessageFactory().createRequest(Optional.of(111L), "GET", "/v1/test/keepalive",
new LinkedList<>(), Optional.empty()).toByteArray();
provider.onWebSocketBinary(message, 0, message.length); provider.onWebSocketBinary(message, 0, message.length);
@ -583,7 +614,8 @@ public class WebSocketResourceProviderTest {
assertThat(requestMessage.getPath()).isEqualTo("/v1/miccheck"); assertThat(requestMessage.getPath()).isEqualTo("/v1/miccheck");
assertThat(requestMessage.getBody().toStringUtf8()).isEqualTo("smert ze smert"); assertThat(requestMessage.getBody().toStringUtf8()).isEqualTo("smert ze smert");
byte[] clientResponse = new ProtobufWebSocketMessageFactory().createResponse(requestMessage.getId(), 200, "OK", new LinkedList<>(), Optional.of("my response".getBytes())).toByteArray(); byte[] clientResponse = new ProtobufWebSocketMessageFactory().createResponse(requestMessage.getId(), 200, "OK",
new LinkedList<>(), Optional.of("my response".getBytes())).toByteArray();
provider.onWebSocketBinary(clientResponse, 0, clientResponse.length); provider.onWebSocketBinary(clientResponse, 0, clientResponse.length);
@ -600,7 +632,7 @@ public class WebSocketResourceProviderTest {
} }
@Test @Test
public void testGetHeaderList() { void testGetHeaderList() {
assertThat(WebSocketResourceProvider.getHeaderList(new MultivaluedHashMap<>())).isEmpty(); assertThat(WebSocketResourceProvider.getHeaderList(new MultivaluedHashMap<>())).isEmpty();
{ {
@ -615,7 +647,7 @@ public class WebSocketResourceProviderTest {
} }
@Test @Test
public void testShouldIncludeUpgradeRequestHeader() { void testShouldIncludeUpgradeRequestHeader() {
assertThat(WebSocketResourceProvider.shouldIncludeUpgradeRequestHeader("Upgrade")).isFalse(); assertThat(WebSocketResourceProvider.shouldIncludeUpgradeRequestHeader("Upgrade")).isFalse();
assertThat(WebSocketResourceProvider.shouldIncludeUpgradeRequestHeader("Connection")).isFalse(); assertThat(WebSocketResourceProvider.shouldIncludeUpgradeRequestHeader("Connection")).isFalse();
assertThat(WebSocketResourceProvider.shouldIncludeUpgradeRequestHeader("Sec-WebSocket-Key")).isFalse(); assertThat(WebSocketResourceProvider.shouldIncludeUpgradeRequestHeader("Sec-WebSocket-Key")).isFalse();
@ -624,13 +656,13 @@ public class WebSocketResourceProviderTest {
} }
@Test @Test
public void testShouldIncludeRequestMessageHeader() { void testShouldIncludeRequestMessageHeader() {
assertThat(WebSocketResourceProvider.shouldIncludeRequestMessageHeader("X-Forwarded-For")).isFalse(); assertThat(WebSocketResourceProvider.shouldIncludeRequestMessageHeader("X-Forwarded-For")).isFalse();
assertThat(WebSocketResourceProvider.shouldIncludeRequestMessageHeader("User-Agent")).isTrue(); assertThat(WebSocketResourceProvider.shouldIncludeRequestMessageHeader("User-Agent")).isTrue();
} }
@Test @Test
public void testGetCombinedHeaders() { void testGetCombinedHeaders() {
final Map<String, List<String>> upgradeRequestHeaders = Map.of( final Map<String, List<String>> upgradeRequestHeaders = Map.of(
"Host", List.of("server.example.com"), "Host", List.of("server.example.com"),
"Upgrade", List.of("websocket"), "Upgrade", List.of("websocket"),
@ -650,14 +682,17 @@ public class WebSocketResourceProviderTest {
"X-Forwarded-For", List.of("127.0.0.1"), "X-Forwarded-For", List.of("127.0.0.1"),
"User-Agent", List.of("Request message user agent")); "User-Agent", List.of("Request message user agent"));
assertThat(WebSocketResourceProvider.getCombinedHeaders(upgradeRequestHeaders, requestMessageHeaders)).isEqualTo(expectedHeaders); assertThat(WebSocketResourceProvider.getCombinedHeaders(upgradeRequestHeaders, requestMessageHeaders)).isEqualTo(
expectedHeaders);
} }
private SubProtocol.WebSocketResponseMessage getResponse(ArgumentCaptor<ByteBuffer> responseCaptor) throws InvalidProtocolBufferException { private SubProtocol.WebSocketResponseMessage getResponse(ArgumentCaptor<ByteBuffer> responseCaptor)
throws InvalidProtocolBufferException {
return SubProtocol.WebSocketMessage.parseFrom(responseCaptor.getValue().array()).getResponse(); return SubProtocol.WebSocketMessage.parseFrom(responseCaptor.getValue().array()).getResponse();
} }
private SubProtocol.WebSocketRequestMessage getRequest(ArgumentCaptor<ByteBuffer> requestCaptor) throws InvalidProtocolBufferException { private SubProtocol.WebSocketRequestMessage getRequest(ArgumentCaptor<ByteBuffer> requestCaptor)
throws InvalidProtocolBufferException {
return SubProtocol.WebSocketMessage.parseFrom(requestCaptor.getValue().array()).getRequest(); return SubProtocol.WebSocketMessage.parseFrom(requestCaptor.getValue().array()).getRequest();
} }
@ -677,6 +712,7 @@ public class WebSocketResourceProviderTest {
} }
public static class TestException extends Exception { public static class TestException extends Exception {
public TestException(String message) { public TestException(String message) {
super(message); super(message);
} }
@ -703,7 +739,9 @@ public class WebSocketResourceProviderTest {
@GET @GET
@Path("/world") @Path("/world")
public String testAuthorizedHello(@Auth TestPrincipal user) { public String testAuthorizedHello(@Auth TestPrincipal user) {
if (user == null) throw new AssertionError(); if (user == null) {
throw new AssertionError();
}
return "World: " + user.getName(); return "World: " + user.getName();
} }
@ -711,15 +749,18 @@ public class WebSocketResourceProviderTest {
@GET @GET
@Path("/optional") @Path("/optional")
public String testAuthorizedHello(@Auth Optional<TestPrincipal> user) { public String testAuthorizedHello(@Auth Optional<TestPrincipal> user) {
if (user.isPresent()) return "World: " + user.get().getName(); if (user.isPresent()) {
else return "Empty world"; return "World: " + user.get().getName();
} else {
return "Empty world";
}
} }
@PUT @PUT
@Path("/some/{param}") @Path("/some/{param}")
@Consumes(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON)
@Produces(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON)
public Response testSet(@Auth TestPrincipal user, @PathParam ("param") String param, @Valid TestEntity entity) { public Response testSet(@Auth TestPrincipal user, @PathParam("param") String param, @Valid TestEntity entity) {
return Response.ok(user.name + ":" + param + ":" + entity.key + ":" + entity.value).build(); return Response.ok(user.name + ":" + param + ":" + entity.key + ":" + entity.value).build();
} }
@ -737,14 +778,14 @@ public class WebSocketResourceProviderTest {
} }
return context.getClient() return context.getClient()
.sendRequest("GET", "/v1/miccheck", new LinkedList<>(), Optional.of("smert ze smert".getBytes())) .sendRequest("GET", "/v1/miccheck", new LinkedList<>(), Optional.of("smert ze smert".getBytes()))
.thenApply(response -> Response.ok().entity(new String(response.getBody().get())).build()); .thenApply(response -> Response.ok().entity(new String(response.getBody().get())).build());
} }
public static class TestEntity { public static class TestEntity {
public TestEntity(String key, long value) { public TestEntity(String key, long value) {
this.key = key; this.key = key;
this.value = value; this.value = value;
} }

68
websocket-resources/src/test/java/org/whispersystems/websocket/logging/WebSocketRequestLogTest.java
View File

@ -4,56 +4,57 @@
*/ */
package org.whispersystems.websocket.logging; package org.whispersystems.websocket.logging;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.mock;
import ch.qos.logback.classic.LoggerContext; import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.core.OutputStreamAppender; import ch.qos.logback.core.OutputStreamAppender;
import ch.qos.logback.core.spi.DeferredProcessingAware; import ch.qos.logback.core.spi.DeferredProcessingAware;
import io.dropwizard.logging.AbstractOutputStreamAppenderFactory; import io.dropwizard.logging.AbstractOutputStreamAppenderFactory;
import org.glassfish.jersey.internal.MapPropertiesDelegate;
import org.glassfish.jersey.server.ContainerRequest;
import org.glassfish.jersey.server.ContainerResponse;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.whispersystems.websocket.WebSocketSecurityContext;
import org.whispersystems.websocket.session.ContextPrincipal;
import org.whispersystems.websocket.session.WebSocketSessionContext;
import javax.ws.rs.core.Response;
import java.io.ByteArrayOutputStream; import java.io.ByteArrayOutputStream;
import java.net.URI; import java.net.URI;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.HashMap; import java.util.HashMap;
import java.util.List; import java.util.List;
import java.util.Locale; import java.util.Locale;
import javax.ws.rs.core.Response;
import static org.assertj.core.api.Assertions.assertThat; import org.glassfish.jersey.internal.MapPropertiesDelegate;
import static org.mockito.Mockito.mock; import org.glassfish.jersey.server.ContainerRequest;
import org.glassfish.jersey.server.ContainerResponse;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.whispersystems.websocket.WebSocketSecurityContext;
import org.whispersystems.websocket.session.ContextPrincipal;
import org.whispersystems.websocket.session.WebSocketSessionContext;
public class WebSocketRequestLogTest { public class WebSocketRequestLogTest {
private final static Locale ORIGINAL_DEFAULT_LOCALE = Locale.getDefault(); private final static Locale ORIGINAL_DEFAULT_LOCALE = Locale.getDefault();
@Before @BeforeEach
public void beforeEachTest() { void beforeEachTest() {
Locale.setDefault(Locale.ENGLISH); Locale.setDefault(Locale.ENGLISH);
} }
@After @AfterEach
public void afterEachTest() { void afterEachTest() {
Locale.setDefault(ORIGINAL_DEFAULT_LOCALE); Locale.setDefault(ORIGINAL_DEFAULT_LOCALE);
} }
@Test @Test
public void testLogLineWithoutHeaders() throws InterruptedException { void testLogLineWithoutHeaders() throws InterruptedException {
WebSocketSessionContext sessionContext = mock(WebSocketSessionContext.class); WebSocketSessionContext sessionContext = mock(WebSocketSessionContext.class);
ListAppender<WebsocketEvent> listAppender = new ListAppender<>(); ListAppender<WebsocketEvent> listAppender = new ListAppender<>();
WebsocketRequestLoggerFactory requestLoggerFactory = new WebsocketRequestLoggerFactory(); WebsocketRequestLoggerFactory requestLoggerFactory = new WebsocketRequestLoggerFactory();
requestLoggerFactory.appenders = List.of(new ListAppenderFactory<>(listAppender)); requestLoggerFactory.appenders = List.of(new ListAppenderFactory<>(listAppender));
WebsocketRequestLog requestLog = requestLoggerFactory.build("test-logger"); WebsocketRequestLog requestLog = requestLoggerFactory.build("test-logger");
ContainerRequest request = new ContainerRequest (null, URI.create("/v1/test"), "GET", new WebSocketSecurityContext(new ContextPrincipal(sessionContext)), new MapPropertiesDelegate(new HashMap<>()), null); ContainerRequest request = new ContainerRequest(null, URI.create("/v1/test"), "GET",
ContainerResponse response = new ContainerResponse(request, Response.ok("My response body").build()); new WebSocketSecurityContext(new ContextPrincipal(sessionContext)), new MapPropertiesDelegate(new HashMap<>()),
null);
ContainerResponse response = new ContainerResponse(request, Response.ok("My response body").build());
requestLog.log("123.456.789.123", request, response); requestLog.log("123.456.789.123", request, response);
@ -61,22 +62,25 @@ public class WebSocketRequestLogTest {
assertThat(listAppender.list.size()).isEqualTo(1); assertThat(listAppender.list.size()).isEqualTo(1);
String loggedLine = new String(listAppender.outputStream.toByteArray()); String loggedLine = new String(listAppender.outputStream.toByteArray());
assertThat(loggedLine).matches("123\\.456\\.789\\.123 \\- \\- \\[[0-9]{2}\\/[a-zA-Z]{3}\\/[0-9]{4}:[0-9]{2}:[0-9]{2}:[0-9]{2} (\\-|\\+)[0-9]{4}\\] \"GET \\/v1\\/test WS\" 200 \\- \"\\-\" \"\\-\"\n"); assertThat(loggedLine).matches(
"123\\.456\\.789\\.123 \\- \\- \\[[0-9]{2}\\/[a-zA-Z]{3}\\/[0-9]{4}:[0-9]{2}:[0-9]{2}:[0-9]{2} (\\-|\\+)[0-9]{4}\\] \"GET \\/v1\\/test WS\" 200 \\- \"\\-\" \"\\-\"\n");
} }
@Test @Test
public void testLogLineWithHeaders() throws InterruptedException { void testLogLineWithHeaders() throws InterruptedException {
WebSocketSessionContext sessionContext = mock(WebSocketSessionContext.class); WebSocketSessionContext sessionContext = mock(WebSocketSessionContext.class);
ListAppender<WebsocketEvent> listAppender = new ListAppender<>(); ListAppender<WebsocketEvent> listAppender = new ListAppender<>();
WebsocketRequestLoggerFactory requestLoggerFactory = new WebsocketRequestLoggerFactory(); WebsocketRequestLoggerFactory requestLoggerFactory = new WebsocketRequestLoggerFactory();
requestLoggerFactory.appenders = List.of(new ListAppenderFactory<>(listAppender)); requestLoggerFactory.appenders = List.of(new ListAppenderFactory<>(listAppender));
WebsocketRequestLog requestLog = requestLoggerFactory.build("test-logger"); WebsocketRequestLog requestLog = requestLoggerFactory.build("test-logger");
ContainerRequest request = new ContainerRequest (null, URI.create("/v1/test"), "GET", new WebSocketSecurityContext(new ContextPrincipal(sessionContext)), new MapPropertiesDelegate(new HashMap<>()), null); ContainerRequest request = new ContainerRequest(null, URI.create("/v1/test"), "GET",
new WebSocketSecurityContext(new ContextPrincipal(sessionContext)), new MapPropertiesDelegate(new HashMap<>()),
null);
request.header("User-Agent", "SmertZeSmert"); request.header("User-Agent", "SmertZeSmert");
request.header("Referer", "https://moxie.org"); request.header("Referer", "https://moxie.org");
ContainerResponse response = new ContainerResponse(request, Response.ok("My response body").build()); ContainerResponse response = new ContainerResponse(request, Response.ok("My response body").build());
requestLog.log("123.456.789.123", request, response); requestLog.log("123.456.789.123", request, response);
@ -84,14 +88,16 @@ public class WebSocketRequestLogTest {
assertThat(listAppender.list.size()).isEqualTo(1); assertThat(listAppender.list.size()).isEqualTo(1);
String loggedLine = new String(listAppender.outputStream.toByteArray()); String loggedLine = new String(listAppender.outputStream.toByteArray());
assertThat(loggedLine).matches("123\\.456\\.789\\.123 \\- \\- \\[[0-9]{2}\\/[a-zA-Z]{3}\\/[0-9]{4}:[0-9]{2}:[0-9]{2}:[0-9]{2} (\\-|\\+)[0-9]{4}\\] \"GET \\/v1\\/test WS\" 200 \\- \"https://moxie.org\" \"SmertZeSmert\"\n"); assertThat(loggedLine).matches(
"123\\.456\\.789\\.123 \\- \\- \\[[0-9]{2}\\/[a-zA-Z]{3}\\/[0-9]{4}:[0-9]{2}:[0-9]{2}:[0-9]{2} (\\-|\\+)[0-9]{4}\\] \"GET \\/v1\\/test WS\" 200 \\- \"https://moxie.org\" \"SmertZeSmert\"\n");
System.out.println(listAppender.list.get(0)); System.out.println(listAppender.list.get(0));
System.out.println(new String(listAppender.outputStream.toByteArray())); System.out.println(new String(listAppender.outputStream.toByteArray()));
} }
private static class ListAppenderFactory<T extends DeferredProcessingAware> extends
AbstractOutputStreamAppenderFactory<T> {
private static class ListAppenderFactory<T extends DeferredProcessingAware> extends AbstractOutputStreamAppenderFactory<T> {
private final ListAppender<T> listAppender; private final ListAppender<T> listAppender;
public ListAppenderFactory(ListAppender<T> listAppender) { public ListAppenderFactory(ListAppender<T> listAppender) {
@ -107,8 +113,8 @@ public class WebSocketRequestLogTest {
private static class ListAppender<E> extends OutputStreamAppender<E> { private static class ListAppender<E> extends OutputStreamAppender<E> {
public final List<E> list = new ArrayList<E>(); public final List<E> list = new ArrayList<E>();
public final ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); public final ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
protected void append(E e) { protected void append(E e) {
super.append(e); super.append(e);