public void ConstructorCall_WithParameters_ShouldRecordMessage()
{
_recorder = Mock.Create <IRecorder>();
_sut = new NetworkTunnel(_socket, _recorder);
Mock.Assert(() => _recorder.RecordInfo(Arg.AnyString, Arg.AnyString), Occurs.Exactly(1));
}
public void Send_WithParameters_ShouldSentWithSameParameters()
{
var paramToSent = new byte[] { 0b01010101 };
_sut = new NetworkTunnel(_socket, _recorder);
_sut.Send(paramToSent);
Mock.Assert(() => _socket.Send(paramToSent), Occurs.Once());
}
public void Send_Throws_ShouldBeCaught()
{
var paramToSent = new byte[] { 0b01010101 };
Mock.Arrange(() => _socket.Send(null)).IgnoreArguments().Throws(new SocketException());
_sut = new NetworkTunnel(_socket, _recorder);
_sut.Send(paramToSent);
Mock.Assert(() => _recorder.RecordError(Arg.AnyString, Arg.AnyString), Occurs.Once());
}
public void Dispose_CalledTwice_ShouldCallSocketDisposeOnce()
{
var socket = Mock.Create <ISocket>();
Mock.Arrange(() => socket.Connected).Returns(true);
_sut = new NetworkTunnel(socket, _recorder);
_sut.Dispose();
_sut.Dispose();
Mock.Assert(() => socket.Dispose(), Occurs.Once());
}
public void Send_ThrowsInterruptConnection_ShouldBeCaught()
{
var paramToSent = new byte[] { 0b01010101 };
Mock.Arrange(() => _socket.Send(null)).IgnoreArguments().Throws(new SocketException(10054));
_sut = new NetworkTunnel(_socket, _recorder);
_sut.Send(paramToSent);
Mock.Assert(() => _socket.Dispose(), Occurs.Exactly(1));
Mock.Assert(() => _recorder.RecordInfo(Arg.AnyString, Arg.AnyString), Occurs.Exactly(3));
Mock.Assert(() => _recorder.RecordError(Arg.AnyString, Arg.AnyString), Occurs.Never());
}
public async Task SocketReceive_Throws_ShouldBeCaught()
{
var socket = Mock.Create <ISocket>();
Mock.Arrange(() => socket.Receive(null)).IgnoreArguments().Throws(new SocketException());
Mock.Arrange(() => socket.Connected).Returns(true);
_sut = new NetworkTunnel(socket, _recorder);
_sut.Listen();
await Task.Delay(100);
Mock.Assert(() => _recorder.RecordError(Arg.AnyString, Arg.AnyString), Occurs.Once());
}
public void Dispose_CalledTwice_ShouldCallClosedEventOnce()
{
var closeRaised = 0;
var socket = Mock.Create <ISocket>();
Mock.Arrange(() => socket.Connected).Returns(true);
_sut = new NetworkTunnel(socket, _recorder);
_sut.Closed += () => closeRaised++;
_sut.Dispose();
_sut.Dispose();
Assert.Equal(1, closeRaised);
}
public bool TryConnect(INetworkAddress networkAddress, out INetworkTunnel networkTunnel)
{
bool result = false;
networkTunnel = default;
try
{
result = TryConnectInternal(networkAddress, out networkTunnel);
}
catch (Exception exception)
{
ExceptionHandler(exception);
}
return(result);
}
private bool TryConnectInternal(INetworkAddress networkAddress, out INetworkTunnel networkTunnel)
{
var socket = _socketFactory.Invoke(networkAddress.IP.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
var isFail = false;
networkTunnel = default;
SafeExecution.TryCatch(
() => socket.Connect(networkAddress.IP, networkAddress.Port),
e =>
{
SafeExecution.TryCatch(() => socket.Dispose(),
e => ExceptionHandler(e));
isFail = true;
});
if (!isFail)
{
networkTunnel = _networkTunnelFactory.Invoke(socket);
}
return(!isFail);
}
public Session(INetworkTunnel networkTunnel, IRecorder recorder)
{
_networkTunnel = networkTunnel;
_recorder = recorder;
_requestCalculator = new IndexerCalculator(false);
_responseCalculator = new IndexerCalculator(true);
_requestBytePrefix = REQUEST.ExtractBytePrefix();
_responseBytePrefix = RESPONSE.ExtractBytePrefix();
_responceEventMap = new Dictionary <byte, Action <IEnumerable <byte>, byte> >
{
{ _requestBytePrefix, BytesReceivedHandler },
{ _responseBytePrefix, BytesRespondedHandler },
{ 0, BytesUnknownHandler },
};
_networkTunnel.Listen();
_networkTunnel.Received += ReceivedHandler;
_networkTunnel.Closed += CloseHandler;
_requestFromRemoteReceived = false;
_requestToRemoteSent = false;
}
private ISession CreateSession(INetworkTunnel networkTunnel, IRecorder recorder)
{
return(new Session(networkTunnel, recorder));
}
protected virtual ISession SessionFactory(INetworkTunnel networkTunnel)
{
return(new Session(networkTunnel, _recorder));
}
private void AcceptedHandlerInternal(INetworkTunnel tunnel)
{
var session = _sessionFactory.Invoke(tunnel);
ConnectionReceived?.Invoke(session);
}
private void AcceptedHandler(INetworkTunnel tunnel)
{
SafeExecution.TryCatch(() => AcceptedHandlerInternal(tunnel), ExceptionHandler);
}
public SessionTests()
{
_networkTunnel = Mock.Create <INetworkTunnel>();
_recorder = Mock.Create <IRecorder>();
}
