public void SendTest(string dest)
{
ITransportResolver resolver = MockTransportResolver();
using (var engine = new MessagingEngine(resolver, new SonicTransportFactory()))
{
engine.SerializationManager.RegisterSerializer("fake", typeof(string), new FakeStringSerializer());
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, dest), s => { }))
{
engine.Send(Guid.NewGuid().ToString(), new Endpoint(TransportConstants.TRANSPORT_ID1, dest));
Thread.Sleep(1000);
}
int i = 0;
Stopwatch sw = Stopwatch.StartNew();
var done = new ManualResetEvent(false);
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, dest), s =>
{
if (Interlocked.Increment(ref i) == 2961)
{
done.Set();
}
}))
{
var message = string.Join(",", Enumerable.Range(0, 100).Select(x => Guid.NewGuid().ToString()));
while (!done.WaitOne(0))
{
engine.Send(message, new Endpoint(TransportConstants.TRANSPORT_ID1, dest));
}
}
Console.WriteLine(sw.ElapsedMilliseconds);
}
}
public void ListenSameCommandOnDifferentEndpointsTest()
{
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null, "InMemory") }
})))
{
var commandHandler = new CommandHandler();
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.BoundedContext("bc")
.PublishingEvents(typeof(int)).With("eventExchange")
.ListeningCommands(typeof(string)).On("exchange1")
.ListeningCommands(typeof(string)).On("exchange2")
.WithCommandsHandler(commandHandler)))
{
engine.Start();
messagingEngine.Send("test1", new Endpoint("InMemory", "exchange1", serializationFormat: SerializationFormat.Json));
messagingEngine.Send("test2", new Endpoint("InMemory", "exchange2", serializationFormat: SerializationFormat.Json));
messagingEngine.Send("test3", new Endpoint("InMemory", "exchange3", serializationFormat: SerializationFormat.Json));
Thread.Sleep(6000);
Assert.That(commandHandler.AcceptedCommands, Is.EquivalentTo(new[] { "test1", "test2" }));
}
}
}
public void SendToOverflowenQueueFailureTest()
{
ITransportResolver resolver = MockTransportResolver();
//Assumption: queue capacity is 1mb
var halfMegabyteMessage = new string('a', 1 << 19);
using (var engine = new MessagingEngine(resolver, new SonicTransportFactory()))
{
engine.SerializationManager.RegisterSerializer("fake", typeof(string), new FakeStringSerializer());
engine.Send(halfMegabyteMessage, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"));
Exception exception = null;
var t = new Thread(() =>
{
try
{
engine.Send(halfMegabyteMessage, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"));
}
catch (Exception ex)
{
exception = ex;
}
});
t.Start();
Assert.That(t.Join(2000), Is.True, "Exception was not thrown when queue is overflowed");
Assert.That(exception, Is.Not.Null);
Console.WriteLine(exception);
}
}
public void ListenSameCommandOnDifferentEndpointsTest()
{
using (
var messagingEngine =
new MessagingEngine(
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null, "InMemory") }
})))
{
var commandHandler = new CommandHandler();
using (var engine = new CqrsEngine(messagingEngine,
new InMemoryEndpointResolver(),
LocalBoundedContext.Named("bc")
.PublishingEvents(typeof(int)).To("eventExchange").RoutedTo("eventQueue")
.ListeningCommands(typeof(string)).On("exchange1").On("exchange2").RoutedFrom("commandQueue")
.WithCommandsHandler(commandHandler))
)
{
messagingEngine.Send("test1", new Endpoint("InMemory", "bc.exchange1", serializationFormat: "json"));
messagingEngine.Send("test2", new Endpoint("InMemory", "bc.exchange2", serializationFormat: "json"));
messagingEngine.Send("test3", new Endpoint("InMemory", "bc.exchange3", serializationFormat: "json"));
Thread.Sleep(2000);
Assert.That(commandHandler.AcceptedCommands, Is.EquivalentTo(new[] { "test1", "test2" }));
}
}
}
public void InvestigationTest()
{
long count = 0;
var handled = new AutoResetEvent(false);
using (var engine = new MessagingEngine(
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "tr", new TransportInfo("localhost", "guest", "guest", "None", messaging: "RabbitMq") }
}), new RabbitMqTransportFactory()))
{
var eventStoreConnection = EventStoreConnection.Create(ConnectionSettings.Create().UseConsoleLogger().SetDefaultUserCredentials(new UserCredentials("admin", "changeit")),
new IPEndPoint(IPAddress.Loopback, 1113));
eventStoreConnection.Connect();
eventStoreConnection.SubscribeToAllFrom(Position.Start, false, (subscription, @event) =>
{
engine.Send(@event, new Endpoint("tr", "t1", true, "json"));
handled.Set();
count++;
}, subscription => { });
handled.WaitOne();
var sw = Stopwatch.StartNew();
while (handled.WaitOne(100))
{
}
Console.WriteLine("Published {0} events. Within {1}ms", count, sw.ElapsedMilliseconds);
}
}
public void EventLoggingInterceptorDoesNotBreakProcessingChain()
{
var eventLoggingInterceptor = new DefaultEventLoggingInterceptor(_logFactory);
var simpleEventInterceptor = new EventSimpleInterceptor();
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null) }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.EventInterceptors(eventLoggingInterceptor, simpleEventInterceptor),
Register.Saga <TestSaga>("test1")
.ListeningEvents(typeof(string)).From("lykke-wallet").On("lykke-wallet-events")))
{
engine.StartSubscribers();
messagingEngine.Send("1", new Endpoint("InMemory", "lykke-wallet-events", serializationFormat: SerializationFormat.Json));
Thread.Sleep(1000);
Assert.True(simpleEventInterceptor.Intercepted);
}
}
}
public void EventLoggingInterceptorTestForDefaultLogging()
{
var eventLoggingInterceptor = new DefaultEventLoggingInterceptor(_logFactory);
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null) }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.EventInterceptors(eventLoggingInterceptor),
Register.Saga <TestSaga>("test1")
.ListeningEvents(typeof(string)).From("lykke-wallet").On("lykke-wallet-events")))
{
engine.StartSubscribers();
using (var writer = new StringWriter())
{
var prevOut = Console.Out;
Console.SetOut(writer);
messagingEngine.Send("1", new Endpoint("InMemory", "lykke-wallet-events", serializationFormat: SerializationFormat.Json));
Thread.Sleep(1000);
Console.SetOut(prevOut);
var output = writer.ToString();
Assert.IsFalse(output.IsNullOrEmpty(), "Event was not logged");
}
}
}
}
public void EventLoggingInterceptorTest()
{
int eventLoggedCount = 0;
var eventLoggingInterceptor = new CustomEventLoggingInterceptor(
_logFactory,
new Dictionary <Type, EventLoggingDelegate>
{
{ typeof(string), (l, h, e) => ++ eventLoggedCount }
});
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null) }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.EventInterceptors(eventLoggingInterceptor),
Register.Saga <TestSaga>("test1")
.ListeningEvents(typeof(string)).From("lykke-wallet").On("lykke-wallet-events")))
{
engine.StartSubscribers();
messagingEngine.Send("1", new Endpoint("InMemory", "lykke-wallet-events", serializationFormat: SerializationFormat.Json));
Thread.Sleep(1000);
Assert.True(eventLoggedCount > 0, "Event was not logged");
Assert.True(eventLoggedCount == 1, "Event was logged more than once");
}
}
}
public void TwoSimpleCommandInterceptorsTest()
{
var commandSimpleInterceptorOne = new CommandSimpleInterceptor();
var commandSimpleInterceptorTwo = new CommandSimpleInterceptor();
var commandsHandler = new CommandsHandler();
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null) }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.CommandInterceptors(commandSimpleInterceptorOne, commandSimpleInterceptorTwo),
Register.BoundedContext("swift-cashout")
.ListeningCommands(typeof(int)).On("lykke-wallet-events")
.WithCommandsHandler(commandsHandler)))
{
engine.StartSubscribers();
messagingEngine.Send(1, new Endpoint("InMemory", "lykke-wallet-events", serializationFormat: SerializationFormat.Json));
Thread.Sleep(1000);
Assert.True(commandSimpleInterceptorOne.Intercepted);
Assert.True(commandSimpleInterceptorTwo.Intercepted);
Assert.NotNull(commandSimpleInterceptorOne.InterceptionTimestamp);
Assert.NotNull(commandSimpleInterceptorTwo.InterceptionTimestamp);
Assert.True(commandSimpleInterceptorOne.InterceptionTimestamp < commandSimpleInterceptorTwo.InterceptionTimestamp);
Assert.True(commandsHandler.HandledCommands.Count > 0);
}
}
}
public void EndToEndRabbitResubscriptionTest()
{
var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo> {
{ "test", new TransportInfo(HOST, "guest", "guest", null, "RabbitMq") }
}),
new RabbitMqTransportFactory(_logFactory));
using (messagingEngine)
{
for (int i = 0; i < 100; i++)
{
messagingEngine.Send(i, new Endpoint("test", TEST_EXCHANGE, serializationFormat: SerializationFormat.Json));
}
messagingEngine.Subscribe <int>(new Endpoint("test", TEST_QUEUE, serializationFormat: SerializationFormat.Json), message =>
{
Console.WriteLine(message + "\n");
Thread.Sleep(1000);
});
Thread.Sleep(30 * 60 * 1000);
}
Console.WriteLine("Done");
}
public void TwoSimpleEventInterceptorsTest()
{
var simpleEventInterceptorOne = new EventSimpleInterceptor();
var simpleEventInterceptorTwo = new EventSimpleInterceptor();
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null) }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.EventInterceptors(simpleEventInterceptorOne),
Register.EventInterceptors(simpleEventInterceptorTwo),
Register.Saga <TestSaga>("test2")
.ListeningEvents(typeof(string)).From("lykke-wallet").On("lykke-wallet-events")))
{
engine.StartSubscribers();
messagingEngine.Send("2", new Endpoint("InMemory", "lykke-wallet-events", serializationFormat: SerializationFormat.Json));
Thread.Sleep(1000);
Assert.True(simpleEventInterceptorOne.Intercepted);
Assert.True(simpleEventInterceptorTwo.Intercepted);
Assert.NotNull(simpleEventInterceptorOne.InterceptionTimestamp);
Assert.NotNull(simpleEventInterceptorTwo.InterceptionTimestamp);
Assert.True(simpleEventInterceptorOne.InterceptionTimestamp < simpleEventInterceptorTwo.InterceptionTimestamp);
Assert.True(TestSaga.Messages.Contains("2"));
}
}
}
public void CommandLoggingInterceptorDoesNotBreakProcessingChain()
{
var commandLoggingInterceptor = new DefaultCommandLoggingInterceptor(_logFactory);
var commandSimpleInterceptor = new CommandSimpleInterceptor();
var commandsHandler = new CommandsHandler();
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null) }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.CommandInterceptors(commandLoggingInterceptor, commandSimpleInterceptor),
Register.BoundedContext("test1")
.ListeningCommands(typeof(int)).On("lykke-wallet-events")
.WithCommandsHandler(commandsHandler)))
{
engine.StartSubscribers();
messagingEngine.Send(1, new Endpoint("InMemory", "lykke-wallet-events", serializationFormat: SerializationFormat.Json));
Thread.Sleep(1000);
Assert.True(commandSimpleInterceptor.Intercepted);
}
}
}
public void SendWithCustomProperties()
{
ITransportResolver resolver = ObjectMother.MockTransportResolver("WeblogicMoneymail");
using (IMessagingEngine engine = new MessagingEngine(resolver, new WeblogicCustomTransportFactory()))
{
engine.SerializationManager.RegisterSerializer("fake", typeof(string), new FakeStringSerializer());
engine.Send("hello world", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"));
}
}
public void EachDestinationIsSubscribedOnDedicatedThreadTest()
{
ITransportResolver resolver = MockTransportResolver();
using (var engine = new MessagingEngine(resolver, new SonicTransportFactory())){
engine.SerializationManager.RegisterSerializer("fake", typeof(string), new FakeStringSerializer());
var queue1MessagesThreadIds = new List <int>();
var queue2MessagesThreadIds = new List <int>();
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"), s => queue1MessagesThreadIds.Add(Thread.CurrentThread.ManagedThreadId)))
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: "fake"), s => queue2MessagesThreadIds.Add(Thread.CurrentThread.ManagedThreadId)))
{
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: "fake"));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: "fake"));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: "fake"));
Thread.Sleep(1000);
}
Assert.That(queue1MessagesThreadIds.Distinct().Any(), Is.True, "Messages were not processed");
Assert.That(queue2MessagesThreadIds.Distinct().Any(), Is.True, "Messages were not processed");
Assert.That(queue1MessagesThreadIds.Distinct().Count(), Is.EqualTo(1), "Messages from one subscription were processed in more then 1 thread");
Assert.That(queue2MessagesThreadIds.Distinct().Count(), Is.EqualTo(1), "Messages from one subscription were processed in more then 1 thread");
Assert.That(queue1MessagesThreadIds.First() != queue2MessagesThreadIds.First(), Is.True, "Messages from different subscriptions were processed one thread");
}
}
public void SendSubscribeWithTimeToLive()
{
ITransportResolver resolver = ObjectMother.MockTransportResolver("Weblogic");
using (IMessagingEngine engine = new MessagingEngine(resolver, new WeblogicTransportFactory()))
{
engine.SerializationManager.RegisterSerializer("fake", typeof(string), new FakeStringSerializer());
engine.Send("ping1", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"), 200);
engine.Send("ping2", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"), 1000);
Thread.Sleep(300);
var receivedMessages = new List <object>();
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: "fake"), receivedMessages.Add))
{
Thread.Sleep(1000);
}
Assert.AreEqual(1, receivedMessages.Count);
Assert.AreEqual("ping2", receivedMessages[0]);
}
}
public void SendSubscribeTest(string dest)
{
ITransportResolver resolver = MockTransportResolver();
using (var engine = new MessagingEngine(resolver, new SonicTransportFactory()))
{
engine.SerializationManager.RegisterSerializer("fake", typeof(string), new FakeStringSerializer());
var recievedMessages = new List <object>();
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, dest, serializationFormat: "fake"), recievedMessages.Add))
{
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, dest, serializationFormat: "fake"));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, dest, serializationFormat: "fake"));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, dest, serializationFormat: "fake"));
Thread.Sleep(1000);
}
Assert.That(recievedMessages.Count, Is.EqualTo(3), "Some messages were not received");
Assert.That(recievedMessages, Is.EqualTo(new[] { "test", "test", "test" }), "Some messages were corrupted");
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, dest, serializationFormat: "fake"));
Thread.Sleep(100);
Assert.That(recievedMessages.Count, Is.EqualTo(3),
"Subscription callback was called after subscription is disposed");
}
}
public void SubscriptionToClusterTest()
{
ITransportResolver transportResolver = new TransportResolver(new Dictionary <string, TransportInfo>()
{
{ "main", new TransportInfo("localhost1,localhost", "guest", "guest", "None", "RabbitMq") },
{ "sendTransport", new TransportInfo("localhost", "guest", "guest", "None", "RabbitMq") }
});
var endpoint = new Endpoint("main", TEST_EXCHANGE, TEST_QUEUE, true, SerializationFormat.Json);
var sendEndpoint = new Endpoint("sendTransport", TEST_EXCHANGE, TEST_QUEUE, true, SerializationFormat.Json);
using (var me = new MessagingEngine(_logFactory, transportResolver, new RabbitMqTransportFactory(_logFactory, false)))
{
me.Send(1, sendEndpoint);
me.ResubscriptionTimeout = 100;
var received = new ManualResetEvent(false);
me.Subscribe <int>(endpoint, i => received.Set());
Assert.That(received.WaitOne(1000), Is.True, "Subscription when first broker in list is not resolvable while next one is ok");
}
}
public void CommandLoggingInterceptorTestForNoLogging()
{
var commandLoggingInterceptor = new CustomCommandLoggingInterceptor(
_logFactory,
new Dictionary <Type, CommandLoggingDelegate>
{
{ typeof(int), null }
});
var commandsHandler = new CommandsHandler();
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null) }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.CommandInterceptors(commandLoggingInterceptor),
Register.BoundedContext("test1")
.ListeningCommands(typeof(int)).On("lykke-wallet-events")
.WithCommandsHandler(commandsHandler)))
{
engine.StartSubscribers();
using (var writer = new StringWriter())
{
var prevOut = Console.Out;
Console.SetOut(writer);
messagingEngine.Send(1, new Endpoint("InMemory", "lykke-wallet-events", serializationFormat: SerializationFormat.Json));
Thread.Sleep(1000);
Console.SetOut(prevOut);
var output = writer.ToString();
Assert.True(output.IsNullOrEmpty(), "Command was logged");
}
}
}
}
public void BatchDispatchUnackRmqTest()
{
var handler = new EventHandlerWithBatchSupport(1);
var endpointProvider = new Mock <IEndpointProvider>();
using (
var messagingEngine =
new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "RabbitMq", new TransportInfo("amqp://localhost", "guest", "guest", null, "RabbitMq") }
}), new RabbitMqTransportFactory(_logFactory)))
{
messagingEngine.CreateTemporaryDestination("RabbitMq", null);
var endpoint = new Endpoint("RabbitMq", "testExchange", "testQueue", true, SerializationFormat.Json);
endpointProvider.Setup(r => r.Get("route")).Returns(endpoint);
endpointProvider.Setup(r => r.Contains("route")).Returns(true);
using (var engine = new CqrsEngine(
_logFactory,
new DefaultDependencyResolver(),
messagingEngine,
endpointProvider.Object,
false,
Register.BoundedContext("bc")
.ListeningEvents(typeof(DateTime)).From("other").On("route")
.WithProjection(handler, "other", 1, 0,
h => h.OnBatchStart(),
(h, c) => h.OnBatchFinish(c)
)))
{
engine.StartSubscribers();
messagingEngine.Send(DateTime.Now, endpoint);
Thread.Sleep(20000);
}
}
}
public void UnknownMessageTest()
{
ITransportResolver transportResolver = new TransportResolver(new Dictionary <string, TransportInfo>()
{
{ "main", new TransportInfo(HOST, "guest", "guest", "None", "RabbitMq") }
});
var eq = new Endpoint("main", TEST_QUEUE, true, "json");
var ee = new Endpoint("main", TEST_EXCHANGE, true, "json");
using (var me = new MessagingEngine(transportResolver, new RabbitMqTransportFactory()))
{
me.Send("string value", ee);
}
using (var me = new MessagingEngine(transportResolver, new RabbitMqTransportFactory()))
{
me.Subscribe <int>(eq, Console.WriteLine);
me.Subscribe <double>(eq, Console.WriteLine);
// me.Subscribe<string>(eq, Console.WriteLine);
}
Thread.Sleep(1200);
}
public void ByDefaultEachDestinationIsSubscribedOnDedicatedThreadTest()
{
ITransportResolver resolver = MockTransportResolver();
using (var engine = new MessagingEngine(new LogToConsole(), resolver, new InMemoryTransportFactory()))
{
engine.SerializationManager.RegisterSerializer(SerializationFormat.Json, typeof(string), new FakeStringSerializer());
var queue1MessagesThreadIds = new List <int>();
var queue2MessagesThreadIds = new List <int>();
var messagesCounter = 0;
var allMessagesAreRecieved = new ManualResetEvent(false);
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: SerializationFormat.Json), s =>
{
queue1MessagesThreadIds.Add(Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
if (Interlocked.Increment(ref messagesCounter) == 6)
{
allMessagesAreRecieved.Set();
}
}))
using (engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: SerializationFormat.Json), s =>
{
queue2MessagesThreadIds.Add(Thread.CurrentThread.ManagedThreadId);
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
if (Interlocked.Increment(ref messagesCounter) == 6)
{
allMessagesAreRecieved.Set();
}
}))
{
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: SerializationFormat.Json));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: SerializationFormat.Json));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: SerializationFormat.Json));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: SerializationFormat.Json));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE1, serializationFormat: SerializationFormat.Json));
engine.Send("test", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.QUEUE2, serializationFormat: SerializationFormat.Json));
allMessagesAreRecieved.WaitOne(1000);
}
Assert.That(queue1MessagesThreadIds.Distinct().Any(), Is.True, "Messages were not processed");
Assert.That(queue2MessagesThreadIds.Distinct().Any(), Is.True, "Messages were not processed");
Assert.That(queue1MessagesThreadIds.Distinct().Count(), Is.EqualTo(1), "Messages from one subscription were processed in more then 1 thread");
Assert.That(queue2MessagesThreadIds.Distinct().Count(), Is.EqualTo(1), "Messages from one subscription were processed in more then 1 thread");
Assert.That(queue1MessagesThreadIds.First() != queue2MessagesThreadIds.First(), Is.True, "Messages from different subscriptions were processed one thread");
}
}
public void CommandLoggingInterceptorTest()
{
int commandLoggedCount = 0;
var commandLoggingInterceptor = new CustomCommandLoggingInterceptor(
_logFactory,
new Dictionary <Type, CommandLoggingDelegate>
{
{ typeof(int), (l, h, c) => ++ commandLoggedCount }
});
var commandsHandler = new CommandsHandler();
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null) }
})))
{
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.CommandInterceptors(commandLoggingInterceptor),
Register.BoundedContext("test1")
.ListeningCommands(typeof(int)).On("lykke-wallet-events")
.WithCommandsHandler(commandsHandler)))
{
engine.StartSubscribers();
messagingEngine.Send(1, new Endpoint("InMemory", "lykke-wallet-events", serializationFormat: SerializationFormat.Json));
Thread.Sleep(1000);
Assert.True(commandLoggedCount > 0, "Command was not logged");
Assert.True(commandLoggedCount == 1, "Command was logged more than once");
}
}
}
public void PrioritizedCommandsProcessingTest()
{
var endpointProvider = new Mock <IEndpointProvider>();
endpointProvider.Setup(r => r.Get("exchange1")).Returns(new Endpoint("InMemory", "bc.exchange1", true, SerializationFormat.Json));
endpointProvider.Setup(r => r.Get("exchange2")).Returns(new Endpoint("InMemory", "bc.exchange2", true, SerializationFormat.Json));
using (var messagingEngine = new MessagingEngine(
_logFactory,
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null, "InMemory") }
})))
{
var commandHandler = new CommandHandler(100);
using (var engine = new CqrsEngine(
_logFactory,
messagingEngine,
endpointProvider.Object,
Register.DefaultEndpointResolver(new InMemoryEndpointResolver()),
Register.BoundedContext("bc")
.PublishingEvents(typeof(int)).With("eventExchange").WithLoopback("eventQueue")
.ListeningCommands(typeof(string)).On("commandsRoute")
.Prioritized(lowestPriority: 1)
.WithEndpoint("exchange1").For(key => key.Priority == 1)
.WithEndpoint("exchange2").For(key => key.Priority == 2)
.ProcessingOptions("commandsRoute").MultiThreaded(2)
.WithCommandsHandler(commandHandler)))
{
engine.Start();
messagingEngine.Send("low1", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json));
messagingEngine.Send("low2", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json));
messagingEngine.Send("low3", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json));
messagingEngine.Send("low4", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json));
messagingEngine.Send("low5", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json));
messagingEngine.Send("low6", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json));
messagingEngine.Send("low7", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json));
messagingEngine.Send("low8", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json));
messagingEngine.Send("low9", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json));
messagingEngine.Send("low10", new Endpoint("InMemory", "bc.exchange2", serializationFormat: SerializationFormat.Json));
messagingEngine.Send("high", new Endpoint("InMemory", "bc.exchange1", serializationFormat: SerializationFormat.Json));
Thread.Sleep(2000);
Console.WriteLine(string.Join("\n", commandHandler.AcceptedCommands));
Assert.That(commandHandler.AcceptedCommands.Take(2).Any(c => (string)c == "high"), Is.True);
}
}
}
public void PrioritizedCommandsProcessingTest()
{
using (
var messagingEngine =
new MessagingEngine(
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "InMemory", new TransportInfo("none", "none", "none", null, "InMemory") }
})))
{
var commandHandler = new CommandHandler(100);
using (var engine = new CqrsEngine(messagingEngine,
new InMemoryEndpointResolver(),
LocalBoundedContext.Named("bc").ConcurrencyLevel(1)
.PublishingEvents(typeof(int)).To("eventExchange").RoutedTo("eventQueue")
.ListeningCommands(typeof(string)).On("exchange1", CommandPriority.Low).On("exchange2", CommandPriority.High).RoutedFrom("commandQueue")
.WithCommandsHandler(commandHandler))
)
{
messagingEngine.Send("low1", new Endpoint("InMemory", "bc.exchange1", serializationFormat: "json"));
messagingEngine.Send("low2", new Endpoint("InMemory", "bc.exchange1", serializationFormat: "json"));
messagingEngine.Send("low3", new Endpoint("InMemory", "bc.exchange1", serializationFormat: "json"));
messagingEngine.Send("low4", new Endpoint("InMemory", "bc.exchange1", serializationFormat: "json"));
messagingEngine.Send("low5", new Endpoint("InMemory", "bc.exchange1", serializationFormat: "json"));
messagingEngine.Send("low6", new Endpoint("InMemory", "bc.exchange1", serializationFormat: "json"));
messagingEngine.Send("low7", new Endpoint("InMemory", "bc.exchange1", serializationFormat: "json"));
messagingEngine.Send("low8", new Endpoint("InMemory", "bc.exchange1", serializationFormat: "json"));
messagingEngine.Send("low9", new Endpoint("InMemory", "bc.exchange1", serializationFormat: "json"));
messagingEngine.Send("low10", new Endpoint("InMemory", "bc.exchange1", serializationFormat: "json"));
messagingEngine.Send("high", new Endpoint("InMemory", "bc.exchange2", serializationFormat: "json"));
Thread.Sleep(2000);
Console.WriteLine(string.Join("\n", commandHandler.AcceptedCommands));
Assert.That(commandHandler.AcceptedCommands.Take(2).Any(c => (string)c == "high"), Is.True);
}
}
}
public void SharedDestinationSendSubscribeTest()
{
ITransportResolver resolver = MockTransportResolver();
using (var engine = new MessagingEngine(resolver, new SonicTransportFactory()))
{
engine.SerializationManager.RegisterSerializer("fake", typeof(string), new FakeStringSerializer());
engine.SerializationManager.RegisterSerializer("fake", typeof(int), new FakeIntSerializer());
var recievedNonSharedMessages = new List <string>();
var recievedStrMessages = new List <string>();
var recievedIntMessages = new List <int>();
using (
engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, false, serializationFormat: "fake"), s =>
{
recievedNonSharedMessages.Add(s);
Console.WriteLine("Non-Shared dest subscription #1:" + s);
}))
using (
engine.Subscribe <string>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, true, serializationFormat: "fake"), s =>
{
recievedStrMessages.Add(s);
Console.WriteLine("Subscription #1:" + s);
}))
using (engine.Subscribe <int>(new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, true, serializationFormat: "fake"), i =>
{
recievedIntMessages.Add(i);
Console.WriteLine("Subscription #2:" + i);
}))
{
engine.Send("11", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send("12", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send("13", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send("14", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send("15", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send(21, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send("16", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send(22, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send("23", new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send(24, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send(25, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send(26, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send(27, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
engine.Send(28, new Endpoint(TransportConstants.TRANSPORT_ID1, TransportConstants.TOPIC, serializationFormat: "fake"));
Thread.Sleep(2000);
}
Assert.That(recievedNonSharedMessages.Count, Is.EqualTo(14), "Not all messages from both sequences were received by non-shared subscription ");
Assert.That(recievedStrMessages.Count, Is.EqualTo(7), "Not all messages from first sequence were received by corresponding subscription ");
Assert.That(recievedIntMessages.Count, Is.EqualTo(7), "Not all messages from second sequence were received by corresponding subscription");
}
}
