public void SubscribeDynamic(
[Frozen] Mock <IRabbitMQPersistentConnection> mockConnection,
[Frozen] Mock <IModel> mockChannel,
[Greedy] EventBusRabbitMQ sut,
Mock <QueueDeclareOk> mockQueueDeclareOk
)
{
//Arrange
mockChannel.Setup(_ => _.QueueDeclare(
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <IDictionary <string, object> >()
))
.Returns(mockQueueDeclareOk.Object);
mockConnection.Setup(_ => _.CreateModel())
.Returns(mockChannel.Object);
//Act
sut.SubscribeDynamic <TestDynamicIntegrationEventHandler>("eventName");
//Assert
mockChannel.Verify(_ => _.QueueBind(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <IDictionary <string, object> >()
));
}
public void Dispose_ConsumerChannelIsNotNull_DisposeConsumerChannel(
[Frozen] Mock <IRabbitMQPersistentConnection> mockConnection,
[Frozen] Mock <IModel> mockChannel,
[Frozen] Mock <IEventBusSubscriptionsManager> mockSubsManager,
[Greedy] EventBusRabbitMQ sut,
Mock <QueueDeclareOk> mockQueueDeclareOk
)
{
//Arrange
mockChannel.Setup(_ => _.QueueDeclare(
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <IDictionary <string, object> >()
))
.Returns(mockQueueDeclareOk.Object);
mockConnection.Setup(_ => _.CreateModel())
.Returns(mockChannel.Object);
//Act
sut.Subscribe <TestIntegrationEvent, TestIntegrationEventHandler>();
sut.Dispose();
//Assert
mockChannel.Verify(_ => _.Dispose());
mockSubsManager.Verify(
_ => _.Clear()
);
}
protected void Application_Start()
{
GlobalConfiguration.Configure(WebApiConfig.Register);
var loggerFactory = (ILoggerFactory) new LoggerFactory();
var loggerConnection = loggerFactory.CreateLogger <DefaultRabbitMQPersistentConnection>();
var factory = new ConnectionFactory()
{
HostName = "localhost",
DispatchConsumersAsync = true,
UserName = "******",
Password = "******"
};
DefaultRabbitMQPersistentConnection rabbitmqConnection = new DefaultRabbitMQPersistentConnection(factory, loggerConnection, 5);
if (!rabbitmqConnection.IsConnected)
{
rabbitmqConnection.TryConnect();
}
var logger = loggerFactory.CreateLogger <EventBusRabbitMQ>();
//DI
var builder = new ContainerBuilder();
builder.RegisterType <DispatchAcceptEventHandler>().InstancePerLifetimeScope();
var eventBus = new EventBusRabbitMQ(rabbitmqConnection, logger, builder.Build(), 5);
//Subscribes
eventBus.Subscribe <DispatchAcceptEvent, DispatchAcceptEventHandler>();
}
public NewsController(NewsContext context, IMapper mapper, EventBusRabbitMQ eventBusRabbitMQ)
{
_context = context;
_mapper = mapper;
_eventBus = eventBusRabbitMQ;
}
public void DeveTestar()
{
//Given
var settings = new RabbitMQSettings
{
HostName = "localhost",
Port = 5672,
UserName = "******",
Password = "******"
};
var logger = new XunitLogger <EventBusRabbitMQ>();
var loggerFactoryMock = new Mock <ILoggerFactory>();
loggerFactoryMock.Setup(setup => setup.CreateLogger(It.IsAny <string>())).Returns(logger);
var rabbitMQConnectionMock = new Mock <RabbitMQConnection>(loggerFactoryMock.Object, settings);
var eventBusRabbitMQ = new EventBusRabbitMQ(loggerFactoryMock.Object, rabbitMQConnectionMock.Object);
var teste = new Teste
{
Nome = Guid.NewGuid().ToString()
};
//When
eventBusRabbitMQ.Subscribe <Teste>(received: EventBusRabbitMQ_OnReceivedMessage);
eventBusRabbitMQ.Publish(teste);
//Then
logger.Logs.Should().NotBeEmpty();
}
public static void AgregarSubscripcionHaciaMicroServicio()
{
var eventbus = new EventBusRabbitMQ("");
//eventbus.Subscribe<ProductPriceChangedIntegrationEvent,
// ProductPriceChangedIntegrationEventHandler>();
//eventbus.Subscribe<OrderStartedIntegrationEvent,
// OrderStartedIntegrationEventHandler>();
}
public void Dispose_ConsumerChannelIsNull_ClearSubscription(
[Frozen] Mock <IEventBusSubscriptionsManager> mockSubsManager,
[Greedy] EventBusRabbitMQ sut
)
{
//Arrange
//Act
sut.Dispose();
//Assert
mockSubsManager.Verify(
_ => _.Clear()
);
}
public void UnsubscribeDynamic(
[Frozen] Mock <IEventBusSubscriptionsManager> mockSubsManager,
[Greedy] EventBusRabbitMQ sut
)
{
//Arrange
//Act
sut.UnsubscribeDynamic <TestDynamicIntegrationEventHandler>("eventName");
//Assert
mockSubsManager.Verify(
_ => _.RemoveDynamicSubscription <TestDynamicIntegrationEventHandler>(
It.IsAny <string>()
)
);
}
public static MicroserviceFrameworkBuilder UseEventBusRabbitMQ(this MicroserviceFrameworkBuilder builder,
IConfiguration configuration)
{
builder.RegisterEventHandlers();
builder.Services.Configure <RabbitMQOptions>(configuration.GetSection("RabbitMQ"));
builder.Services.AddSingleton <PersistentConnection>();
builder.Services.AddSingleton <IEventExecutor, DefaultEventExecutor>();
builder.Services.AddSingleton <IConnectionFactory>(provider =>
{
var opts = provider.GetRequiredService <IOptionsMonitor <RabbitMQOptions> >().CurrentValue;
var connectionFactory = new ConnectionFactory
{
HostName = opts.HostName,
DispatchConsumersAsync = true
};
if (opts.Port > 0)
{
connectionFactory.Port = opts.Port;
}
if (!string.IsNullOrWhiteSpace(opts.UserName))
{
connectionFactory.UserName = opts.UserName;
}
if (!string.IsNullOrWhiteSpace(opts.Password))
{
connectionFactory.Password = opts.Password;
}
return(connectionFactory);
});
builder.Services.AddSingleton <IEventBus>((services) =>
{
var connection = services.GetRequiredService <PersistentConnection>();
var eventExecutor = services.GetRequiredService <IEventExecutor>();
var logger = services.GetRequiredService <ILogger <EventBusRabbitMQ> >();
var eventBus = new EventBusRabbitMQ(services.GetRequiredService <IOptionsMonitor <RabbitMQOptions> >(),
connection, eventExecutor, logger);
eventBus.SubscribeAllEventTypes();
return(eventBus);
});
return(builder);
}
public void Unsubscribe(
[Frozen] Mock <IEventBusSubscriptionsManager> mockSubsManager,
[Greedy] EventBusRabbitMQ sut
)
{
//Arrange
//Act
sut.Unsubscribe <TestIntegrationEvent, TestIntegrationEventHandler>();
//Assert
mockSubsManager.Verify(
_ => _.GetEventKey <TestIntegrationEvent>()
);
mockSubsManager.Verify(
_ => _.RemoveSubscription <TestIntegrationEvent, TestIntegrationEventHandler>()
);
}
private void InitializeModule(ILifetimeScope autofacContainer)
{
var emailsConfiguration = new EmailsConfiguration(Configuration["EmailsConfiguration:FromEmail"], Configuration["EmailsConfiguration:SendGridUser"], Configuration["EmailsConfiguration:SendGridKey"]);
var httpContextAccessor = autofacContainer.Resolve <IHttpContextAccessor>();
var executionContextAccessor = new ExecutionContextAccessor(httpContextAccessor);
var eventBus = new EventBusRabbitMQ(_logger, GetRabbitMQConnection(), "football-banter", "Phrases");
PhrasesStartup.Initialize(
Configuration["ConnectionString"],
executionContextAccessor,
_logger,
emailsConfiguration,
Configuration["Security:TextEncryptionKey"],
null,
eventBus
);
}
public void SubscribeDynamic_SecondTime(
[Frozen] Mock <IRabbitMQPersistentConnection> mockConnection,
[Frozen] Mock <IModel> mockChannel,
[Frozen] Mock <IEventBusSubscriptionsManager> mockSubsManager,
[Greedy] EventBusRabbitMQ sut,
Mock <QueueDeclareOk> mockQueueDeclareOk
)
{
//Arrange
mockChannel.Setup(_ => _.QueueDeclare(
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <IDictionary <string, object> >()
))
.Returns(mockQueueDeclareOk.Object);
mockConnection.Setup(_ => _.CreateModel())
.Returns(mockChannel.Object);
mockSubsManager.SetupSequence(_ => _.HasSubscriptionsForEvent(
It.IsAny <string>())
)
.Returns(false)
.Returns(true);
//Act
sut.SubscribeDynamic <TestDynamicIntegrationEventHandler>("eventName");
sut.SubscribeDynamic <TestDynamicIntegrationEventHandler>("eventName");
//Assert
mockChannel.Verify(_ => _.QueueBind(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <IDictionary <string, object> >()
), Times.Once);
}
public void Publish(
[Frozen] Mock <IRabbitMQPersistentConnection> mockConnection,
[Frozen] Mock <IModel> mockChannel,
[Greedy] EventBusRabbitMQ sut,
TestIntegrationEvent integrationEvent
)
{
//Arrange
mockConnection.Setup(_ => _.CreateModel())
.Returns(mockChannel.Object);
//Act
sut.Publish(integrationEvent);
//Assert
mockChannel.Verify(_ => _.BasicPublish(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <bool>(),
It.IsAny <IBasicProperties>(),
It.IsAny <ReadOnlyMemory <byte> >()
));
}
