public ObservableChannelTests()
{
_channel = Substitute.For <IChannel>();
var messageSubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1);
_messageStream = messageSubject.AsObservable();
_observableChannel = new ObservableChannel(_messageStream, _channel);
}
public static IObservableChannel MockObservableChannel(IObservable <IObserverDto <ProtocolMessage> > replaySubject)
{
var mockChannel = Substitute.For <IChannel>();
var mockEventStream = replaySubject.AsObservable();
var observableChannel = new ObservableChannel(mockEventStream, mockChannel);
return(observableChannel);
}
public RpcClientTests()
{
_testScheduler = new TestScheduler();
_logger = Substitute.For <ILogger>();
_peerIdentifier = PeerIdHelper.GetPeerId("Test");
_channelHandlerContext = Substitute.For <IChannelHandlerContext>();
_channelFactory = Substitute.For <ITcpClientChannelFactory>();
_clientEventLoopGroupFactory = Substitute.For <ITcpClientEventLoopGroupFactory>();
_mockSocketReplySubject = new ReplaySubject <IObserverDto <ProtocolMessage> >(1, _testScheduler);
var mockChannel = Substitute.For <IChannel>();
var mockEventStream = _mockSocketReplySubject.AsObservable();
var observableChannel = new ObservableChannel(mockEventStream, mockChannel);
_channelFactory.BuildChannelAsync(_clientEventLoopGroupFactory, Arg.Any <IPAddress>(), Arg.Any <int>(),
Arg.Any <X509Certificate2>()).Returns(observableChannel);
_rpcClientConfig = Substitute.For <IRpcClientConfig>();
_rpcClientConfig.HostAddress = IPAddress.Any;
_rpcClientConfig.NodeId = "0";
_rpcClientConfig.PfxFileName = "pfx";
_rpcClientConfig.Port = 9000;
}
void ObserveOutputIdle(bool writer)
{
TimeSpan writerIdleTime = this.zeroSecond;
TimeSpan allIdleTime = this.zeroSecond;
IdleStateEvent expected;
if (writer)
{
writerIdleTime = TimeSpan.FromSeconds(5);
expected = IdleStateEvent.FirstWriterIdleStateEvent;
}
else
{
allIdleTime = TimeSpan.FromSeconds(5);
expected = IdleStateEvent.FirstAllIdleStateEvent;
}
var idleStateHandler = new TestableIdleStateHandler(
true, this.zeroSecond, writerIdleTime, allIdleTime);
var events = new List <object>();
var handler = new TestEventChannelInboundHandlerAdapter(events);
var channel = new ObservableChannel(idleStateHandler, handler);
try
{
// We're writing 3 messages that will be consumed at different rates!
channel.WriteAndFlushAsync(Unpooled.WrappedBuffer(new byte[] { 1 }));
channel.WriteAndFlushAsync(Unpooled.WrappedBuffer(new byte[] { 2 }));
channel.WriteAndFlushAsync(Unpooled.WrappedBuffer(new byte[] { 3 }));
channel.WriteAndFlushAsync(Unpooled.WrappedBuffer(new byte[5 * 1024]));
// Establish a baseline. We're not consuming anything and let it idle once.
idleStateHandler.TickRun();
Assert.Single(events);
Assert.Same(expected, events[0]);
events.Clear();
// Our ticker should be at second 5
Assert.Equal(TimeSpan.FromSeconds(5), idleStateHandler.Tick);
// Consume one message in 4 seconds, then be idle for 2 seconds,
// then run the task and we shouldn't get an IdleStateEvent because
// we haven't been idle for long enough!
idleStateHandler.DoTick(TimeSpan.FromSeconds(4));
AssertNotNullAndRelease(channel.Consume());
idleStateHandler.TickRun(TimeSpan.FromSeconds(2));
Assert.Empty(events);
Assert.Equal(TimeSpan.FromSeconds(11), idleStateHandler.Tick); // 5s + 4s + 2s
// Consume one message in 3 seconds, then be idle for 4 seconds,
// then run the task and we shouldn't get an IdleStateEvent because
// we haven't been idle for long enough!
idleStateHandler.DoTick(TimeSpan.FromSeconds(3));
AssertNotNullAndRelease(channel.Consume());
idleStateHandler.TickRun(TimeSpan.FromSeconds(4));
Assert.Empty(events);
Assert.Equal(TimeSpan.FromSeconds(18), idleStateHandler.Tick); // 11s + 3s + 4s
// Don't consume a message and be idle for 5 seconds.
// We should get an IdleStateEvent!
idleStateHandler.TickRun(TimeSpan.FromSeconds(5));
Assert.Single(events);
Assert.Equal(TimeSpan.FromSeconds(23), idleStateHandler.Tick); // 18s + 5s
events.Clear();
// Consume one message in 2 seconds, then be idle for 1 seconds,
// then run the task and we shouldn't get an IdleStateEvent because
// we haven't been idle for long enough!
idleStateHandler.DoTick(TimeSpan.FromSeconds(2));
AssertNotNullAndRelease(channel.Consume());
idleStateHandler.TickRun(TimeSpan.FromSeconds(1));
Assert.Empty(events);
Assert.Equal(TimeSpan.FromSeconds(26), idleStateHandler.Tick); // 23s + 2s + 1s
// Consume part of the message every 2 seconds, then be idle for 1 seconds,
// then run the task and we should get an IdleStateEvent because the first trigger
idleStateHandler.DoTick(TimeSpan.FromSeconds(2));
AssertNotNullAndRelease(channel.ConsumePart(1024));
idleStateHandler.DoTick(TimeSpan.FromSeconds(2));
AssertNotNullAndRelease(channel.ConsumePart(1024));
idleStateHandler.TickRun(TimeSpan.FromSeconds(1));
Assert.Single(events);
Assert.Equal(TimeSpan.FromSeconds(31), idleStateHandler.Tick); // 26s + 2s + 2s + 1s
events.Clear();
// Consume part of the message every 2 seconds, then be idle for 1 seconds,
// then consume all the rest of the message, then run the task and we shouldn't
// get an IdleStateEvent because the data is flowing and we haven't been idle for long enough!
idleStateHandler.DoTick(TimeSpan.FromSeconds(2));
AssertNotNullAndRelease(channel.ConsumePart(1024));
idleStateHandler.DoTick(TimeSpan.FromSeconds(2));
AssertNotNullAndRelease(channel.ConsumePart(1024));
idleStateHandler.TickRun(TimeSpan.FromSeconds(1));
Assert.Empty(events);
Assert.Equal(TimeSpan.FromSeconds(36), idleStateHandler.Tick); // 31s + 2s + 2s + 1s
idleStateHandler.DoTick(TimeSpan.FromSeconds(2));
AssertNotNullAndRelease(channel.ConsumePart(1024));
// There are no messages left! Advance the ticker by 3 seconds,
// attempt a consume() but it will be null, then advance the
// ticker by an another 2 seconds and we should get an IdleStateEvent
// because we've been idle for 5 seconds.
idleStateHandler.DoTick(TimeSpan.FromSeconds(3));
Assert.Null(channel.Consume());
idleStateHandler.TickRun(TimeSpan.FromSeconds(2));
Assert.Single(events);
Assert.Equal(TimeSpan.FromSeconds(43), idleStateHandler.Tick); // 36s + 2s + 3s + 2s
// q.e.d.
}
finally
{
channel.FinishAndReleaseAll();
}
}
