public void VerifyChannelHandlerCanBeReusedInPipeline()
{
_connection.Setup(x => x.IsServer).Returns(true);
_handler = NewHandler();
// Only read the connection preface...after preface is read internal state of Http2ConnectionHandler
// is expected to change relative to the pipeline.
IByteBuffer preface = Http2CodecUtil.ConnectionPrefaceBuf();
_handler.ChannelRead(_ctx.Object, preface);
_decoder.Verify(
x => x.DecodeFrame(
It.IsAny <IChannelHandlerContext>(),
It.IsAny <IByteBuffer>(),
It.IsAny <List <object> >()),
Times.Never());
// Now remove and add the this.handler...this is setting up the test condition.
_handler.HandlerRemoved(_ctx.Object);
_handler.HandlerAdded(_ctx.Object);
// Now verify we can continue as normal, reading connection preface plus more.
IByteBuffer prefacePlusSome = AddSettingsHeader(Unpooled.Buffer().WriteBytes(Http2CodecUtil.ConnectionPrefaceBuf()));
_handler.ChannelRead(_ctx.Object, prefacePlusSome);
_decoder.Verify(
x => x.DecodeFrame(
It.Is <IChannelHandlerContext>(v => v == _ctx.Object),
It.IsAny <IByteBuffer>(),
It.IsAny <List <object> >()),
Times.AtLeastOnce);
}
public void ClientShouldveSentPrefaceAndSettingsFrameWhenUserEventIsTriggered()
{
_connection.Setup(x => x.IsServer).Returns(false);
_channel.Setup(x => x.IsActive).Returns(false);
_handler = NewHandler();
_channel.Setup(x => x.IsActive).Returns(true);
var evt = Http2ConnectionPrefaceAndSettingsFrameWrittenEvent.Instance;
AtomicBoolean verified = new AtomicBoolean(false);
_ctx
.Setup(x => x.FireUserEventTriggered(It.Is <object>(v => ReferenceEquals(v, evt))))
.Returns <object>(msg =>
{
Assert.Same(msg, evt);
_ctx.Verify(x => x.WriteAsync(It.Is <object>(d => Http2CodecUtil.ConnectionPrefaceBuf().Equals((IByteBuffer)d))));
_encoder.Verify(
x => x.WriteSettingsAsync(
It.Is <IChannelHandlerContext>(v => v == _ctx.Object),
It.IsAny <Http2Settings>(),
It.IsAny <IPromise>()));
verified.Value = true;
return(_ctx.Object);
});
_handler.ChannelActive(_ctx.Object);
Assert.True(verified.Value);
}
public void ServerShouldNotSendClientPrefaceStringWhenActive()
{
_connection.Setup(x => x.IsServer).Returns(true);
_channel.Setup(x => x.IsActive).Returns(false);
_handler = NewHandler();
_channel.Setup(x => x.IsActive).Returns(true);
_handler.ChannelActive(_ctx.Object);
_ctx.Verify(x => x.WriteAsync(It.Is <object>(d => Http2CodecUtil.ConnectionPrefaceBuf().Equals((IByteBuffer)d))), Times.Never());
}
private static void TestUpgrade(Http2ConnectionHandler handler, IChannelHandler multiplexer)
{
IFullHttpRequest request = new DefaultFullHttpRequest(HttpVersion.Http11, HttpMethod.Options, "*");
request.Headers.Set(HttpHeaderNames.Host, "netty.io");
request.Headers.Set(HttpHeaderNames.Connection, "Upgrade, HTTP2-Settings");
request.Headers.Set(HttpHeaderNames.Upgrade, "h2c");
request.Headers.Set((AsciiString)"HTTP2-Settings", "AAMAAABkAAQAAP__");
var parent = new Mock <IServerChannel>();
EmbeddedChannel channel = new EmbeddedChannel(parent.Object, DefaultChannelId.NewInstance(), false, true, new ChannelHandlerAdapter());
IChannelHandlerContext ctx = channel.Pipeline.FirstContext();
Http2ServerUpgradeCodec codec;
if (multiplexer == null)
{
codec = new Http2ServerUpgradeCodec(handler);
}
else
{
codec = new Http2ServerUpgradeCodec((Http2FrameCodec)handler, multiplexer);
}
Assert.True(codec.PrepareUpgradeResponse(ctx, request, new DefaultHttpHeaders()));
codec.UpgradeTo(ctx, request);
// Flush the channel to ensure we write out all buffered data
channel.Flush();
channel.WriteInbound(Http2CodecUtil.ConnectionPrefaceBuf());
Http2FrameInboundWriter writer = new Http2FrameInboundWriter(channel);
writer.WriteInboundSettings(new Http2Settings());
writer.WriteInboundRstStream(Http2CodecUtil.HttpUpgradeStreamId, Http2Error.Cancel);
Assert.Same(handler, channel.Pipeline.Remove <Http2ConnectionHandler>());
Assert.Null(channel.Pipeline.Get <Http2ConnectionHandler>());
Assert.True(channel.Finish());
// Check that the preface was send (a.k.a the settings frame)
var settingsBuffer = channel.ReadOutbound <IByteBuffer>();
Assert.NotNull(settingsBuffer);
settingsBuffer.Release();
var buf = channel.ReadOutbound <IByteBuffer>();
Assert.NotNull(buf);
buf.Release();
Assert.Null(channel.ReadOutbound());
}
private void SetUp(Http2FrameCodecBuilder frameCodecBuilder, Http2Settings initialRemoteSettings)
{
// Some tests call this method twice. Once with JUnit's @Before and once directly to pass special settings.
// This call ensures that in case of two consecutive calls to setUp(), the previous channel is shutdown and
// ByteBufs are released correctly.
Dispose0();
_frameWriter = Http2TestUtil.MockedFrameWriter();
var builder = frameCodecBuilder.FrameWriter(_frameWriter.Object);
builder.FrameLogger = new Http2FrameLogger(Common.Internal.Logging.InternalLogLevel.TRACE);
builder.InitialSettings = initialRemoteSettings;
_frameCodec = frameCodecBuilder.Build();
_inboundHandler = new LastInboundHandler();
_channel = new EmbeddedChannel();
_frameInboundWriter = new Http2FrameInboundWriter(_channel);
//channel.Connect(new InetSocketAddress(0));
_channel.Pipeline.AddLast(_frameCodec);
_channel.Pipeline.AddLast(_inboundHandler);
_channel.Pipeline.FireChannelActive();
// Handshake
_frameWriter.Verify(
x => x.WriteSettingsAsync(
It.Is <IChannelHandlerContext>(v => v == _frameCodec._ctx),
It.IsAny <Http2Settings>(),
It.IsAny <IPromise>()));
_frameWriter.VerifyNoOtherCalls();
_channel.WriteInbound(Http2CodecUtil.ConnectionPrefaceBuf());
_frameInboundWriter.WriteInboundSettings(initialRemoteSettings);
_frameWriter.Verify(
x => x.WriteSettingsAckAsync(
It.Is <IChannelHandlerContext>(v => v == _frameCodec._ctx),
It.IsAny <IPromise>()));
_frameInboundWriter.WriteInboundSettingsAck();
var settingsFrame = _inboundHandler.ReadInbound <IHttp2SettingsFrame>();
Assert.NotNull(settingsFrame);
var settingsAckFrame = _inboundHandler.ReadInbound <IHttp2SettingsAckFrame>();
Assert.NotNull(settingsAckFrame);
}
public void ServerReceivingClientPrefaceStringFollowedByNonSettingsShouldHandleException()
{
_connection.Setup(x => x.IsServer).Returns(true);
_handler = NewHandler();
// Create a connection preface followed by a bunch of zeros (i.e. not a settings frame).
IByteBuffer buf = Unpooled.Buffer().WriteBytes(Http2CodecUtil.ConnectionPrefaceBuf()).WriteZero(10);
_handler.ChannelRead(_ctx.Object, buf);
var captor = new ArgumentCaptor <IByteBuffer>();
_frameWriter.Verify(
x => x.WriteGoAwayAsync(
It.Is <IChannelHandlerContext>(v => v == _ctx.Object),
It.Is <int>(v => v == 0),
It.Is <Http2Error>(v => v == Http2Error.ProtocolError),
It.Is <IByteBuffer>(v => captor.Capture(v)),
It.Is <IPromise>(v => v == _promise)),
Times.AtLeastOnce);
Assert.Equal(0, captor.GetValue().ReferenceCount);
}
public void ServerReceivingValidClientPrefaceStringShouldContinueReadingFrames()
{
_connection.Setup(x => x.IsServer).Returns(true);
_handler = NewHandler();
IByteBuffer prefacePlusSome = AddSettingsHeader(Unpooled.Buffer().WriteBytes(Http2CodecUtil.ConnectionPrefaceBuf()));
_handler.ChannelRead(_ctx.Object, prefacePlusSome);
_decoder.Verify(
x => x.DecodeFrame(
It.Is <IChannelHandlerContext>(v => v == _ctx.Object),
It.IsAny <IByteBuffer>(),
It.IsAny <List <object> >()),
Times.AtLeastOnce);
}