public async Task CanRunBadWorkItem()
{
using (var queue = new InMemoryQueue <WorkItemData>(o => o.RetryDelay(TimeSpan.FromMilliseconds(500)).LoggerFactory(Log))) {
using (var messageBus = new InMemoryMessageBus(o => o.LoggerFactory(Log))) {
var handlerRegistry = new WorkItemHandlers();
var job = new WorkItemJob(queue, messageBus, handlerRegistry, Log);
handlerRegistry.Register <MyWorkItem>(ctx => {
var jobData = ctx.GetData <MyWorkItem>();
Assert.Equal("Test", jobData.SomeData);
throw new Exception();
});
string jobId = await queue.EnqueueAsync(new MyWorkItem {
SomeData = "Test"
}, true);
var countdown = new AsyncCountdownEvent(1);
await messageBus.SubscribeAsync <WorkItemStatus>(status => {
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace("Progress: {Progress}", status.Progress);
}
Assert.Equal(jobId, status.WorkItemId);
countdown.Signal();
});
await job.RunUntilEmptyAsync();
await countdown.WaitAsync(TimeSpan.FromSeconds(2));
Assert.Equal(0, countdown.CurrentCount);
}
}
}
public void CanSendMessageToMultipleSubscribers()
{
var latch = new CountDownLatch(3);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void CanRunWorkItemWithClassHandler()
{
ServiceProvider.SetServiceProvider(typeof(MyBootstrappedServiceProvider));
var queue = new InMemoryQueue <WorkItemData>();
var messageBus = new InMemoryMessageBus();
var handlerRegistry = new WorkItemHandlers();
var job = new WorkItemJob(queue, messageBus, handlerRegistry);
handlerRegistry.Register <MyWorkItem, MyWorkItemHandler>();
var jobId = queue.Enqueue(new MyWorkItem {
SomeData = "Test"
}, true);
int statusCount = 0;
messageBus.Subscribe <WorkItemStatus>(status => {
Assert.Equal(jobId, status.WorkItemId);
statusCount++;
});
job.RunUntilEmpty();
Assert.Equal(12, statusCount);
}
public async Task CanRunWorkItemWithClassHandler()
{
using (var queue = new InMemoryQueue <WorkItemData>(new InMemoryQueueOptions <WorkItemData> {
LoggerFactory = Log
})) {
using (var messageBus = new InMemoryMessageBus(new InMemoryMessageBusOptions {
LoggerFactory = Log
})) {
var handlerRegistry = new WorkItemHandlers();
var job = new WorkItemJob(queue, messageBus, handlerRegistry, Log);
handlerRegistry.Register <MyWorkItem>(new MyWorkItemHandler(Log));
string jobId = await queue.EnqueueAsync(new MyWorkItem {
SomeData = "Test"
}, true);
int statusCount = 0;
await messageBus.SubscribeAsync <WorkItemStatus>(status => {
_logger.Trace("Progress: {progress}", status.Progress);
Assert.Equal(jobId, status.WorkItemId);
statusCount++;
});
await job.RunUntilEmptyAsync();
Assert.Equal(11, statusCount);
}
}
}
public async Task CanRunWorkItem()
{
using (var queue = new InMemoryQueue <WorkItemData>()) {
using (var messageBus = new InMemoryMessageBus()) {
var handlerRegistry = new WorkItemHandlers();
var job = new WorkItemJob(queue, messageBus, handlerRegistry, Log);
handlerRegistry.Register <MyWorkItem>(async ctx => {
var jobData = ctx.GetData <MyWorkItem>();
Assert.Equal("Test", jobData.SomeData);
for (int i = 0; i < 10; i++)
{
await SystemClock.SleepAsync(100);
await ctx.ReportProgressAsync(10 * i);
}
});
var jobId = await queue.EnqueueAsync(new MyWorkItem {
SomeData = "Test"
}, true);
int statusCount = 0;
messageBus.Subscribe <WorkItemStatus>(status => {
_logger.Trace("Progress: {progress}", status.Progress);
Assert.Equal(jobId, status.WorkItemId);
statusCount++;
});
await job.RunUntilEmptyAsync();
Assert.Equal(12, statusCount);
}
}
}
public override async Task InitializeAsync()
{
await base.InitializeAsync();
_migrationIndex = new MigrationIndex(_configuration);
await _migrationIndex.DeleteAsync();
await _migrationIndex.ConfigureAsync();
var cacheClient = new InMemoryCacheClient();
var messageBus = new InMemoryMessageBus();
_lockProvider = new CacheLockProvider(cacheClient, messageBus, Log);
_migrationStateRepository = new MigrationStateRepository(_migrationIndex);
var serviceCollection = new ServiceCollection();
serviceCollection.AddSingleton <VersionedWithoutVersionMigration>();
serviceCollection.AddSingleton <Version1Migration>();
serviceCollection.AddSingleton <Version2Migration>();
serviceCollection.AddSingleton <Version3Migration>();
serviceCollection.AddSingleton <FailingMigration>();
serviceCollection.AddSingleton <FailingResumableMigration>();
serviceCollection.AddSingleton <RepeatableMigration>();
_serviceProvider = serviceCollection.BuildServiceProvider();
_migrationManager = new MigrationManager(_serviceProvider, _migrationStateRepository, _lockProvider, Log);
}
public async Task CanRunWorkItemJobUntilEmpty()
{
using (var queue = new InMemoryQueue <WorkItemData>(new InMemoryQueueOptions <WorkItemData> {
LoggerFactory = Log
})) {
using (var messageBus = new InMemoryMessageBus(new InMemoryMessageBusOptions {
LoggerFactory = Log
})) {
var handlerRegistry = new WorkItemHandlers();
var job = new WorkItemJob(queue, messageBus, handlerRegistry, Log);
handlerRegistry.Register <MyWorkItem>(new MyWorkItemHandler(Log));
await queue.EnqueueAsync(new MyWorkItem {
SomeData = "Test"
}, true);
await queue.EnqueueAsync(new MyWorkItem {
SomeData = "Test"
}, true);
await job.RunUntilEmptyAsync();
var stats = await queue.GetQueueStatsAsync();
Assert.Equal(2, stats.Enqueued);
Assert.Equal(2, stats.Dequeued);
Assert.Equal(2, stats.Completed);
}
}
}
public async Task CanRunBadWorkItem()
{
using (var queue = new InMemoryQueue <WorkItemData>(new InMemoryQueueOptions <WorkItemData> {
RetryDelay = TimeSpan.FromMilliseconds(500), LoggerFactory = Log
})) {
using (var messageBus = new InMemoryMessageBus(new InMemoryMessageBusOptions {
LoggerFactory = Log
})) {
var handlerRegistry = new WorkItemHandlers();
var job = new WorkItemJob(queue, messageBus, handlerRegistry, Log);
handlerRegistry.Register <MyWorkItem>(ctx => {
var jobData = ctx.GetData <MyWorkItem>();
Assert.Equal("Test", jobData.SomeData);
throw new Exception();
});
string jobId = await queue.EnqueueAsync(new MyWorkItem {
SomeData = "Test"
}, true);
int statusCount = 0;
await messageBus.SubscribeAsync <WorkItemStatus>(status => {
_logger.Trace("Progress: {progress}", status.Progress);
Assert.Equal(jobId, status.WorkItemId);
statusCount++;
});
await job.RunUntilEmptyAsync();
Assert.Equal(1, statusCount);
}
}
}
public async Task CanRunWorkItemWithClassHandler()
{
ServiceProvider.SetServiceProvider(typeof(MyBootstrappedServiceProvider));
var queue = new InMemoryQueue <WorkItemData>();
var messageBus = new InMemoryMessageBus();
var handlerRegistry = new WorkItemHandlers();
var job = new WorkItemJob(queue, messageBus, handlerRegistry, Log);
handlerRegistry.Register <MyWorkItem, MyWorkItemHandler>();
var jobId = await queue.EnqueueAsync(new MyWorkItem {
SomeData = "Test"
}, true);
int statusCount = 0;
messageBus.Subscribe <WorkItemStatus>(status => {
_logger.Trace("Progress: {progress}", status.Progress);
Assert.Equal(jobId, status.WorkItemId);
statusCount++;
});
await job.RunUntilEmptyAsync();
Assert.Equal(11, statusCount);
}
public async Task CanRunBadWorkItem()
{
var queue = new InMemoryQueue <WorkItemData>(retries: 2, retryDelay: TimeSpan.FromMilliseconds(500));
var messageBus = new InMemoryMessageBus();
var handlerRegistry = new WorkItemHandlers();
var job = new WorkItemJob(queue, messageBus, handlerRegistry);
handlerRegistry.Register <MyWorkItem>(ctx => {
var jobData = ctx.GetData <MyWorkItem>();
Assert.Equal("Test", jobData.SomeData);
throw new ApplicationException();
});
var jobId = await queue.EnqueueAsync(new MyWorkItem {
SomeData = "Test"
}, true);
int statusCount = 0;
messageBus.Subscribe <WorkItemStatus>(status => {
Logger.Trace().Message($"Progress: {status.Progress}").Write();
Assert.Equal(jobId, status.WorkItemId);
statusCount++;
});
await job.RunUntilEmptyAsync();
Assert.Equal(1, statusCount);
}
public void CanRunWorkItem()
{
var queue = new InMemoryQueue <WorkItemData>();
var messageBus = new InMemoryMessageBus();
var handlerRegistry = new WorkItemHandlers();
var job = new WorkItemJob(queue, messageBus, handlerRegistry);
handlerRegistry.Register <MyWorkItem>(async ctx => {
var jobData = ctx.GetData <MyWorkItem>();
Assert.Equal("Test", jobData.SomeData);
for (int i = 0; i < 10; i++)
{
Thread.Sleep(100);
ctx.ReportProgress(10 * i);
}
});
var jobId = queue.Enqueue(new MyWorkItem {
SomeData = "Test"
}, true);
int statusCount = 0;
messageBus.Subscribe <WorkItemStatus>(status => {
Assert.Equal(jobId, status.WorkItemId);
statusCount++;
});
job.RunUntilEmpty();
Assert.Equal(12, statusCount);
}
public virtual async Task CanHaveMultipleQueueInstancesWithLockingAsync()
{
using (var cache = new InMemoryCacheClient(Log)) {
using (var messageBus = new InMemoryMessageBus(Log)) {
var distributedLock = new CacheLockProvider(cache, messageBus, Log);
await CanHaveMultipleQueueInstancesWithLockingImplAsync(distributedLock);
}
}
}
private static async void MessageBusTest()
{
IMessageBus messageBus = new InMemoryMessageBus();
messageBus.SubscribeAsync <SimpleMessageA>(msg =>
{
Console.WriteLine(msg.Data);
});
await messageBus.PublishAsync(new SimpleMessageA { Data = "hello" });
}
public void TestMethod1()
{
var bus = new InMemoryMessageBus();
var lHandler = new CreateCommandHandlers();
CreateCommand lCommand = new CreateCommand(Guid.NewGuid());
bus.RegisterHandler<CreateCommand>(lHandler.Handle);
bus.Send(lCommand);
Assert.IsTrue(lHandler.HandledIds.Contains(lCommand.Id));
}
public void TestMethod1()
{
var bus = new InMemoryMessageBus();
var lHandler = new CreateCommandHandlers();
CreateCommand lCommand = new CreateCommand(Guid.NewGuid());
bus.RegisterHandler <CreateCommand>(lHandler.Handle);
bus.Send(lCommand);
Assert.IsTrue(lHandler.HandledIds.Contains(lCommand.Id));
}
public InMemoryMessageBusTests()
{
m_MockStore = new Mock <ISubscriberStore>();
m_MockAggregator = new Mock <IMessageAggregator>();
m_Sut = new InMemoryMessageBus(m_MockStore.Object,
m_MockAggregator.Object);
m_Message = new TestMessage();
m_Handler = new TestHandler(m_Sut);
}
public async Task CanCheckMessageCounts()
{
var messageBus = new InMemoryMessageBus(o => o.LoggerFactory(Log));
await messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
Assert.Equal(1, messageBus.MessagesSent);
Assert.Equal(1, messageBus.GetMessagesSent <SimpleMessageA>());
Assert.Equal(0, messageBus.GetMessagesSent <SimpleMessageB>());
}
public ElasticRepositoryTestBase(ITestOutputHelper output) : base(output)
{
SystemClock.Reset();
Log.MinimumLevel = LogLevel.Trace;
Log.SetLogLevel <ScheduledTimer>(LogLevel.Warning);
_cache = new InMemoryCacheClient(Log);
_messgeBus = new InMemoryMessageBus(Log);
_workItemQueue = new InMemoryQueue <WorkItemData>(loggerFactory: Log);
_configuration = new MyAppElasticConfiguration(_workItemQueue, _cache, _messgeBus, Log);
_client = _configuration.Client;
}
public void Registered_handlers_recieve_raised_events()
{
var bus = new InMemoryMessageBus();
var eventHandler = Substitute.For <IEventListener>();
var fakeEvent = new FakeEvent();
bus.RegisterEventHandler(eventHandler);
bus.RaiseEvent <FakeEvent>(fakeEvent);
eventHandler.Received().Handle(fakeEvent);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var dataBaseRoot = new InMemoryDatabaseRoot();
services.AddDbContext <ApiContext>(opt => opt.UseInMemoryDatabase("BooksDb"));
services.AddDbContext <OrderContext>(opt => opt.UseInMemoryDatabase("OrdersDb"));
services.AddDbContext <ShippingContext>(opt => opt.UseInMemoryDatabase("ShippingDb", dataBaseRoot));
services.AddTransient <PurchaseOrderReceivedHandler>();
var sp = services.BuildServiceProvider();
var bus = new InMemoryMessageBus();
var optionsBuilder = new DbContextOptionsBuilder <ShippingContext>();
optionsBuilder.UseInMemoryDatabase("ShippingDb", dataBaseRoot);
var context = new ShippingContext(optionsBuilder.Options);
var shippingOrderHandler = new PurchaseOrderReceivedHandler(bus, context);
bus.RegisterHandler <PurchaseOrderReceived>(e => shippingOrderHandler.Handle(e));
services.AddSingleton <InMemoryMessageBus>(bus);
// services.AddAuthentication(options =>
// {
// options.DefaultScheme = JwtBearerDefaults.AuthenticationScheme;
// })
// .AddJwtBearer(jwtOptions =>
// {
// jwtOptions.Authority = $"https://login.microsoftonline.com/tfp/{Configuration["AzureAdB2C:Tenant"]}/{Configuration["AzureAdB2C:Policy"]}/v2.0/";
// jwtOptions.Audience = Configuration["AzureAdB2C:ClientId"];
// jwtOptions.Events = new JwtBearerEvents
// {
// OnAuthenticationFailed = AuthenticationFailed
// };
// });
services.AddAzureAdB2CAuthentication();
services.AddMvc(setupAction => {
var inputFormatter = setupAction.InputFormatters.OfType <JsonInputFormatter>().FirstOrDefault();
if (inputFormatter != null)
{
inputFormatter.SupportedMediaTypes.Add("application/json-patch+json");
}
});
services.AddSwaggerGen(c =>
{
c.SwaggerDoc("v1", new Info {
Title = "Books Store", Version = "v1"
});
});
}
public virtual async Task CanDequeueWithLockingAsync()
{
using (var cache = new InMemoryCacheClient(new InMemoryCacheClientOptions {
LoggerFactory = Log
})) {
using (var messageBus = new InMemoryMessageBus(new InMemoryMessageBusOptions {
LoggerFactory = Log
})) {
var distributedLock = new CacheLockProvider(cache, messageBus, Log);
await CanDequeueWithLockingImpAsync(distributedLock);
}
}
}
public void CanSendMessage() {
var resetEvent = new AutoResetEvent(false);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
resetEvent.Set();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
bool success = resetEvent.WaitOne(100);
Assert.True(success, "Failed to receive message.");
}
public void CanSendMessage()
{
var resetEvent = new AutoResetEvent(false);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
resetEvent.Set();
});
messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
bool success = resetEvent.WaitOne(100);
Assert.True(success, "Failed to receive message.");
}
public void WillOnlyReceiveSubscribedMessageType() {
var resetEvent = new AutoResetEvent(false);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<SimpleMessageB>(msg => {
Assert.True(false, "Received wrong message type.");
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
resetEvent.Set();
});
messageBus.Publish(new SimpleMessageA {
Data = "Hello"
});
bool success = resetEvent.WaitOne(100);
Assert.True(success, "Failed to receive message.");
}
public ElasticRepositoryTestBase(ITestOutputHelper output) : base(output)
{
Log.MinimumLevel = LogLevel.Information;
Log.SetLogLevel <ScheduledTimer>(LogLevel.Warning);
_cache = new InMemoryCacheClient(new InMemoryCacheClientOptions {
LoggerFactory = Log
});
_messageBus = new InMemoryMessageBus(new InMemoryMessageBusOptions {
LoggerFactory = Log
});
_workItemQueue = new InMemoryQueue <WorkItemData>(new InMemoryQueueOptions <WorkItemData> {
LoggerFactory = Log
});
_configuration = new MyAppElasticConfiguration(_workItemQueue, _cache, _messageBus, Log);
_client = _configuration.Client;
}
public ElasticRepositoryTestBase(ITestOutputHelper output) : base(output)
{
Log.MinimumLevel = LogLevel.Trace;
Log.SetLogLevel <ScheduledTimer>(LogLevel.Warning);
_cache = new InMemoryCacheClient(new InMemoryCacheClientOptions {
LoggerFactory = Log
});
_messageBus = new InMemoryMessageBus(new InMemoryMessageBusOptions {
LoggerFactory = Log
});
_workItemQueue = new InMemoryQueue <WorkItemData>(new InMemoryQueueOptions <WorkItemData> {
LoggerFactory = Log
});
_configuration = new MyAppElasticConfiguration(_workItemQueue, _cache, _messageBus, Log);
_client = _configuration.Client;
_configuration.WaitForReady(new CancellationTokenSource(TimeSpan.FromMinutes(1)).Token);
}
public static IServiceCollection AddMessageBus(this IServiceCollection services)
{
services.AddSingleton(provider =>
{
var options = provider.GetRequiredService <IOptions <MessageBusOptions> >().Value;
var type = options.Type.ToLower();
IMessageBus client;
if (type == "auto")
{
var redisOptions = provider.GetRequiredService <IOptions <RedisOptions> >().Value;
type = !string.IsNullOrEmpty(redisOptions.ConnectionString) ? "redis" : "memory";
}
switch (type)
{
case "inmemory":
case "memory":
client = new InMemoryMessageBus(new InMemoryMessageBusOptions
{
LoggerFactory = provider.GetRequiredService <ILoggerFactory>(),
Serializer = provider.GetRequiredService <ISerializer>()
});
break;
case "redis":
client = new RedisMessageBus(new RedisMessageBusOptions
{
Subscriber = provider.GetRequiredService <IConnectionMultiplexer>().GetSubscriber(),
LoggerFactory = provider.GetRequiredService <ILoggerFactory>(),
Serializer = provider.GetRequiredService <ISerializer>()
});
break;
default:
throw new NotSupportedException($"The cache type {options.Type} is not supported.");
}
return(client);
});
return(services);
}
public when_an_event_is_received()
{
Bus = new InMemoryMessageBus();
var config = Bus.Configuration;
var persistence = new InMemoryPersistence(config.MessageSender, config.Sagas.Storage);
var repository = new Repository <InventoryItem>(new InMemoryEventStore <Guid>(persistence));
var commandHandlers = new InventoryCommandHandlers(repository);
var projector = new Projector();
config.CommandHandlers.Register <CreateInventoryItem>(() => commandHandlers);
config.CommandHandlers.Register <RenameInventoryItem>(() => commandHandlers);
config.CommandHandlers.Register <DeactivateInventoryItem>(() => commandHandlers);
config.EventReceivers.Register <InventoryItemCreated>(() => projector);
config.EventReceivers.Register <InventoryItemRenamed>(() => projector);
config.EventReceivers.Register <InventoryItemDeactivated>(() => projector);
Products = projector.Products;
Bus.Start();
}
protected ScenarioTest(ITestOutputHelper output)
{
this.output = output;
var ignoredMessages = new List <IMessageDescriptor>();
var pendingOperations = new PendingOperations();
IgnoredMessages = ignoredMessages;
var container = CreateContainer(pendingOperations, ignoredMessages);
var configuration = new MessageBusConfigurationBuilder().HasServiceProvider(container).CreateConfiguration();
Bus = new InMemoryMessageBus(configuration, pendingOperations);
Setup = new ScenarioBuilder(Bus);
RegisterCommandHandlers(configuration);
RegisterEventReceivers(configuration);
RegisterSagas(configuration);
Bus.Start(new MessageObserver(output));
}
public async Task CanRunWorkItemWithDelegateHandler()
{
using (var queue = new InMemoryQueue <WorkItemData>(new InMemoryQueueOptions <WorkItemData> {
LoggerFactory = Log
})) {
using (var messageBus = new InMemoryMessageBus(new InMemoryMessageBusOptions {
LoggerFactory = Log
})) {
var handlerRegistry = new WorkItemHandlers();
var job = new WorkItemJob(queue, messageBus, handlerRegistry, Log);
handlerRegistry.Register <MyWorkItem>(async ctx => {
var jobData = ctx.GetData <MyWorkItem>();
Assert.Equal("Test", jobData.SomeData);
for (int i = 1; i < 10; i++)
{
await SystemClock.SleepAsync(100);
await ctx.ReportProgressAsync(10 * i);
}
}, Log.CreateLogger("MyWorkItem"));
string jobId = await queue.EnqueueAsync(new MyWorkItem {
SomeData = "Test"
}, true);
int statusCount = 0;
await messageBus.SubscribeAsync <WorkItemStatus>(status => {
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace("Progress: {Progress}", status.Progress);
}
Assert.Equal(jobId, status.WorkItemId);
Interlocked.Increment(ref statusCount);
});
await job.RunUntilEmptyAsync();
Assert.Equal(11, statusCount);
}
}
}
public void WillOnlyReceiveSubscribedMessageType()
{
var resetEvent = new AutoResetEvent(false);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe <SimpleMessageB>(msg => {
Assert.True(false, "Received wrong message type.");
});
messageBus.Subscribe <SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
resetEvent.Set();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
bool success = resetEvent.WaitOne(100);
Assert.True(success, "Failed to receive message.");
}
public void CanRunBadWorkItem()
{
var queue = new InMemoryQueue <WorkItemData>();
var messageBus = new InMemoryMessageBus();
var handlerRegistry = new WorkItemHandlers();
var job = new WorkItemJob(queue, messageBus, handlerRegistry);
handlerRegistry.Register <MyWorkItem>(async ctx => {
var jobData = ctx.GetData <MyWorkItem>();
Assert.Equal("Test", jobData.SomeData);
throw new ApplicationException();
});
var jobId = queue.Enqueue(new MyWorkItem {
SomeData = "Test"
}, true);
int statusCount = 0;
messageBus.Subscribe <WorkItemStatus>(status => {
Assert.Equal(jobId, status.WorkItemId);
statusCount++;
});
job.RunUntilEmpty();
Assert.Equal(1, statusCount);
handlerRegistry.Register <MyWorkItem>(async ctx => {
var jobData = ctx.GetData <MyWorkItem>();
Assert.Equal("Test", jobData.SomeData);
});
jobId = queue.Enqueue(new MyWorkItem {
SomeData = "Test"
}, true);
job.RunUntilEmpty();
Assert.Equal(2, statusCount);
}
public void CanTolerateSubscriberFailure() {
var latch = new CountDownLatch(2);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<SimpleMessageA>(msg => {
throw new ApplicationException();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
bool success = latch.Wait(900);
Assert.True(success, "Failed to receive all messages.");
}
public async Task CanRunWorkItemWithDelegateHandler()
{
using (var queue = new InMemoryQueue <WorkItemData>(o => o.LoggerFactory(Log))) {
using (var messageBus = new InMemoryMessageBus(o => o.LoggerFactory(Log))) {
var handlerRegistry = new WorkItemHandlers();
var job = new WorkItemJob(queue, messageBus, handlerRegistry, Log);
handlerRegistry.Register <MyWorkItem>(async ctx => {
var jobData = ctx.GetData <MyWorkItem>();
Assert.Equal("Test", jobData.SomeData);
for (int i = 1; i < 10; i++)
{
await SystemClock.SleepAsync(100);
await ctx.ReportProgressAsync(10 * i);
}
}, Log.CreateLogger("MyWorkItem"));
string jobId = await queue.EnqueueAsync(new MyWorkItem {
SomeData = "Test"
}, true);
var countdown = new AsyncCountdownEvent(11);
await messageBus.SubscribeAsync <WorkItemStatus>(status => {
if (_logger.IsEnabled(LogLevel.Trace))
{
_logger.LogTrace("Progress: {Progress}", status.Progress);
}
Assert.Equal(jobId, status.WorkItemId);
countdown.Signal();
});
await job.RunUntilEmptyAsync();
await countdown.WaitAsync(TimeSpan.FromSeconds(2));
Assert.Equal(0, countdown.CurrentCount);
}
}
}
public void CanSendMessageToMultipleSubscribers() {
var latch = new CountDownLatch(3);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.Subscribe<SimpleMessageA>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void WillReceiveDerivedMessageTypes() {
var latch = new CountDownLatch(2);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<ISimpleMessage>(msg => {
Assert.Equal("Hello", msg.Data);
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageB {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageC {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
public void CanSubscribeToAllMessageTypes() {
var latch = new CountDownLatch(3);
var messageBus = new InMemoryMessageBus();
messageBus.Subscribe<object>(msg => {
latch.Signal();
});
messageBus.PublishAsync(new SimpleMessageA {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageB {
Data = "Hello"
});
messageBus.PublishAsync(new SimpleMessageC {
Data = "Hello"
});
bool success = latch.Wait(100);
Assert.True(success, "Failed to receive all messages.");
}
