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."); }