public async Task ReadContinuously_Returns_If_Already_Reading(string username, IPEndPoint endpoint)
{
var streamMock = new Mock <INetworkStream>();
streamMock.Setup(s => s.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()))
.Throws(new Exception());
var tcpMock = new Mock <ITcpClient>();
using (var socket = new Socket(SocketType.Stream, ProtocolType.IP))
{
tcpMock.Setup(m => m.Client).Returns(socket);
tcpMock.Setup(s => s.Connected).Returns(true);
tcpMock.Setup(s => s.GetStream()).Returns(streamMock.Object);
using (var c = new MessageConnection(username, endpoint, tcpClient: tcpMock.Object))
{
c.SetProperty("ReadingContinuously", true);
await c.InvokeMethod <Task>("ReadContinuouslyAsync");
}
}
streamMock.Verify(m => m.ReadAsync(It.IsAny <byte[]>(), It.IsAny <int>(), It.IsAny <int>(), It.IsAny <CancellationToken>()), Times.Never);
}
public async Task WriteAsync_Throws_ArgumentException_When_Message_Is_Null(string username, IPEndPoint endpoint)
{
using (var c = new MessageConnection(username, endpoint))
{
c.SetProperty("State", ConnectionState.Disconnected);
var ex = await Record.ExceptionAsync(() => c.WriteAsync(message: null));
Assert.NotNull(ex);
Assert.IsType <ArgumentException>(ex);
Assert.Equal("message", ((ArgumentException)ex).ParamName);
}
}
public async Task WriteAsync_Throws_InvalidOperationException_When_Disconnecting(string username, IPEndPoint endpoint)
{
var msg = new BrowseRequest();
using (var c = new MessageConnection(username, endpoint))
{
c.SetProperty("State", ConnectionState.Disconnecting);
var ex = await Record.ExceptionAsync(() => c.WriteAsync(msg));
Assert.NotNull(ex);
Assert.IsType <InvalidOperationException>(ex);
}
}
public async Task WriteAsync_Throws_InvalidOperationException_When_Disconnecting(string username, IPAddress ipAddress, int port)
{
var msg = new MessageBuilder()
.WriteCode(MessageCode.Peer.BrowseRequest)
.Build();
var c = new MessageConnection(username, ipAddress, port);
c.SetProperty("State", ConnectionState.Disconnecting);
var ex = await Record.ExceptionAsync(async() => await c.WriteAsync(msg));
Assert.NotNull(ex);
Assert.IsType <InvalidOperationException>(ex);
}
public async Task WriteMessageAsync_Defers_When_Connecting(string username, IPAddress ipAddress, int port)
{
var msg = new MessageBuilder()
.Code(MessageCode.PeerBrowseRequest)
.Build();
var c = new MessageConnection(MessageConnectionType.Peer, username, ipAddress, port);
c.SetProperty("State", ConnectionState.Connecting);
await c.WriteMessageAsync(msg);
var deferred = c.GetProperty <ConcurrentQueue <Message> >("DeferredMessages");
Assert.Single(deferred);
}
public async Task WriteAsync_Throws_MessageException_When_Message_ToByteArray_Throws(string username, IPEndPoint endpoint)
{
var expectedEx = new Exception();
var msg = new Mock <IOutgoingMessage>();
msg.Setup(m => m.ToByteArray())
.Throws(expectedEx);
using (var c = new MessageConnection(username, endpoint))
{
c.SetProperty("State", ConnectionState.Disconnected);
var ex = await Record.ExceptionAsync(() => c.WriteAsync(msg.Object));
Assert.NotNull(ex);
Assert.IsType <MessageException>(ex);
Assert.Equal(expectedEx, ex.InnerException);
}
}
