@Test
public void testAccessRequestCookies() throws Exception {
BlockheadClient client = new BlockheadClient(server.getServerUri());
client.setTimeout(1, TimeUnit.SECONDS);
try {
client.connect();
client.sendStandardRequest();
client.expectUpgradeResponse();
client.write(new TextFrame().setPayload("info"));
EventQueue<WebSocketFrame> frames = client.readFrames(1, 1, TimeUnit.SECONDS);
WebSocketFrame resp = frames.poll();
String textMsg = resp.getPayloadAsUTF8();
assertThat(
"DecoratedObjectFactory", textMsg, containsString("Object is a DecoratedObjectFactory"));
assertThat("decorators.size", textMsg, containsString("Decorators.size = [1]"));
assertThat(
"decorator type",
textMsg,
containsString("decorator[] = " + DummyLegacyDecorator.class.getName()));
} finally {
client.close();
}
}
/** Incoming PING (Control Frame) should pass through extension unmodified */
@Test
public void testIncomingPing() {
IncomingFramesCapture capture = new IncomingFramesCapture();
FragmentExtension ext = new FragmentExtension();
ext.setBufferPool(new MappedByteBufferPool());
ext.setPolicy(WebSocketPolicy.newServerPolicy());
ExtensionConfig config = ExtensionConfig.parse("fragment;maxLength=4");
ext.setConfig(config);
ext.setNextIncomingFrames(capture);
String payload = "Are you there?";
Frame ping = WebSocketFrame.ping().setPayload(payload);
ext.incomingFrame(ping);
capture.assertFrameCount(1);
capture.assertHasFrame(OpCode.PING, 1);
WebSocketFrame actual = capture.getFrames().getFirst();
Assert.assertThat("Frame.opcode", actual.getOpCode(), is(OpCode.PING));
Assert.assertThat("Frame.fin", actual.isFin(), is(true));
Assert.assertThat("Frame.rsv1", actual.isRsv1(), is(false));
Assert.assertThat("Frame.rsv2", actual.isRsv2(), is(false));
Assert.assertThat("Frame.rsv3", actual.isRsv3(), is(false));
ByteBuffer expected = BufferUtil.toBuffer(payload, StringUtil.__UTF8_CHARSET);
Assert.assertThat("Frame.payloadLength", actual.getPayloadLength(), is(expected.remaining()));
ByteBufferAssert.assertEquals("Frame.payload", expected, actual.getPayload().slice());
}
@Test
public void testGenerate125ByteBinaryCase1_2_2() {
int length = 125;
ByteBuffer bb = ByteBuffer.allocate(length);
for (int i = 0; i < length; ++i) {
bb.put("*".getBytes());
}
bb.flip();
WebSocketFrame binaryFrame = WebSocketFrame.binary().setPayload(bb);
Generator generator = new UnitGenerator();
ByteBuffer actual = generator.generate(binaryFrame);
ByteBuffer expected = ByteBuffer.allocate(length + 5);
expected.put(new byte[] {(byte) 0x82});
byte b = 0x00; // no masking
b |= length & 0x7F;
expected.put(b);
for (int i = 0; i < length; ++i) {
expected.put("*".getBytes());
}
BufferUtil.flipToFlush(expected, 0);
ByteBufferAssert.assertEquals("buffers do not match", expected, actual);
}
@Test
public void testCaptureRequestHeadersConfigurator() throws Exception {
URI uri = baseServerUri.resolve("/capture-request-headers");
try (BlockheadClient client = new BlockheadClient(uri)) {
client.addHeader("X-Dummy: Bogus\r\n");
client.connect();
client.sendStandardRequest();
client.expectUpgradeResponse();
client.write(new TextFrame().setPayload("X-Dummy"));
IncomingFramesCapture capture = client.readFrames(1, TimeUnit.SECONDS, 1);
WebSocketFrame frame = capture.getFrames().poll();
Assert.assertThat(
"Frame Response", frame.getPayloadAsUTF8(), is("Request Header [X-Dummy]: \"Bogus\""));
}
}
/** Verify that incoming frames are passed thru without modification */
@Test
public void testIncomingFrames() {
IncomingFramesCapture capture = new IncomingFramesCapture();
FragmentExtension ext = new FragmentExtension();
ext.setBufferPool(new MappedByteBufferPool());
ext.setPolicy(WebSocketPolicy.newClientPolicy());
ExtensionConfig config = ExtensionConfig.parse("fragment;maxLength=4");
ext.setConfig(config);
ext.setNextIncomingFrames(capture);
// Quote
List<String> quote = new ArrayList<>();
quote.add("No amount of experimentation can ever prove me right;");
quote.add("a single experiment can prove me wrong.");
quote.add("-- Albert Einstein");
// Manually create frame and pass into extension
for (String q : quote) {
Frame frame = WebSocketFrame.text(q);
ext.incomingFrame(frame);
}
int len = quote.size();
capture.assertFrameCount(len);
capture.assertHasFrame(OpCode.TEXT, len);
String prefix;
for (int i = 0; i < len; i++) {
prefix = "Frame[" + i + "]";
WebSocketFrame actual = capture.getFrames().get(i);
Assert.assertThat(prefix + ".opcode", actual.getOpCode(), is(OpCode.TEXT));
Assert.assertThat(prefix + ".fin", actual.isFin(), is(true));
Assert.assertThat(prefix + ".rsv1", actual.isRsv1(), is(false));
Assert.assertThat(prefix + ".rsv2", actual.isRsv2(), is(false));
Assert.assertThat(prefix + ".rsv3", actual.isRsv3(), is(false));
ByteBuffer expected = BufferUtil.toBuffer(quote.get(i), StringUtil.__UTF8_CHARSET);
Assert.assertThat(
prefix + ".payloadLength", actual.getPayloadLength(), is(expected.remaining()));
ByteBufferAssert.assertEquals(prefix + ".payload", expected, actual.getPayload().slice());
}
}
/**
* Test session open session cleanup (bug #474936)
*
* @throws Exception on test failure
*/
@Test
public void testOpenSessionCleanup() throws Exception {
int iterationCount = 100;
StdErrLog.getLogger(FastFailSocket.class).setLevel(StdErrLog.LEVEL_OFF);
StdErrLog sessLog = StdErrLog.getLogger(WebSocketSession.class);
int oldLevel = sessLog.getLevel();
sessLog.setLevel(StdErrLog.LEVEL_OFF);
for (int requests = 0; requests < iterationCount; requests++) {
fastFail();
fastClose();
dropConnection();
}
sessLog.setLevel(oldLevel);
try (IBlockheadClient client = new BlockheadClient(server.getServerUri())) {
client.setProtocols("container");
client.setTimeout(1, TimeUnit.SECONDS);
client.connect();
client.sendStandardRequest();
client.expectUpgradeResponse();
client.write(new TextFrame().setPayload("calls"));
client.write(new TextFrame().setPayload("openSessions"));
EventQueue<WebSocketFrame> frames = client.readFrames(3, 6, TimeUnit.SECONDS);
WebSocketFrame frame;
String resp;
frame = frames.poll();
assertThat("frames[0].opcode", frame.getOpCode(), is(OpCode.TEXT));
resp = frame.getPayloadAsUTF8();
assertThat(
"Should only have 1 open session",
resp,
containsString("calls=" + ((iterationCount * 2) + 1)));
frame = frames.poll();
assertThat("frames[1].opcode", frame.getOpCode(), is(OpCode.TEXT));
resp = frame.getPayloadAsUTF8();
assertThat("Should only have 1 open session", resp, containsString("openSessions.size=1\n"));
frame = frames.poll();
assertThat("frames[2].opcode", frame.getOpCode(), is(OpCode.CLOSE));
CloseInfo close = new CloseInfo(frame);
assertThat("Close Status Code", close.getStatusCode(), is(StatusCode.NORMAL));
client.write(close.asFrame()); // respond with close
// ensure server socket got close event
assertThat(
"Open Sessions Latch", closeSocket.closeLatch.await(1, TimeUnit.SECONDS), is(true));
assertThat("Open Sessions.statusCode", closeSocket.closeStatusCode, is(StatusCode.NORMAL));
assertThat("Open Sessions.errors", closeSocket.errors.size(), is(0));
}
}
@Test
public void testGenerateEmptyBinaryCase1_2_1() {
WebSocketFrame binaryFrame = WebSocketFrame.binary(new byte[] {});
Generator generator = new UnitGenerator();
ByteBuffer actual = generator.generate(binaryFrame);
ByteBuffer expected = ByteBuffer.allocate(5);
expected.put(new byte[] {(byte) 0x82, (byte) 0x00});
BufferUtil.flipToFlush(expected, 0);
ByteBufferAssert.assertEquals("buffers do not match", expected, actual);
}
private void assertIncoming(byte[] raw, String... expectedTextDatas) {
WebSocketPolicy policy = WebSocketPolicy.newClientPolicy();
DeflateFrameExtension ext = new DeflateFrameExtension();
ext.setBufferPool(bufferPool);
ext.setPolicy(policy);
ExtensionConfig config = ExtensionConfig.parse("deflate-frame");
ext.setConfig(config);
// Setup capture of incoming frames
IncomingFramesCapture capture = new IncomingFramesCapture();
// Wire up stack
ext.setNextIncomingFrames(capture);
Parser parser = new UnitParser(policy);
parser.configureFromExtensions(Collections.singletonList(ext));
parser.setIncomingFramesHandler(ext);
parser.parse(ByteBuffer.wrap(raw));
int len = expectedTextDatas.length;
capture.assertFrameCount(len);
capture.assertHasFrame(OpCode.TEXT, len);
int i = 0;
for (WebSocketFrame actual : capture.getFrames()) {
String prefix = "Frame[" + i + "]";
Assert.assertThat(prefix + ".opcode", actual.getOpCode(), is(OpCode.TEXT));
Assert.assertThat(prefix + ".fin", actual.isFin(), is(true));
Assert.assertThat(
prefix + ".rsv1", actual.isRsv1(), is(false)); // RSV1 should be unset at this point
Assert.assertThat(prefix + ".rsv2", actual.isRsv2(), is(false));
Assert.assertThat(prefix + ".rsv3", actual.isRsv3(), is(false));
ByteBuffer expected = BufferUtil.toBuffer(expectedTextDatas[i], StandardCharsets.UTF_8);
Assert.assertThat(
prefix + ".payloadLength", actual.getPayloadLength(), is(expected.remaining()));
ByteBufferAssert.assertEquals(prefix + ".payload", expected, actual.getPayload().slice());
i++;
}
}
/** Verify that outgoing text frames are fragmented by default configuration */
@Test
public void testOutgoingFramesDefaultConfig() throws IOException {
OutgoingFramesCapture capture = new OutgoingFramesCapture();
FragmentExtension ext = new FragmentExtension();
ext.setBufferPool(new MappedByteBufferPool());
ext.setPolicy(WebSocketPolicy.newServerPolicy());
ExtensionConfig config = ExtensionConfig.parse("fragment");
ext.setConfig(config);
ext.setNextOutgoingFrames(capture);
// Quote
List<String> quote = new ArrayList<>();
quote.add("No amount of experimentation can ever prove me right;");
quote.add("a single experiment can prove me wrong.");
quote.add("-- Albert Einstein");
// Write quote as separate frames
for (String section : quote) {
Frame frame = WebSocketFrame.text(section);
ext.outgoingFrame(frame, null);
}
// Expected Frames
List<WebSocketFrame> expectedFrames = new ArrayList<>();
expectedFrames.add(
new WebSocketFrame(OpCode.TEXT)
.setPayload("No amount of experimentation can ever prove me right;"));
expectedFrames.add(
new WebSocketFrame(OpCode.TEXT).setPayload("a single experiment can prove me wrong."));
expectedFrames.add(new WebSocketFrame(OpCode.TEXT).setPayload("-- Albert Einstein"));
// capture.dump();
int len = expectedFrames.size();
capture.assertFrameCount(len);
String prefix;
LinkedList<WebSocketFrame> frames = capture.getFrames();
for (int i = 0; i < len; i++) {
prefix = "Frame[" + i + "]";
WebSocketFrame actualFrame = frames.get(i);
WebSocketFrame expectedFrame = expectedFrames.get(i);
// Validate Frame
Assert.assertThat(prefix + ".opcode", actualFrame.getOpCode(), is(expectedFrame.getOpCode()));
Assert.assertThat(prefix + ".fin", actualFrame.isFin(), is(expectedFrame.isFin()));
Assert.assertThat(prefix + ".rsv1", actualFrame.isRsv1(), is(expectedFrame.isRsv1()));
Assert.assertThat(prefix + ".rsv2", actualFrame.isRsv2(), is(expectedFrame.isRsv2()));
Assert.assertThat(prefix + ".rsv3", actualFrame.isRsv3(), is(expectedFrame.isRsv3()));
// Validate Payload
ByteBuffer expectedData = expectedFrame.getPayload().slice();
ByteBuffer actualData = actualFrame.getPayload().slice();
Assert.assertThat(
prefix + ".payloadLength", actualData.remaining(), is(expectedData.remaining()));
ByteBufferAssert.assertEquals(prefix + ".payload", expectedData, actualData);
}
}
@Override
public void reset() {
super.reset();
this.channelId = -1;
}