public void CatEventDoesNotTriggerPersonEvent(string name)
{
// Arrange
using var busContext = new RabbitMqContextBuilder()
.WithExchange("TestExchange")
.WithConnectionString("amqp://*****:*****@localhost")
.CreateContext();
using var host = new MicroserviceHostBuilder()
.WithBusContext(busContext)
.AddEventListener <PersonEventListener>()
.AddEventListener <CatEventListener>()
.CreateHost();
host.Start();
var publisher = new EventPublisher(busContext);
var catEvent = new CatAddedEvent {
Cat = new Cat {
Name = name
}
};
// Act
publisher.Publish(catEvent);
Thread.Sleep(WaitTime);
// Assert
Assert.IsNull(PersonEventListener.ResultEvent);
Assert.AreEqual(catEvent, CatEventListener.ResultEvent);
}
private IBusContext <IConnection> CreateNijnConfig(IServiceCollection serviceCollection)
{
//Deprecated method, maar kan even niet anders
ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(
new ConsoleLoggerProvider(
(text, logLevel) => logLevel >= LogLevel.Debug, true));
var connectionBuilder = new RabbitMQContextBuilder()
.ReadFromEnvironmentVariables();
_context = connectionBuilder.CreateContext();
var builder = new MicroserviceHostBuilder()
.SetLoggerFactory(loggerFactory)
.RegisterDependencies(serviceCollection)
.WithContext(_context)
.UseConventions();
var host = builder.CreateHost();
host.StartListeningInOtherThread();
return(_context);
}
public static void UseMicroserviceHost(this IServiceCollection services)
{
Enum.TryParse(Environment.GetEnvironmentVariable("LOG_LEVEL"), out LogLevel logLevel);
var contextBuilder = new RabbitMqContextBuilder().ReadFromEnvironmentVariables();
var context = Policy.Handle <BrokerUnreachableException>()
.WaitAndRetryForever(sleepDurationProvider => TimeSpan.FromSeconds(5))
.Execute(contextBuilder.CreateContext);
var loggerFactory = LoggerFactory.Create(configure =>
{
configure.AddConsole().SetMinimumLevel(logLevel);
});
var microserviceHost = new MicroserviceHostBuilder()
.SetLoggerFactory(loggerFactory)
.RegisterDependencies(services)
.WithQueueName(Environment.GetEnvironmentVariable("BROKER_QUEUE_NAME"))
.WithBusContext(context)
.UseConventions()
.CreateHost();
services.AddLogging(builder => builder.AddConsole().SetMinimumLevel(logLevel));
services.AddSingleton(context);
services.AddSingleton(microserviceHost);
services.AddHostedService <Miffy>();
}
public static async Task ScrapeAuditLog(IBusContext <IConnection> mainContext, ServiceCollection collection,
DateTime startTime)
{
var exchangeName = "Audit_Bestelling " + Guid.NewGuid();
var connectionBuilder = new RabbitMQContextBuilder()
.ReadFromEnvironmentVariables().WithExchange(exchangeName);
var builder = new MicroserviceHostBuilder();
builder
.RegisterDependencies(collection)
.WithContext(connectionBuilder.CreateContext())
.ExitAfterIdleTime(new TimeSpan(0, 0, 2, 0))
.UseConventions();
builder.CreateHost().StartListeningInOtherThread();
var publisher = new CommandPublisher(mainContext);
var replayEventsCommand = new ReplayEventsCommand
{
ToTimestamp = startTime.Ticks,
ExchangeName = exchangeName
};
var result = await publisher.Publish <bool>(replayEventsCommand, "AuditlogReplayService",
"Minor.WSA.AuditLog.Commands.ReplayEventsCommand");
}
public void Initialize()
{
connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
options = new DbContextOptionsBuilder <KlantContext>()
.UseSqlite(connection)
.Options;
using (var context = new KlantContext(options))
{
context.Database.EnsureCreated();
}
_context = new TestBusContext();
var services = new ServiceCollection();
services.AddTransient <ICommandPublisher, CommandPublisher>();
services.AddSingleton <DbContextOptions>(options);
services.AddSingleton <KlantContext>();
services.AddTransient <IKlantDatamapper, KlantDatamapper>();
services.AddSingleton <IBusContext <IConnection> >(_context);
services.AddTransient <IEventPublisher, EventPublisher>();
var builder = new MicroserviceHostBuilder()
.RegisterDependencies(services)
.WithContext(_context)
.AddCommandListener <KlantListener>();
_host = builder.CreateHost();
_host.StartListening();
Thread.Sleep(1000);
}
public void CommandReturnsProperException(string message)
{
// Arrange
using var busContext = new RabbitMqContextBuilder()
.WithExchange("TestExchange")
.WithConnectionString("amqp://*****:*****@localhost")
.CreateContext();
using var host = new MicroserviceHostBuilder()
.WithBusContext(busContext)
.WithQueueName("QueueName2")
.AddEventListener <ErrorEventListener>()
.CreateHost();
host.Start();
var command = new DummyCommand(message);
var publisher = new CommandPublisher(busContext);
// Act
Task <DummyCommand> Act() => publisher.PublishAsync <DummyCommand>(command);
// Arrange
var exception = Assert.ThrowsExceptionAsync <DestinationQueueException>(Act);
Assert.AreEqual("Received error command from queue Test.Command.Listener", exception.Result.Message);
}
public void EventListenerReceivesMessageAsync(string firstName, string lastName, string email, string phone)
{
// Arrange
using var busContext = new RabbitMqContextBuilder()
.WithExchange("TestExchange")
.WithConnectionString("amqp://*****:*****@localhost")
.CreateContext();
using var host = new MicroserviceHostBuilder()
.WithBusContext(busContext)
.AddEventListener <PersonEventListener>()
.CreateHost();
host.Start();
var publisher = new EventPublisher(busContext);
var personEvent = new PersonAddedEvent {
Person = new Person
{
FirstName = firstName,
LastName = lastName,
Email = email,
PhoneNumber = phone
}
};
// Act
publisher.PublishAsync(personEvent);
Thread.Sleep(WaitTime);
// Assert
Assert.AreEqual(personEvent, PersonEventListener.ResultEvent);
}
public void StringEventListenerReceivesProperString(string text)
{
// Arrange
var testContext = new TestBusContext();
var hostBuilder = new MicroserviceHostBuilder().WithBusContext(testContext);
using var host = hostBuilder
.WithQueueName("test.queue")
.AddEventListener <StringEventListenerDummy>()
.CreateHost();
host.Start();
//Act
var message = new DummyEvent("test.topic")
{
DummyText = text
};
new EventPublisher(testContext).Publish(message);
// Assert
Thread.Sleep(WaitTime);
var expectedResult = JsonConvert.SerializeObject(message);
Assert.AreEqual(expectedResult, StringEventListenerDummy.ReceivedData);
}
public void EventListenerHandlesMultipleEvents(params string[] names)
{
// Arrange
using var busContext = new RabbitMqContextBuilder()
.WithExchange("TestExchange")
.WithConnectionString("amqp://*****:*****@localhost")
.CreateContext();
using var host = new MicroserviceHostBuilder()
.WithBusContext(busContext)
.WithQueueName("QueueName3")
.AddEventListener <SpamEventListener>()
.CreateHost();
host.Start();
var publisher = new EventPublisher(busContext);
var catEvents = names.Select(e => new CatAddedEvent {
Cat = new Cat {
Name = e
}
}).ToList();
// Act
foreach (var @event in catEvents)
{
publisher.Publish(@event);
}
Thread.Sleep(WaitTime);
CollectionAssert.AreEquivalent(catEvents, SpamEventListener.ResultEvents);
}
public void Initialize()
{
connection = new SqliteConnection("DataSource=:memory:");
connection.Open();
options = new DbContextOptionsBuilder <WebshopContext>()
.UseSqlite(connection)
.Options;
using (var context = new WebshopContext(options))
{
context.Database.EnsureCreated();
}
var services = new ServiceCollection();
services.AddSingleton <DbContextOptions>(options);
services.AddTransient <WebshopContext, WebshopContext>();
services.AddTransient <IArtikelDatamapper, ArtikelDatamapper>();
services.AddTransient <IKlantDatamapper, KlantDatamapper>();
_context = new TestBusContext();
var builder = new MicroserviceHostBuilder()
.RegisterDependencies(services)
.WithContext(_context)
.AddEventListener <MagazijnListener>();
_host = builder.CreateHost();
_host.StartListening();
}
private static void ConfigureNijn(IServiceCollection services)
{
ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(
new ConsoleLoggerProvider(
(text, logLevel) => logLevel >= LogLevel.Debug, true));
var connectionBuilder = new RabbitMQContextBuilder()
.ReadFromEnvironmentVariables();
var nijnContext = connectionBuilder.CreateContext();
services.AddTransient <ICommandPublisher, CommandPublisher>();
services.AddTransient <IEventPublisher, EventPublisher>();
var builder = new MicroserviceHostBuilder()
.SetLoggerFactory(loggerFactory)
.RegisterDependencies(services)
.WithContext(nijnContext)
.UseConventions();
var host = builder.CreateHost();
host.CreateQueues();
host.StartListeningInOtherThread();
var logger = NijnLogger.CreateLogger <Program>();
logger.LogInformation("Started...");
}
public void UseConventionsRegistersProperTopics(string messageText)
{
// Arrange
var testContext = new TestBusContext();
var hostBuilder = new MicroserviceHostBuilder().WithBusContext(testContext);
// Act
hostBuilder.UseConventions();
hostBuilder.CreateHost().Start();
// Assert
var message = new DummyEvent("IrrelevantTopic")
{
DummyText = messageText
};
new EventPublisher(testContext).Publish(message);
Thread.Sleep(WaitTime);
Assert.IsNull(EventListenerDummy.HandlesResult);
Assert.IsNull(EventListenerDummy2.HandlesResult);
Assert.AreEqual(message, EventListenerDummy3.HandlesResult);
}
public static int Main(string[] args)
{
var microservice = new MicroserviceHostBuilder("hello")
.UseDefaultWebStack(listenPortNumber: 5000)
.AutoDiscoverComponents()
.Build();
return(microservice.Run(args));
}
public void QueueNameIsAutomaticallySet()
{
// Act
var host = new MicroserviceHostBuilder();
// Assert
Assert.IsNotNull(host.QueueName);
Assert.IsTrue(host.QueueName.StartsWith("unset_queue_name_"));
}
private static void Main(string[] args)
{
var connectionString = Environment.GetEnvironmentVariable("SPRINTERDB");
var options = new DbContextOptionsBuilder <BeheerContext>()
.UseNpgsql(connectionString)
.Options;
ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(
new ConsoleLoggerProvider(
(text, logLevel) => logLevel >= LogLevel.Debug, true));
var connectionBuilder = new RabbitMQContextBuilder()
.ReadFromEnvironmentVariables();
var nijnContext = connectionBuilder.CreateContext();
var services = new ServiceCollection();
services.AddTransient <ICommandPublisher, CommandPublisher>();
services.AddTransient <IEventPublisher, EventPublisher>();
services.AddSingleton <DbContextOptions>(options);
services.AddTransient <BeheerContext, BeheerContext>();
services.AddTransient <IArtikelDatamapper, ArtikelDatamapper>();
services.AddTransient <IBestellingDatamapper, BestellingDatamapper>();
services.AddSingleton <IBusContext <IConnection> >(nijnContext);
services.AddTransient <IKlantDatamapper, KlantDatamapper>();
var builder = new MicroserviceHostBuilder()
.SetLoggerFactory(loggerFactory)
.RegisterDependencies(services)
.WithContext(nijnContext)
.UseConventions();
var host = builder.CreateHost();
host.CreateQueues();
using (var context = new BeheerContext(options))
{
context.Database.EnsureDeleted();
context.Database.EnsureCreated();
if (!context.Artikelen.Any())
{
ScrapeAuditLog(nijnContext, services, DateTime.Now).Wait();
}
}
host.StartListeningInOtherThread();
var logger = NijnLogger.CreateLogger <Program>();
logger.LogInformation("Started...");
}
static void Main(string[] args)
{
ILoggerFactory loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(
new ConsoleLoggerProvider(
(text, logLevel) => logLevel >= LogLevel.Debug, true));
//192.168.99.100
var connectionBuilder = new RabbitMQContextBuilder()
.WithExchange("MVM.EventExchange")
.WithAddress("192.168.99.100", 5672)
.WithCredentials(userName: "******", password: "******");
using (var context = connectionBuilder.CreateContext())
{
var builder = new MicroserviceHostBuilder()
.SetLoggerFactory(loggerFactory)
.RegisterDependencies((services) =>
{
services.AddTransient <IDataMapper, SinaasAppelDataMapper>();
})
.WithContext(context)
.UseConventions();
using (var host = builder.CreateHost())
{
host.StartListening();
Console.WriteLine("ServiceHost is listening to incoming events...");
Console.WriteLine("Press any key to quit.");
var publisher = new EventPublisher(context);
publisher.Publish(new PolisToegevoegdEvent("MVM.Polisbeheer.PolisToegevoegd")
{
Message = "Hey"
});
publisher.Publish(new HenkToegevoegdEvent("Test")
{
Test = "Oi"
});
int i = 0;
while (true)
{
Console.ReadKey();
Test(context, i);
Test(context, i * 100);
i++;
}
}
}
}
public void WithQueueNameSetsQueueProperly(string queueName)
{
// Arrange
var host = new MicroserviceHostBuilder();
// Act
host.WithQueueName(queueName);
// Assert
Assert.AreEqual(queueName, host.QueueName);
}
public void RegisterDependenciesInvokesConfigMethod()
{
// Arrange
var host = new MicroserviceHostBuilder();
bool hasBeenCalled = false;
// Act
host.RegisterDependencies(e => hasBeenCalled = true);
// Assert
Assert.IsTrue(hasBeenCalled);
}
static void Main(string[] args)
{
ILoggerFactory loggerFactory = new LoggerFactory();
//Deprecated method, maar kan even niet anders
ConsoleLoggerOptions options = new ConsoleLoggerOptions();
loggerFactory.AddProvider(
new ConsoleLoggerProvider(
(text, logLevel) => logLevel >= LogLevel.Debug, true));
//192.168.99.100
var connectionBuilder = new RabbitMQContextBuilder()
.WithExchange("MVM.EventExchange")
.WithAddress("localhost", 5672)
.WithCredentials(userName: "******", password: "******");
var context = new TestBusContext();
var builder = new MicroserviceHostBuilder()
.SetLoggerFactory(loggerFactory)
.RegisterDependencies((services) =>
{
services.AddTransient <IDataMapper, SinaasAppelDataMapper>();
services.AddTransient <ICommandPublisher, CommandPublisher>();
services.AddTransient <IEventPublisher, EventPublisher>();
services.AddSingleton <IBusContext <IConnection> >(context);
})
.WithContext(context)
.UseConventions();
var host = builder.CreateHost();
host.StartListeningInOtherThread();
Console.WriteLine("ServiceHost is listening to incoming events...");
Console.WriteLine("Press any key to quit.");
var publisher = new EventPublisher(context);
var commandpublisher = new CommandPublisher(context);
publisher.Publish(new PolisToegevoegdEvent("MVM.Polisbeheer.PolisToegevoegd")
{
Message = "Hey"
});
publisher.Publish(new HenkToegevoegdEvent("Test")
{
Test = "Oi"
});
}
public void EventListenerWithReturnTypeThrowsException()
{
// Arrange
var testContext = new TestBusContext();
var hostBuilder = new MicroserviceHostBuilder().WithBusContext(testContext);
// Act
void Act() => hostBuilder.AddEventListener <EventWithReturnTypeEventListener>();
// Assert
var exception = Assert.ThrowsException <BusConfigurationException>(Act);
Assert.AreEqual("Method Handle does not have a proper " +
"eventlistener signature in type EventWithReturnTypeEventListener", exception.Message);
}
public void CreateHostReturnsHostWithContext()
{
// Arrange
var contextMock = new Mock <IBusContext <IConnection> >();
var context = contextMock.Object;
var builder = new MicroserviceHostBuilder();
builder.WithBusContext(context);
// Act
var host = builder.CreateHost();
// Arrange
Assert.AreSame(context, host.Context);
}
public void RegisterDependenciesRegistersOneExtraDependency()
{
// Arrange
var builder = new MicroserviceHostBuilder();
// Act
builder.RegisterDependencies(e =>
{
e.AddTransient <TestType1>();
});
// Assert
Assert.AreEqual(2, builder.ServiceCollection.Count);
IServiceProvider serviceProvider = builder.ServiceCollection.BuildServiceProvider();
Assert.IsNotNull(serviceProvider.GetService <TestType1>());
}
public static int Main(string[] args)
{
var microservice = new MicroserviceHostBuilder()
.UseInjectionAdapterAutofac()
.UsePlatformMessaging()
.UsePlatformMessagingAdapterKestrel()
.UsePlatformRest()
.ContributeComponents((existingComponents, newComponents) => {
newComponents
.ContributeTransactionScript <HelloWorldTx>();
newComponents
.ContributeHttpEndpoint(name: "rest-api")
.RouteRequestsToRestApiService(protocolName: MessageProtocolInfo.Select.HttpRestNWheelsV1().ProtocolName);
})
.Build();
return(microservice.Run(args));
}
public void EventIsProperlyReceived(string data)
{
// Arrange
AuditLogContext dbContext = new AuditLogContext(_options);
TestBusContext testBusContext = new TestBusContext();
using var hostBuilder = new MicroserviceHostBuilder()
.WithBusContext(testBusContext)
.RegisterDependencies(services =>
{
services.AddSingleton(dbContext);
services.AddTransient <IAuditLogItemRepository, AuditLogItemRepository>();
})
.AddEventListener <IAuditLogItemRepository>()
.AddEventListener <AuditEventLoggingListener>();
using var host = hostBuilder.CreateHost();
host.Start();
DummyEvent evt = new DummyEvent("test.queue")
{
Text = data
};
IEventPublisher eventPublisher = new EventPublisher(testBusContext);
// Act
eventPublisher.Publish(evt);
Thread.Sleep(1500);
// Assert
AuditLogItem[] resultData = dbContext.AuditLogItems.ToArray();
Assert.AreEqual(1, resultData.Length);
string expectedData = JsonConvert.SerializeObject(evt);
var firstItem = resultData.First();
Assert.AreEqual(expectedData, firstItem.Data);
Assert.AreEqual(evt.Id.ToString(), firstItem.Id);
Assert.AreEqual(new DateTime(evt.Timestamp).ToFileTimeUtc(), firstItem.TimeStamp);
}
public void RegisterDependenciesAddsToExistingServiceCollection()
{
// Arrange
var builder = new MicroserviceHostBuilder();
ServiceCollection serviceCollection = new ServiceCollection();
serviceCollection.AddTransient <TestType1>();
// Act
builder.RegisterDependencies(services => { services.AddTransient <TestType2>(); });
builder.RegisterDependencies(serviceCollection);
// Assert
IServiceProvider serviceProvider = builder.ServiceCollection.BuildServiceProvider();
Assert.IsNotNull(serviceProvider.GetService <TestType1>());
Assert.IsNotNull(serviceProvider.GetService <TestType2>());
}
public void AddingListenerOnlyAddsRelevantMethod()
{
// Arrange
var testContext = new TestBusContext();
var builder = new MicroserviceHostBuilder().WithBusContext(testContext)
.WithQueueName("test.queue")
.AddEventListener <MethodEventListener>();
// Act
using var host = builder.CreateHost();
var result = host.Listeners.ToList();
// Assert
Assert.AreEqual(1, result.Count);
var firstItem = result.FirstOrDefault();
Assert.AreEqual("testPattern", firstItem?.TopicExpressions.FirstOrDefault());
}
public void UseApplicationFeature_DefaultFeature_ModuleMissing_OnlyModuleAdded()
{
//-- arrange
var microservice = new MicroserviceHostBuilder("test");
//-- act
microservice.UseApplicationFeature <DefaultFeatureLoader>();
//-- assert
microservice.BootConfig.MicroserviceConfig.ApplicationModules.Length.Should().Be(1);
var module = microservice.BootConfig.MicroserviceConfig.ApplicationModules[0];
module.Assembly.Should().Be(this.GetType().GetTypeInfo().Assembly.GetName().Name);
module.Features.Length.Should().Be(0);
}
static void Main(string[] args)
{
using ILoggerFactory loggerFactory = LoggerFactory.Create(configure =>
{
string logLevelString = Environment.GetEnvironmentVariable(EnvVarNames.LogLevel) ?? "Information";
LogLevel logLevel = Enum.Parse <LogLevel>(logLevelString);
configure.AddConsole().SetMinimumLevel(logLevel);
});
MiffyLoggerFactory.LoggerFactory = loggerFactory;
RabbitMqLoggerFactory.LoggerFactory = loggerFactory;
using IBusContext <IConnection> context = new RabbitMqContextBuilder()
.ReadFromEnvironmentVariables()
.CreateContext();
using IMicroserviceHost host = new MicroserviceHostBuilder()
.SetLoggerFactory(loggerFactory)
.WithBusContext(context)
.RegisterDependencies(services =>
{
services.AddDbContext <AuditLogContext>(config =>
{
config.UseMySql(Environment.GetEnvironmentVariable(EnvVarNames.DatabaseConnectionString));
config.UseLoggerFactory(loggerFactory);
}, ServiceLifetime.Singleton);
services.AddTransient <IAuditLogItemRepository, AuditLogItemRepository>();
services.AddTransient <IEventPublisher, EventPublisher>();
using var serviceScope = services.BuildServiceProvider().GetRequiredService <IServiceScopeFactory>().CreateScope();
var auditLogContext = serviceScope.ServiceProvider.GetService <AuditLogContext>();
auditLogContext.Database.Migrate();
})
.UseConventions()
.CreateHost();
host.Start();
// Keep app running
new ManualResetEvent(false).WaitOne();
}
public void UseConventionsRegistersProperCommandListeners()
{
// Arrange
var testContext = new TestBusContext();
var hostBuilder = new MicroserviceHostBuilder()
.WithBusContext(testContext);
// Act
hostBuilder.UseConventions();
hostBuilder.CreateHost().Start();
// Assert
var message = new GetAnimalsCommand();
ICommandPublisher publisher = new CommandPublisher(testContext);
Animal[] animals = publisher.PublishAsync <IEnumerable <Animal> >(message).Result.ToArray();
Assert.AreEqual(2, animals.Length);
}
public void AddingListenerRegistersProperCommandReceiver()
{
// Arrange
TestBusContext testContext = new TestBusContext();
MicroserviceHostBuilder hostBuilder = new MicroserviceHostBuilder()
.WithQueueName("test.queue")
.WithBusContext(testContext);
// Act
hostBuilder.AddEventListener <CommandListenerDummy>();
List <MicroserviceCommandListener> result = hostBuilder.CreateHost().CommandListeners.ToList();
// Assert
Assert.AreEqual(1, result.Count);
var firstItem = result.FirstOrDefault();
Assert.AreEqual("command.queue", firstItem?.Queue);
}
