public void MultipleInitializationsRaceConditionTest()
{
var transportResolver = new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "tr1", new TransportInfo("host", "guest", "guest", null, "InMemory") },
{ "tr2", new TransportInfo("host", "guest", "guest", null, "InMemory") }
});
var messagingEngine = new MessagingEngine(transportResolver, new ITransportFactory[] { new InMemoryTransportFactory() });
messagingEngine.SerializationManager.RegisterSerializer("txt", typeof(string), new FakeStringSerializer());
var fp1 = new FeedProvider1(messagingEngine);
var consoleLogger = new ConsoleLogger();
fp1.Logger = consoleLogger;
var fp2 = new FeedProvider2(messagingEngine);
fp2.Logger = consoleLogger;
var databus = new DataBus();
databus.RegisterFeedProvider("FP1", fp1);
databus.RegisterFeedProvider("FP2", fp2);
var disposable1 = databus.Channel <string>("FP1").Feed("context1").Subscribe(Console.WriteLine);
var disposable2 = databus.Channel <string>("FP2").Feed("context2").Subscribe(Console.WriteLine);
Thread.Sleep(10000);
disposable1.Dispose();
disposable2.Dispose();
}
public void CqrsEngineTest()
{
var serializationManager = new SerializationManager();
serializationManager.RegisterSerializerFactory(new JsonSerializerFactory());
var transportResolver =
new TransportResolver(new Dictionary <string, TransportInfo>
{
{ "test", new TransportInfo("localhost", "guest", "guest", null, "RabbitMq") }
});
var messagingEngine = new MessagingEngine(transportResolver, new RabbitMqTransportFactory());
using (messagingEngine)
{
var cqrsEngine = new CqrsEngine(messagingEngine, new FakeEndpointResolver(),
LocalBoundedContext.Named("integration")
.PublishingEvents(typeof(int)).To("eventExchange").RoutedTo("eventQueue")
.ListeningCommands(typeof(string)).On("commandExchange").RoutedFrom("commandQueue")
.WithCommandsHandler <CommandsHandler>(),
LocalBoundedContext.Named("bc").WithProjection <EventListener>("integration")
);
/* var cqrsEngine = new CqrsEngine(messagingEngine, new RabbitMqConventionEndpointResolver("test","json",new EndpointResolver(new Dictionary<string, Endpoint>())),
* LocalBoundedContext.Named("integration")
* .PublishingEvents(typeof (int)).To("events").RoutedToSameEndpoint()
* .ListeningCommands(typeof (string)).On("commands").RoutedFromSameEndpoint()
* .WithCommandsHandler<CommandsHandler>(),
* LocalBoundedContext.Named("bc").WithProjection<EventListener>("integration")
* );*/
/* var c=new commandSender(messagingEngine, RemoteBoundedContext.Named("integration")
* .ListeningCommands(typeof(TestCommand)).On(new Endpoint())
* .PublishingEvents(typeof(TransferCreatedEvent)).To(new Endpoint()),
* LocalBoundedContext.Named("testBC")
* .ListeningCommands(typeof(TestCommand)).On(new Endpoint("test", "unistream.u1.commands", true))
* .ListeningCommands(typeof(int)).On(new Endpoint("test", "unistream.u1.commands", true))
* .PublishingEvents(typeof (int)).To(new Endpoint()).RoutedTo(new Endpoint())
* .PublishingEvents(typeof (string)).To(new Endpoint())
* .WithEventStore(dispatchCommits => Wireup.Init()
* .LogToOutputWindow()
* .UsingInMemoryPersistence()
* .InitializeStorageEngine()
* .UsingJsonSerialization()
* .UsingSynchronousDispatchScheduler()
* .DispatchTo(dispatchCommits))
* ); */
// messagingEngine.Send("test", new Endpoint("test", "unistream.u1.commands", true,"json"));
cqrsEngine.SendCommand("test", "integration");
Thread.Sleep(3000);
}
}
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 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);
}
