public void should_send_message_to_replayer()
{
var targetPeer = new PeerId("Abc.Testing.Target");
var replayerMock = new Mock <IMessageReplayer>();
MockContainer.GetMock <IMessageReplayerRepository>().Setup(x => x.GetActiveMessageReplayer(targetPeer)).Returns(replayerMock.Object);
var transportMessage = new FakeCommand(1).ToTransportMessage();
var command = new PersistMessageCommand(transportMessage, new[] { targetPeer });
Handler.Handle(command);
replayerMock.Verify(x => x.AddLiveMessage(transportMessage));
}
public void should_persist_message()
{
using (SystemDateTime.PauseTime())
{
var transportMessage = new FakeCommand(42).ToTransportMessage();
var peerId = new PeerId("Abc.Testing.Target");
var command = new PersistMessageCommand(transportMessage, new[] { peerId });
Handler.Handle(command);
Wait.Until(() => _inMemoryMessageMatcher.CassandraInsertCount == 1, 2.Seconds());
_storageMock.Verify(x => x.Write(It.IsAny <IList <MatcherEntry> >()), Times.Once);
}
}
public void persistent_messages_sent_to_multiple_peers_should_only_be_persisted_for_persistent_ones()
{
using (MessageId.PauseIdGeneration())
{
var message = new FakeEvent(123).ToTransportMessage(Self);
var persistCommand = new PersistMessageCommand(message, new[] { AnotherPersistentPeer.Id }).ToTransportMessage(Self);
Transport.Send(message, new[] { AnotherPersistentPeer, AnotherNonPersistentPeer });
InnerTransport.ExpectExactly(
new TransportMessageSent(message, new[] { AnotherPersistentPeer, AnotherNonPersistentPeer }),
new TransportMessageSent(persistCommand, new[] { PersistencePeer })
);
}
}
public void should_not_send_completion_when_message_is_PersistMessageCommand()
{
using (MessageId.PauseIdGeneration())
{
var cmd = new PersistMessageCommand(new FakeCommand(123).ToTransportMessage(), new List <PeerId> {
new PeerId("Peer.Id")
});
SetupDispatch(cmd);
var transportMessageReceived = cmd.ToTransportMessage(_peerUp);
_transport.RaiseMessageReceived(transportMessageReceived);
_transport.Messages.ShouldNotContain(x => x.TransportMessage.MessageTypeId == MessageExecutionCompleted.TypeId);
}
}
public void should_serialize_persist_message_command()
{
var transportMessage = new FakeEvent(42).ToTransportMessage(_self);
var persistMessageCommand = new PersistMessageCommand(transportMessage, new PeerId("Abc.Testing.A"), new PeerId("Abc.Testing.B"));
var serializedTransportMessage = _messageSerializer.ToTransportMessage(persistMessageCommand, _self.Id, _self.EndPoint);
serializedTransportMessage.Id.ShouldEqual(transportMessage.Id);
serializedTransportMessage.MessageTypeId.ShouldEqual(transportMessage.MessageTypeId);
serializedTransportMessage.Content.ShouldEqual(transportMessage.Content);
serializedTransportMessage.Originator.ShouldEqual(transportMessage.Originator);
serializedTransportMessage.Environment.ShouldEqual(transportMessage.Environment);
serializedTransportMessage.WasPersisted.ShouldEqual(transportMessage.WasPersisted);
serializedTransportMessage.PersistentPeerIds.ShouldBeEquivalentTo(persistMessageCommand.Targets);
}
public void should_send_persistent_message_to_the_persistence_and_to_the_peer()
{
using (MessageId.PauseIdGeneration())
{
var message = new FakeCommand(123).ToTransportMessage();
Transport.Send(message, new[] { AnotherPersistentPeer });
var expectedPersistenceMessage = new PersistMessageCommand(message, new[] { AnotherPersistentPeer.Id }).ToTransportMessage(Self);
InnerTransport.ExpectExactly(new[]
{
new TransportMessageSent(message, AnotherPersistentPeer, true),
new TransportMessageSent(expectedPersistenceMessage, PersistencePeer),
});
}
}
private static TransportMessage ToTransportMessage(PersistMessageCommand persistMessageCommand) => persistMessageCommand.TransportMessage.ToPersistTransportMessage(persistMessageCommand.Targets);
