public void OneMessage() { Message[] recievedMsgs = null; var endPoint = new Endpoint("localhost", 23456); using (var reciever = new Receiver(new IPEndPoint(IPAddress.Loopback, 23456), messages => { recievedMsgs = messages; return MockRepository.GenerateStub<IMessageAcceptance>(); }, ObjectMother.Logger())) { reciever.Start(); new Sender(ObjectMother.Logger()) { Destination = endPoint, Messages = new[] { new Message { Data = new byte[] {1, 2, 4, 5, 6}, SentAt = new DateTime(2001, 1, 1), Queue = "hello doggy", Id = MessageId.GenerateRandom() }, } }.Send(); Wait.Until(() => recievedMsgs != null).ShouldBeTrue(); recievedMsgs.ShouldHaveCount(1); "hello doggy".ShouldEqual(recievedMsgs[0].Queue); new byte[] { 1, 2, 4, 5, 6 }.ShouldEqual(recievedMsgs[0].Data); new DateTime(2001, 1, 1).ShouldEqual(recievedMsgs[0].SentAt); } }
public void CanHandleClientConnectAndDisconnect() { using (var reciever = new Receiver(_endpointToListenTo, messages => null, _logger)) { reciever.Start(); using (var client = new TcpClient()) { client.Connect(_endpointToListenTo); } Wait.Until(() => _logger.InfoMessages .Any(x => x.StartsWith("Could not process Reading Length"))).ShouldBeTrue(); } }
public void CanHandleClientSendingNegativeNumberForLength() { using (var reciever = new Receiver(_endpointToListenTo, messages => null)) { reciever.Start(); using (var client = new TcpClient()) { client.Connect(_endpointToListenTo); client.GetStream().Write(BitConverter.GetBytes(-2), 0, 4); } Wait.Until(() => _logger.InfoMessages .Any(x => x.Contains("Got invalid length -2"))).ShouldBeTrue(); } }
public void CanHandleClientConnectAndDisconnect() { using (var reciever = new Receiver(_endpointToListenTo, messages => null, _logger)) { reciever.Start(); using (var client = new TcpClient()) { client.Connect(_endpointToListenTo); } Wait.Until(() => (from e in _logger.InfoMessages.OfType<StringMessage>() where e.Message.StartsWith("Could not process Reading Length") select e).Any()).ShouldBeTrue(); } }
public void CanHandleClientSendingBadLengthOfData() { using (var reciever = new Receiver(_endpointToListenTo, messages => null)) { reciever.Start(); using (var client = new TcpClient()) { client.Connect(_endpointToListenTo); var stream = client.GetStream(); stream.Write(BitConverter.GetBytes(16), 0, 4); stream.Write(BitConverter.GetBytes(5), 0, 4); } Wait.Until(() => _logger.InfoMessages .Any(x => x.Contains("Could not process Reading Message"))).ShouldBeTrue(); } }
public void Start() { AssertNotDisposedOrDisposing(); if (_wasStarted) throw new InvalidOperationException("The Start method may not be invoked more than once."); _receiver = new Receiver(_endpoint, AcceptMessages); _receiver.Start(); _choke = new SendingChoke(); _queuedMessagesSender = new QueuedMessagesSender(_queueStorage, _choke, _logger); _sendingThread = new Thread(_queuedMessagesSender.Send) { IsBackground = true, Name = "Lightning Queues Sender Thread for " + _path }; _sendingThread.Start(); _wasStarted = true; }
public void CanHandleClientSendingThreeBytesAndDisconnecting() { using (var reciever = new Receiver(_endpointToListenTo, messages => null)) { reciever.Start(); using (var client = new TcpClient()) { client.Connect(_endpointToListenTo); client.GetStream().Write(new byte[] { 1, 4, 6 }, 0, 3); } Wait.Until(() => _logger.InfoMessages .Any(x => x.StartsWith("Could not process Reading Length"))).ShouldBeTrue(); } }
public void WillTellSenderIfCommitFailed() { var acceptance = MockRepository.GenerateStub<IMessageAcceptance>(); acceptance.Stub(x => x.Commit()).Throw(new InvalidOperationException()); using (var reciever = new Receiver(_endpointToListenTo, messages => acceptance)) { reciever.Start(); using (var client = new TcpClient()) { client.Connect(_endpointToListenTo); var stream = client.GetStream(); var serialize = new Message[0].Serialize(); stream.Write(BitConverter.GetBytes(serialize.Length), 0, 4); stream.Write(serialize, 0, serialize.Length); var buffer = new byte[ProtocolConstants.RecievedBuffer.Length]; stream.Read(buffer, 0, buffer.Length); ProtocolConstants.RecievedBuffer.ShouldEqual(buffer); stream.Write(ProtocolConstants.AcknowledgedBuffer, 0, ProtocolConstants.AcknowledgedBuffer.Length); buffer = new byte[ProtocolConstants.RevertBuffer.Length]; stream.Read(buffer, 0, buffer.Length); ProtocolConstants.RevertBuffer.ShouldEqual(buffer); } } }
public void WillSendConfirmationForClient() { var acceptance = MockRepository.GenerateStub<IMessageAcceptance>(); using (var reciever = new Receiver(_endpointToListenTo, messages => acceptance)) { reciever.Start(); using (var client = new TcpClient()) { client.Connect(_endpointToListenTo); var stream = client.GetStream(); var serialize = new Message[0].Serialize(); stream.Write(BitConverter.GetBytes(serialize.Length), 0, 4); stream.Write(serialize, 0, serialize.Length); var buffer = new byte[ProtocolConstants.RecievedBuffer.Length]; stream.Read(buffer, 0, buffer.Length); ProtocolConstants.RecievedBuffer.ShouldEqual(buffer); } } }
public void WillLetSenderKnowThatMessagesWereSentToInvalidQueue() { using (var reciever = new Receiver(_endpointToListenTo, messages => { throw new QueueDoesNotExistsException(); })) { reciever.Start(); using (var client = new TcpClient()) { client.Connect(_endpointToListenTo); var stream = client.GetStream(); var serialize = new Message[0].Serialize(); stream.Write(BitConverter.GetBytes(serialize.Length), 0, 4); stream.Write(serialize, 0, serialize.Length); var buffer = new byte[ProtocolConstants.ProcessingFailureBuffer.Length]; stream.Read(buffer, 0, buffer.Length); ProtocolConstants.QueueDoesNoExiststBuffer.ShouldEqual(buffer); } } }
public void WillCallCommitAcceptanceIfSenderSendConfirmation() { var commitCalled = false; var acceptance = MockRepository.GenerateStub<IMessageAcceptance>(); acceptance.Expect(x => x.Commit()).WhenCalled(x => commitCalled = true); using (var reciever = new Receiver(_endpointToListenTo, messages => acceptance)) { reciever.Start(); using (var client = new TcpClient()) { client.Connect(_endpointToListenTo); var stream = client.GetStream(); var serialize = new Message[0].Serialize(); stream.Write(BitConverter.GetBytes(serialize.Length), 0, 4); stream.Write(serialize, 0, serialize.Length); var buffer = new byte[ProtocolConstants.RecievedBuffer.Length]; stream.Read(buffer, 0, buffer.Length); ProtocolConstants.RecievedBuffer.ShouldEqual(buffer); stream.Write(ProtocolConstants.AcknowledgedBuffer, 0, ProtocolConstants.AcknowledgedBuffer.Length); } } Wait.Until(() => commitCalled); acceptance.VerifyAllExpectations(); }
public void CanHandleSlowClients() { using (var reciever = new Receiver(_endpointToListenTo, messages => null, _logger)) { reciever.Timeout = TimeSpan.FromMilliseconds(500); reciever.Start(); using (var client = new TcpClient()) { client.Connect(_endpointToListenTo); var stream = client.GetStream(); stream.Write(BitConverter.GetBytes(16), 0, 4); Thread.Sleep(1000); stream.Write(Guid.NewGuid().ToByteArray(), 0, 16); } Wait.Until(() => _logger.InfoMessages .Any(x => x.Contains("TimeoutException"))).ShouldBeTrue(); } }
public void CanHandleClientSendingUnseriliazableData() { using (var reciever = new Receiver(_endpointToListenTo, messages => null)) { reciever.Start(); using (var client = new TcpClient()) { client.Connect(_endpointToListenTo); var stream = client.GetStream(); stream.Write(BitConverter.GetBytes(16), 0, 4); stream.Write(Guid.NewGuid().ToByteArray(), 0, 16); } Wait.Until(() =>_logger.InfoMessages .Any(x => x.Contains("Unable to deserialize messages"))).ShouldBeTrue(); } }