public void ExecuteCommand_WhenCalled_ShouldTrySendInstruction()
{
Mock.Arrange(() => _instructionSenderHolder.HasActiveSender).Returns(true);
Mock.Arrange(() => _instructionSenderHolder.TrySendInstruction(Arg.IsAny <IEnumerable <byte> >()))
.Returns(Task.FromResult((true, Enumerable.Empty <byte>())));
_sut.ExecuteCommand("command");
Mock.Assert(() => _instructionSenderHolder.TrySendInstruction(Arg.IsAny <IEnumerable <byte> >()), Occurs.Once());
Mock.Assert(() => _recorder.RecordError(Arg.AnyString, Arg.AnyString), Occurs.Never());
}
public void TrySendText_WhenCalled_ShouldCallTrySendInstruction()
{
var instructionsReceiver = Mock.Create <IInstructionReceiver>();
Mock.Arrange(() => instructionsReceiver.TrySendInstruction(Arg.IsAny <IEnumerable <byte> >())).Returns(Task.FromResult((true, Enumerable.Empty <byte>())));
_sutSender = new RemoteApiMap(instructionsReceiver, _recorder);
_sutSender.TrySendText("Test");
Mock.Assert(() => instructionsReceiver.TrySendInstruction(Arg.IsAny <IEnumerable <byte> >()), Occurs.Once());
Mock.Assert(() => _recorder.RecordError(Arg.AnyString, Arg.AnyString), Occurs.Never());
}
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 InstructionReceived_WhenRaisedWithEmpty_ShouldRecordError()
{
var received = "string.Empty";
_sut.TextReceived += s => received = s;
Mock.Raise(() => _connectParser.InstructionReceived += null, "");
Mock.Assert(() => _recorder.RecordError(Arg.AnyString, Arg.AnyString), Occurs.Once());
Assert.Equal("string.Empty", received);
}
public void ResponseInnerCall_WhenCalledFirst_ShouldNotReceiveData()
{
var actualReceived = default(IEnumerable <byte>);
var data = BitConverter.GetBytes(23443223);
var dataWithPrefix = GenerateDataWithPrefix(Session.RESPONSE, data);
_sut = new Session(_networkTunnel, _recorder);
_sut.Received += received => actualReceived = received;
Mock.Raise(() => _networkTunnel.Received += null, dataWithPrefix.ToArray());
Mock.Assert(() => _recorder.RecordError(Arg.AnyString, Arg.AnyString), Occurs.Once());
Assert.Equal(default(IEnumerable <byte>), actualReceived);
}
public void TrySendInstruction_WhenCalledWithoutSession_ShouldSendCachError()
{
var dataToSend = ((byte)0b1011_1111).ToEnumerable();
_sut.TrySendInstruction(dataToSend);
Mock.Assert(() => _recorder.RecordError(Arg.AnyString, Arg.AnyString), Occurs.Exactly(1));
}
// RESPONSE (INNER CALL)
private void ResponseInternal(IEnumerable <byte> data)
{
if (!_requestFromRemoteReceived)
{
_recorder.RecordError(this.GetType().Name,
"Trying to send response without inner call");
return;
}
_requestFromRemoteReceived = false;
var nextPrefix = _responseCalculator.GenerateIndexToSend(RESPONSE);
var dataWithPrefix = data.WrapDataWithFirstByte(nextPrefix);
_networkTunnel?.Send(dataWithPrefix.ToArray());
}
public async Task AcceptAsync_Throws_ShouldBeCaught()
{
var socketMock = Mock.Create <ISocket>();
Mock.Arrange(() => socketMock.AcceptAsync()).IgnoreArguments().Throws(new Exception("exception"));
Mock.Arrange(() => socketMock.Close()).IgnoreArguments().Throws(new Exception("exception"));
var socketFactory = ArrangeSocketFactory(socketMock, false);
var networkTunnelFactory = ArrangeNetworkTunnelFactory();
var networkAddress = ArrangeNetworkAddress(IPAddress.Any, 20);
_sut = CreateNetworkPoint(networkAddress, networkTunnelFactory, socketFactory, _recorder);
Mock.Assert(() => _recorder.RecordError(Arg.AnyString, Arg.AnyString), Occurs.Exactly(1));
}
public async Task <bool> TrySendText(string instruction)
{
if (!_instructionsReceiver.HasActiveSession)
{
return(false);
}
var result = await _instructionsReceiver.TrySendInstruction(instruction.ToEnumerableByte());
if (!result.Item1)
{
_recorder?.RecordError(GetType().Name, "Fail to send text");
}
return(result.Item1);
}
public async void OperatorConstructor_WhenCalled_ShouldCallReceiveInAcceptedSocket()
{
var socketTester1 = new SocketTester("connector");
var socketTester2 = new SocketTester("listener");
var socketTester3 = new SocketTester("accepted");
var socketFactory = ArrangeSocketFactoryLocal(socketTester1, socketTester2, socketTester3);
var remoteTraceMonitorСonsistent = new RemoteTraceMonitorСonsistentTester(null);
CreateLocalOperator(socketFactory, _cacheRecorder, remoteTraceMonitorСonsistent);
await remoteTraceMonitorСonsistent.Initialized;
_output.WriteLine("Errors:");
_output.WriteLine(_cacheRecorder.ErrorCache);
_output.WriteLine("Info:");
_output.WriteLine(_cacheRecorder.InfoCache);
Assert.Equal(3, socketTester3.ReceiveCalledTimes);
Mock.Assert(() => _recorder.DefaultException(Arg.IsAny <Object>(), Arg.IsAny <Exception>()),
Occurs.Never());
Mock.Assert(() => _recorder.RecordError(Arg.IsAny <string>(), Arg.IsAny <string>()),
Occurs.Never());
}
private void ExceptionHandler(Exception exception)
{
_recorder.RecordError(nameof(NetworkConnector), exception.Message);
}
private void RecordError(string message)
{
_recorder.RecordError(nameof(NetworkTunnel), BuildMessageError(message));
}
private void ExceptionHandler(Exception exception)
{
Close();
_recorder.RecordError(nameof(NetworkPoint), exception.Message);
}
