public void AbsoluteUpgradeUrlWithQuery()
{
var uri = new Uri("ws://localhost:9999/path%20with%20ws?a=b%20c");
WebSocketClientHandshaker handshaker = NewHandshaker(uri, null, null, true);
IFullHttpRequest request = handshaker.NewHandshakeRequest();
try
{
Assert.Equal("ws://localhost:9999/path%20with%20ws?a=b%20c", request.Uri);
}
finally
{
request.Release();
}
}
public void UpgradeUrl()
{
var uri = new Uri("ws://localhost:9999/path%20with%20ws");
WebSocketClientHandshaker handshaker = this.NewHandshaker(uri);
IFullHttpRequest request = handshaker.NewHandshakeRequest();
try
{
Assert.Equal("/path%20with%20ws", request.Uri);
}
finally
{
request.Release();
}
}
public void UpgradeUrlWithoutPathWithQuery()
{
Uri uri = new Uri("ws://localhost:9999?a=b%20c");
WebSocketClientHandshaker handshaker = NewHandshaker(uri);
IFullHttpRequest request = handshaker.NewHandshakeRequest();
try
{
Assert.Equal("/?a=b%20c", request.Uri);
}
finally
{
request.Release();
}
}
static void CheckContentBuffer(IFullHttpRequest aggregatedMessage)
{
var buffer = (CompositeByteBuffer)aggregatedMessage.Content;
Assert.Equal(2, buffer.NumComponents);
IList <IByteBuffer> buffers = buffer.Decompose(0, buffer.Capacity);
Assert.Equal(2, buffers.Count);
foreach (IByteBuffer buf in buffers)
{
// This should be false as we decompose the buffer before to not have deep hierarchy
Assert.False(buf is CompositeByteBuffer);
}
aggregatedMessage.Release();
}
public void ExpectContinueResetHttpObjectDecoder()
{
// request with header "Expect: 100-continue" must be replied with one "100 Continue" response
// case 5: Test that HttpObjectDecoder correctly resets its internal state after a failed expectation.
var decoder = new HttpRequestDecoder();
const int MaxBytes = 10;
var aggregator = new HttpObjectAggregator(MaxBytes);
var testHandler = new TestHandler();
var channel = new EmbeddedChannel(decoder, aggregator, testHandler);
string req1 = "POST /1 HTTP/1.1\r\n" +
"Content-Length: " + (MaxBytes + 1) + "\r\n" +
"Expect: 100-continue\r\n" +
"\r\n";
Assert.False(channel.WriteInbound(Unpooled.WrappedBuffer(Encoding.ASCII.GetBytes(req1))));
var resp = channel.ReadOutbound <IFullHttpResponse>();
Assert.Equal(HttpStatusClass.ClientError, resp.Status.CodeClass);
resp.Release();
string req2 = "POST /2 HTTP/1.1\r\n" +
"Content-Length: " + MaxBytes + "\r\n" +
"Expect: 100-continue\r\n" +
"\r\n";
Assert.False(channel.WriteInbound(Unpooled.WrappedBuffer(Encoding.ASCII.GetBytes(req2))));
resp = channel.ReadOutbound <IFullHttpResponse>();
Assert.Equal(100, resp.Status.Code);
resp.Release();
var content = new byte[MaxBytes];
Assert.False(channel.WriteInbound(Unpooled.WrappedBuffer(content)));
IFullHttpRequest req = testHandler.Request;
Assert.NotNull(req);
Assert.Equal("/2", req.Uri);
Assert.Equal(10, req.Content.ReadableBytes);
req.Release();
AssertHasInboundMessages(channel, false);
AssertHasOutboundMessages(channel, false);
Assert.False(channel.Finish());
}
protected void HeaderDefaultHttp(string uri, AsciiString header, string expectedValue)
{
Assert.True(Uri.TryCreate(uri, UriKind.RelativeOrAbsolute, out Uri originalUri));
WebSocketClientHandshaker handshaker = this.NewHandshaker(originalUri);
IFullHttpRequest request = handshaker.NewHandshakeRequest();
try
{
Assert.True(request.Headers.TryGet(header, out ICharSequence value));
Assert.Equal(expectedValue, value.ToString(), true);
}
finally
{
request.Release();
}
}
public void SetOriginFromCustomHeaders()
{
HttpHeaders customHeaders = new DefaultHttpHeaders().Set(GetOriginHeaderName(), "http://example.com");
WebSocketClientHandshaker handshaker = NewHandshaker(new Uri("ws://server.example.com/chat"), null,
customHeaders, false);
IFullHttpRequest request = handshaker.NewHandshakeRequest();
try
{
Assert.Equal("http://example.com", request.Headers.Get(GetOriginHeaderName(), null));
}
finally
{
request.Release();
}
}
public void HostHeaderPreserved()
{
Uri uri = new Uri("ws://localhost:9999");
WebSocketClientHandshaker handshaker = NewHandshaker(uri, null,
new DefaultHttpHeaders().Set(HttpHeaderNames.Host, "test.netty.io"), false);
IFullHttpRequest request = handshaker.NewHandshakeRequest();
try
{
Assert.Equal("/", request.Uri);
Assert.Equal("test.netty.io", request.Headers.Get(HttpHeaderNames.Host, null));
}
finally
{
request.Release();
}
}
void TestHttpResponseAndFrameInSameBuffer(bool codec)
{
string url = "ws://localhost:9999/ws";
WebSocketClientHandshaker shaker = this.NewHandshaker(new Uri(url));
var handshaker = new Handshaker(shaker);
// use randomBytes helper from utils to check that it functions properly
byte[] data = WebSocketUtil.RandomBytes(24);
// Create a EmbeddedChannel which we will use to encode a BinaryWebsocketFrame to bytes and so use these
// to test the actual handshaker.
var factory = new WebSocketServerHandshakerFactory(url, null, false);
IFullHttpRequest request = shaker.NewHandshakeRequest();
WebSocketServerHandshaker socketServerHandshaker = factory.NewHandshaker(request);
request.Release();
var websocketChannel = new EmbeddedChannel(socketServerHandshaker.NewWebSocketEncoder(),
socketServerHandshaker.NewWebsocketDecoder());
Assert.True(websocketChannel.WriteOutbound(new BinaryWebSocketFrame(Unpooled.WrappedBuffer(data))));
byte[] bytes = Encoding.ASCII.GetBytes("HTTP/1.1 101 Switching Protocols\r\nContent-Length: 0\r\n\r\n");
CompositeByteBuffer compositeByteBuf = Unpooled.CompositeBuffer();
compositeByteBuf.AddComponent(true, Unpooled.WrappedBuffer(bytes));
for (; ;)
{
var frameBytes = websocketChannel.ReadOutbound <IByteBuffer>();
if (frameBytes == null)
{
break;
}
compositeByteBuf.AddComponent(true, frameBytes);
}
var ch = new EmbeddedChannel(new HttpObjectAggregator(int.MaxValue), new Handler(handshaker));
if (codec)
{
ch.Pipeline.AddFirst(new HttpClientCodec());
}
else
{
ch.Pipeline.AddFirst(new HttpRequestEncoder(), new HttpResponseDecoder());
}
// We need to first write the request as HttpClientCodec will fail if we receive a response before a request
// was written.
shaker.HandshakeAsync(ch).Wait();
for (; ;)
{
// Just consume the bytes, we are not interested in these.
var buf = ch.ReadOutbound <IByteBuffer>();
if (buf == null)
{
break;
}
buf.Release();
}
Assert.True(ch.WriteInbound(compositeByteBuf));
Assert.True(ch.Finish());
var frame = ch.ReadInbound <BinaryWebSocketFrame>();
IByteBuffer expect = Unpooled.WrappedBuffer(data);
try
{
Assert.Equal(expect, frame.Content);
Assert.True(frame.IsFinalFragment);
Assert.Equal(0, frame.Rsv);
}
finally
{
expect.Release();
frame.Release();
}
}
