public ServerClientTests()
{
tcpClient = A.Fake <ITcpClient>();
stream = A.Fake <INetworkStream>();
reader = A.Fake <IMessageStreamReader>();
sender = A.Fake <IMessagesSender>();
config = A.Fake <ICsConfiguration>();
mediator = A.Fake <IMediator>();
A.CallTo(() => config.Address).Returns(IPAddress.Loopback);
A.CallTo(() => config.Port).Returns(1234);
A.CallTo(() => tcpClient.GetStream()).Returns(stream);
A.CallTo(() => reader.MayHaveMessages).ReturnsLazily(() => messagesRead = !messagesRead);
A.CallTo(() => reader.ReadAvailable()).ReturnsLazily(() => A.CollectionOfFake <IMessage>(1).ToArray());
Func <ITcpClient> clientFactory = () =>
{
tcpClientCreated = true;
return(tcpClient);
};
Func <INetworkStream, IMessageStreamReader> readerFactory = s =>
{
if (s == stream)
{
readerCreated = true;
return(reader);
}
throw new InvalidOperationException();
};
serverClient = new ServerClient(config, sender, mediator, clientFactory, readerFactory);
}
public IMessageTransmitter CreateMessageTransmitter(Stream baseStream)
{
IMessageStreamReader messageStreamReader = this.CreateMessageStreamReader(baseStream, this.InteractionLog);
IMessageStreamWriter messageStreamWriter = this.CreateMessageStreamWriter(baseStream, this.InteractionLog);
return(new MessageTransmitter(messageStreamReader,
messageStreamWriter,
baseStream,
this.MessageRoundTripTimeout));
}
public MessageTransmitter(IMessageStreamReader messageStreamReader,
IMessageStreamWriter messageStreamWriter,
Stream baseStream)
:
this(messageStreamReader,
messageStreamWriter,
baseStream,
MessageTransmitter.DefaultMessageRoundTripTimeout)
{
}
private IReadOnlyList <IMessage> TryReadResponse(IMessageStreamReader reader)
{
try
{
return(reader.ReadAll());
}
catch (Exception ex)
{
logger.Error("Reading failed, re-throwing CannotSendMessageException.", ex);
throw new CannotSendMessageException("Cannot read response from the server.", ex);
}
}
public MessageStreamReaderTests()
{
stream = A.Fake <NetworkMemoryStream>(o => o.CallsBaseMethods());
deserializer = A.Fake <IMessageDeserializer>();
preparedMessage = A.Fake <IMessage>();
A.CallTo(() => deserializer.Deserialize(null, 0, 0))
.WhenArgumentsMatch(FirstMessage)
.Returns(preparedMessage);
parser = new MessageStreamReader(deserializer, stream);
}
public MessageTransmitter(IMessageStreamReader messageStreamReader,
IMessageStreamWriter messageStreamWriter,
Stream baseStream,
TimeSpan messageRoundTripTimeout)
{
this.MessageStreamReader = messageStreamReader;
this.MessageStreamReader.MessageProcessingError += this.OnMessageProcessingError;
this.MessageStreamWriter = messageStreamWriter;
this.BaseStream = baseStream;
this.MessageRoundTripTimeout = messageRoundTripTimeout;
this.Observable = (from messageEnvelope in this.MessageStreamReader
select messageEnvelope.Message).Publish();
}
/// <remarks>
/// We don't have a way to reliably test for TCP/IP connection close or end-of-message, so we use this kind of
/// hack. This class is rather untestable (data must be injected to the stream during the SpinWait).
/// </remarks>
public static IReadOnlyList <IMessage> ReadAll(this IMessageStreamReader stream)
{
var msgs = new List <IMessage>();
int waitTime = 1000;
while (stream.MayHaveMessages)
{
var part = stream.ReadAvailable();
if (part.Count == 0)
{
Thread.SpinWait(waitTime);
waitTime *= 2;
}
else
{
msgs.AddRange(part);
}
}
return(msgs);
}
