public FakeTransportInfrastructure(ReceiveSettings[] receiveSettings) { Dispatcher = new FakeDispatcher(); Receivers = receiveSettings .Select(settings => new FakeReceiver()) .ToDictionary <FakeReceiver, string, IMessageReceiver>(r => r.Id, r => r); }
public void after_orderPaid_then_orderCompleted() { // given var d = new FakeDispatcher(); var m = new Runner(d); var o = new Order { OrderId = Guid.NewGuid() }; // when var inputEvent = new OrderPaid { Order = o }; m.Handle(inputEvent); // then Assert.Equal(2, d.Messages.Count); Assert.IsType <PrintOrder>(d.Messages[0]); Assert.IsType <OrderCompleted>(d.Messages[1]); var x0 = d.Messages[0] as PrintOrder; var x1 = d.Messages[1] as OrderCompleted; Assert.Equal(o.OrderId, x0.Order.OrderId); Assert.Equal(inputEvent.CorrelationId, x0.CorrelationId); Assert.Equal(inputEvent.MessageId, x0.ParentId); Assert.True(x1.Success); Assert.False(x1.Retried); Assert.Equal(o.OrderId, x1.Order.OrderId); Assert.Equal(inputEvent.CorrelationId, x1.CorrelationId); Assert.Equal(inputEvent.MessageId, x1.ParentId); }
public void after_foodCooked_then_priceOrder() { // given var d = new FakeDispatcher(); var m = new Runner(d); var o = new Order { OrderId = Guid.NewGuid() }; // when var inputEvent = new FoodCooked { Order = o }; m.Handle(inputEvent); // then Assert.Single(d.Messages); Assert.IsType <PriceOrder>(d.Messages[0]); var x0 = d.Messages[0] as PriceOrder; Assert.Equal(o.OrderId, x0.Order.OrderId); Assert.Equal(inputEvent.CorrelationId, x0.CorrelationId); Assert.Equal(inputEvent.MessageId, x0.ParentId); }
public void after_first_attempt_succeeded_on_callback_do_nothing() { // given var d = new FakeDispatcher(); var m = new Runner(d); var o = new Order { OrderId = Guid.NewGuid() }; m.Handle(new OrderPlaced { Order = o }); m.Handle(new FoodCooked { Order = o }); var cookFoodCallback = (d.Messages[1] as Callback).Payload as CookFoodCalledBack; d.Clear(); // when m.Handle(cookFoodCallback); // then Assert.Empty(d.Messages); }
public async Task Sqs_Queue_Is_Not_Polled_After_Cancellation() { var cts = new CancellationTokenSource(); int callCountBeforeCancelled = 0; int callCountAfterCancelled = 0; ISqsQueue sqsQueue = TestQueue(() => { if (cts.Token.IsCancellationRequested) { callCountAfterCancelled++; } else { callCountBeforeCancelled++; } }); IMessageDispatcher dispatcher = new FakeDispatcher(); var bus = CreateSubscriptionGroup(new[] { sqsQueue }, dispatcher); var runTask = bus.RunAsync(cts.Token); cts.CancelAfter(TimeoutPeriod); await Assert.ThrowsAnyAsync <OperationCanceledException>(() => runTask); callCountBeforeCancelled.ShouldBeGreaterThan(0); callCountAfterCancelled.ShouldBeLessThanOrEqualTo(1); }
public async Task Messages_Not_Dispatched_After_Cancellation() { var cts = new CancellationTokenSource(); int dispatchedBeforeCancelled = 0; int dispatchedAfterCancelled = 0; ISqsQueue sqsQueue = TestQueue(); IMessageDispatcher dispatcher = new FakeDispatcher(() => { if (cts.Token.IsCancellationRequested) { dispatchedAfterCancelled++; } else { dispatchedBeforeCancelled++; } }); var bus = CreateSubscriptionGroup(new[] { sqsQueue }, dispatcher); var runTask = bus.RunAsync(cts.Token); cts.CancelAfter(TimeoutPeriod); await Assert.ThrowsAnyAsync <OperationCanceledException>(async() => await runTask); dispatchedBeforeCancelled.ShouldBeGreaterThan(0); dispatchedAfterCancelled.ShouldBe(0); }
public async Task QueueCanBeAssignedToOnePump() { var sqsQueue = TestQueue(); var buffer = CreateMessageReceiveBuffer(sqsQueue); IMessageDispatcher dispatcher = new FakeDispatcher(); IMultiplexerSubscriber consumer1 = CreateSubscriber(dispatcher); IMultiplexer multiplexer = CreateMultiplexer(); multiplexer.ReadFrom(buffer.Reader); consumer1.Subscribe(multiplexer.GetMessagesAsync()); var cts = new CancellationTokenSource(); var multiplexerCompletion = multiplexer.RunAsync(cts.Token); var consumer1Completion = consumer1.RunAsync(cts.Token); var buffer1Completion = buffer.RunAsync(cts.Token); cts.Cancel(); await multiplexerCompletion.HandleCancellation(); await Assert.ThrowsAnyAsync <OperationCanceledException>(() => consumer1Completion); await Assert.ThrowsAnyAsync <OperationCanceledException>(() => buffer1Completion); }
public void after_orderPlaced_then_cookFood_and_set_timeout() { // given var d = new FakeDispatcher(); var m = new Runner(d); var o = new Order { OrderId = Guid.NewGuid() }; // when var inputEvent = new OrderPlaced { Order = o }; m.Handle(inputEvent); // then Assert.Equal(2, d.Messages.Count); Assert.IsType <CookFood>(d.Messages[0]); Assert.IsType <Callback>(d.Messages[1]); var x0 = d.Messages[0] as CookFood; var x1 = d.Messages[1] as Callback; Assert.Equal(o.OrderId, x0.Order.OrderId); Assert.Equal(inputEvent.CorrelationId, x0.CorrelationId); Assert.Equal(inputEvent.MessageId, x0.ParentId); Assert.Equal(inputEvent.CorrelationId, x1.CorrelationId); Assert.Equal(inputEvent.MessageId, x1.ParentId); Assert.Equal(5, x1.Seconds); Assert.IsType <CookFoodCalledBack>(x1.Payload); }
public async Task DoAsync_ConsumesRequests_WhenRequestsAvailable() { var transport = new FakeTransport(100); var dispatcher = new FakeDispatcher(); var cqrs = new CqrsStrategy(new RequestTypeFinder(new[] { typeof(FakeCommand) })) { Dispatcher = dispatcher, Formatter = new JsonRequestContentFormatter() }; var orchestrator = new EngineBuilder(options => { options.Warps = 5; options.RequestsPerWarp = 5; options.RunRequestsInWarpAllAtOnce = true; options.SlidingStep = TimeSpan.FromMilliseconds(10); }) .ReceiveRequestsFrom(r => r.Add(transport)) .Finally(cqrs) .BuildOrchestrator(); await orchestrator.StartAsync(); var completed = await transport.Complete(); await orchestrator.StopAsync(TimeSpan.Zero); Assert.Equal(100, dispatcher.CallCounter); Assert.Equal(100, completed); }
public async Task QueueCanBeAssignedToMultiplePumps() { var sqsQueue = TestQueue(); var buffer = CreateMessageReceiveBuffer(sqsQueue); IMessageDispatcher dispatcher = new FakeDispatcher(); IMultiplexerSubscriber consumer1 = CreateSubscriber(dispatcher); IMultiplexerSubscriber consumer2 = CreateSubscriber(dispatcher); IMultiplexer multiplexer = CreateMultiplexer(); multiplexer.ReadFrom(buffer.Reader); consumer1.Subscribe(multiplexer.GetMessagesAsync()); consumer2.Subscribe(multiplexer.GetMessagesAsync()); using var cts = new CancellationTokenSource(TimeoutPeriod); // consumers var multiplexerCompletion = multiplexer.RunAsync(cts.Token); var consumer1Completion = consumer1.RunAsync(cts.Token); var consumer2Completion = consumer2.RunAsync(cts.Token); var buffer1Completion = buffer.RunAsync(cts.Token); var results = await Task.WhenAll( multiplexerCompletion.HandleCancellation(), buffer1Completion.HandleCancellation(), consumer1Completion.HandleCancellation(), consumer2Completion.HandleCancellation()); results.Any().ShouldBeTrue(); }
public void SetUp() { var publishers = new Publishers(); publishers.AddOrReplacePublishers("A", new List<PublisherTableEntry> {new PublisherTableEntry(typeof(object), PublisherAddress.CreateFromPhysicalAddresses("publisher1"))}); router = new SubscriptionRouter(publishers, new EndpointInstances(), i => i.ToString()); dispatcher = new FakeDispatcher(); subscribeTerminator = new MessageDrivenSubscribeTerminator(router, "replyToAddress", "Endpoint", dispatcher); }
public async Task Subscriber_Not_Started_No_Buffer_Filled_Then_No_More_Messages_Requested() { // Arrange int messagesFromQueue = 0; int messagesDispatched = 0; int receivebufferSize = 2; int multiplexerCapacity = 2; // plus one "in flight" between buffer and multiplexer int expectedReceiveFromQueueCount = receivebufferSize + multiplexerCapacity + 1; var sqsQueue = TestQueue(() => Interlocked.Increment(ref messagesFromQueue)); IMessageReceiveBuffer buffer = CreateMessageReceiveBuffer(sqsQueue, receivebufferSize); IMessageDispatcher dispatcher = new FakeDispatcher(() => Interlocked.Increment(ref messagesDispatched)); IMultiplexerSubscriber consumer1 = CreateSubscriber(dispatcher); IMultiplexer multiplexer = CreateMultiplexer(multiplexerCapacity); multiplexer.ReadFrom(buffer.Reader); consumer1.Subscribe(multiplexer.GetMessagesAsync()); // need to start the multiplexer before calling Messages using var cts = new CancellationTokenSource(); // Act and Assert var multiplexerCompletion = multiplexer.RunAsync(cts.Token); var bufferCompletion = buffer.RunAsync(cts.Token); cts.CancelAfter(TimeSpan.FromSeconds(3)); await multiplexerCompletion.HandleCancellation(); await Assert.ThrowsAnyAsync <OperationCanceledException>(() => bufferCompletion); await Patiently.AssertThatAsync(OutputHelper, () => { messagesFromQueue.ShouldBe(expectedReceiveFromQueueCount); messagesDispatched.ShouldBe(0); return(true); }); // Starting the consumer after the token is cancelled will not dispatch messages await Assert.ThrowsAnyAsync <OperationCanceledException>(() => consumer1.RunAsync(cts.Token)); await Patiently.AssertThatAsync(OutputHelper, () => { messagesFromQueue.ShouldBe(expectedReceiveFromQueueCount); messagesDispatched.ShouldBe(0); return(true); }); }
public void SetUp() { publishers = new Publishers(); publishers.AddOrReplacePublishers("A", new List <PublisherTableEntry> { new PublisherTableEntry(typeof(object), PublisherAddress.CreateFromPhysicalAddresses("publisher1")) }); router = new SubscriptionRouter(publishers, new EndpointInstances(), i => i.ToString()); dispatcher = new FakeDispatcher(); subscribeTerminator = new MessageDrivenSubscribeTerminator(router, "replyToAddress", "Endpoint", dispatcher); }
public void SetUp() { agent = Mock.Of <IAgentControl>(); var dispatcherMock = new Mock <FakeDispatcher>() { CallBase = true }; dispatcher = dispatcherMock.Object; adapter = new AgentControlJsonAdapter(agent, dispatcher); }
public async Task Sqs_Client_Throwing_Exceptions_Continues_To_Request_Messages() { // Arrange int messagesRequested = 0; int messagesDispatched = 0; IEnumerable <Message> GetMessages() { Interlocked.Increment(ref messagesRequested); throw new Exception(); } var queue = new FakeSqsQueue(ct => Task.FromResult(GetMessages())); var queues = new List <ISqsQueue> { queue }; IMessageDispatcher dispatcher = new FakeDispatcher(() => { Interlocked.Increment(ref messagesDispatched); }); var defaults = new SubscriptionGroupSettingsBuilder() .WithDefaultConcurrencyLimit(8); var settings = new Dictionary <string, SubscriptionGroupConfigBuilder> { { "test", new SubscriptionGroupConfigBuilder("test").AddQueues(queues) }, }; var subscriptionGroupFactory = new SubscriptionGroupFactory( dispatcher, MessageMonitor, LoggerFactory); ISubscriptionGroup collection = subscriptionGroupFactory.Create(defaults, settings); var cts = new CancellationTokenSource(); // Act var runTask = collection.RunAsync(cts.Token); await Patiently.AssertThatAsync(_outputHelper, () => { messagesRequested.ShouldBeGreaterThan(1, $"but was {messagesRequested}"); messagesDispatched.ShouldBe(0, $"but was {messagesDispatched}"); }); cts.Cancel(); await runTask.HandleCancellation(); }
public void SubscriptionGroup_StartingTwice_ShouldReturnSameCompletionTask() { var queue = TestQueue(); var dispatcher = new FakeDispatcher(); var bus = CreateSubscriptionGroup(new[] { queue }, dispatcher); var cts = new CancellationTokenSource(TimeoutPeriod); var task1 = bus.RunAsync(cts.Token); var task2 = bus.RunAsync(cts.Token); Assert.True(ReferenceEquals(task1, task2)); }
public async Task Try() { var persister = new InMemorySagaPersister(); var inbox = new InMemoryInbox(); var dispatcher = new FakeDispatcher(); var manager = new SagaManager(persister, inbox, dispatcher); await manager.Process <SagaData>("messageId", "correlationId", new ContextBag(), HandlerCallback); var dataContainer = await persister.LoadByCorrelationId("correlationId"); var sagaData = (SagaData)dataContainer.SagaData; Assert.AreEqual(1, sagaData.Counter); }
public async Task ErrorHandlingAroundSqs_WithCustomPolicy_CanSwallowExceptions() { // Arrange int queueCalledCount = 0; int dispatchedMessageCount = 0; var sqsQueue = TestQueue(() => Interlocked.Increment(ref queueCalledCount)); var queues = new List <ISqsQueue> { sqsQueue }; var config = new SubscriptionGroupSettingsBuilder() .WithDefaultConcurrencyLimit(8); config.WithCustomMiddleware( new ErrorHandlingMiddleware <GetMessagesContext, IList <Message>, InvalidOperationException>()); var settings = new Dictionary <string, SubscriptionGroupConfigBuilder> { { "test", new SubscriptionGroupConfigBuilder("test").AddQueues(queues) }, }; IMessageDispatcher dispatcher = new FakeDispatcher(() => Interlocked.Increment(ref dispatchedMessageCount)); var groupFactory = new SubscriptionGroupFactory( dispatcher, MessageMonitor, LoggerFactory); ISubscriptionGroup collection = groupFactory.Create(config, settings); var cts = new CancellationTokenSource(); var completion = collection.RunAsync(cts.Token); await Patiently.AssertThatAsync(_outputHelper, () => { queueCalledCount.ShouldBeGreaterThan(1); dispatchedMessageCount.ShouldBe(0); }); cts.Cancel(); // Act and Assert await completion.HandleCancellation(); }
public void after_second_attempt_failed_on_callback_give_up() { // given var d = new FakeDispatcher(); var m = new Runner(d); var o = new Order { OrderId = Guid.NewGuid() }; m.Handle(new OrderPlaced { Order = o }); var cookFoodCallback1 = (d.Messages[1] as Callback).Payload as CookFoodCalledBack; d.Clear(); m.Handle(cookFoodCallback1); var cookFoodCallback2 = (d.Messages[1] as Callback).Payload as CookFoodCalledBack; d.Clear(); // when var inputEvent = cookFoodCallback2; m.Handle(cookFoodCallback2); // then Assert.Equal(2, d.Messages.Count); Assert.IsType <FailedToContactTheKitchen>(d.Messages[0]); Assert.IsType <OrderCompleted>(d.Messages[1]); var x0 = d.Messages[0] as FailedToContactTheKitchen; var x1 = d.Messages[1] as OrderCompleted; Assert.Equal(o.OrderId, x0.Order.OrderId); Assert.Equal(inputEvent.CorrelationId, x0.CorrelationId); Assert.Equal(inputEvent.MessageId, x0.ParentId); Assert.False(x1.Success); Assert.True(x1.Retried); Assert.Equal(o.OrderId, x1.Order.OrderId); Assert.Equal(inputEvent.CorrelationId, x1.CorrelationId); Assert.Equal(inputEvent.MessageId, x1.ParentId); }
public async Task Can_Be_Set_Up_Using_SubscriptionBus() { var sqsQueue1 = TestQueue(); var sqsQueue2 = TestQueue(); var sqsQueue3 = TestQueue(); var queues = new List <ISqsQueue> { sqsQueue1, sqsQueue2, sqsQueue3 }; IMessageDispatcher dispatcher = new FakeDispatcher(); var bus = CreateSubscriptionGroup(queues, dispatcher); var cts = new CancellationTokenSource(); cts.CancelAfter(TimeoutPeriod); await Assert.ThrowsAnyAsync <OperationCanceledException>(() => bus.RunAsync(cts.Token)); }
public void produces_paid_event_when_food_is_paid_for() { var order = new Order(); var dispatcher = new FakeDispatcher(); var cashier = new Cashier(dispatcher); cashier.Handle(new TakePayment(null) { Order = order }); Assert.Equal(1, dispatcher.Messages.Count); var evnt = dispatcher.Messages[0]; Assert.IsType <OrderPaid>(evnt); }
public async Task MultipleQueuesCanBeAssignedToMultiplePumps() { var sqsQueue1 = TestQueue(); var sqsQueue2 = TestQueue(); var buffer1 = CreateMessageReceiveBuffer(sqsQueue1); var buffer2 = CreateMessageReceiveBuffer(sqsQueue2); // using 2 dispatchers for logging, they should be the same/stateless IMessageDispatcher dispatcher1 = new FakeDispatcher(); IMessageDispatcher dispatcher2 = new FakeDispatcher(); IMultiplexerSubscriber consumer1 = CreateSubscriber(dispatcher1); IMultiplexerSubscriber consumer2 = CreateSubscriber(dispatcher2); IMultiplexer multiplexer = CreateMultiplexer(); multiplexer.ReadFrom(buffer1.Reader); multiplexer.ReadFrom(buffer2.Reader); consumer1.Subscribe(multiplexer.GetMessagesAsync()); consumer2.Subscribe(multiplexer.GetMessagesAsync()); var cts = new CancellationTokenSource(); cts.CancelAfter(TimeoutPeriod); var multiplexerCompletion = multiplexer.RunAsync(cts.Token); // consumers var consumer1Completion = consumer1.RunAsync(cts.Token); var consumer2Completion = consumer2.RunAsync(cts.Token); var buffer1Completion = buffer1.RunAsync(cts.Token); var buffer2Completion = buffer2.RunAsync(cts.Token); await Assert.ThrowsAnyAsync <OperationCanceledException>(() => buffer1Completion); await Assert.ThrowsAnyAsync <OperationCanceledException>(() => buffer2Completion); await Assert.ThrowsAnyAsync <OperationCanceledException>(() => consumer1Completion); await Assert.ThrowsAnyAsync <OperationCanceledException>(() => consumer2Completion); await multiplexerCompletion; }
public async Task MultipleQueuesCanBeAssignedToMultiplePumps() { var sqsQueue1 = TestQueue(); var sqsQueue2 = TestQueue(); var buffer1 = CreateMessageReceiveBuffer(sqsQueue1); var buffer2 = CreateMessageReceiveBuffer(sqsQueue2); // using 2 dispatchers for logging, they should be the same/stateless IMessageDispatcher dispatcher1 = new FakeDispatcher(); IMessageDispatcher dispatcher2 = new FakeDispatcher(); IMultiplexerSubscriber consumer1 = CreateSubscriber(dispatcher1); IMultiplexerSubscriber consumer2 = CreateSubscriber(dispatcher2); IMultiplexer multiplexer = CreateMultiplexer(); multiplexer.ReadFrom(buffer1.Reader); multiplexer.ReadFrom(buffer2.Reader); consumer1.Subscribe(multiplexer.GetMessagesAsync()); consumer2.Subscribe(multiplexer.GetMessagesAsync()); var cts = new CancellationTokenSource(); var multiplexerCompletion = multiplexer.RunAsync(cts.Token); // consumers var consumer1Completion = consumer1.RunAsync(cts.Token); var consumer2Completion = consumer2.RunAsync(cts.Token); var buffer1Completion = buffer1.RunAsync(cts.Token); var buffer2Completion = buffer2.RunAsync(cts.Token); cts.Cancel(); var results = await Task.WhenAll( multiplexerCompletion.HandleCancellation(), buffer1Completion.HandleCancellation(), buffer2Completion.HandleCancellation(), consumer1Completion.HandleCancellation(), consumer2Completion.HandleCancellation()); results.Any().ShouldBeTrue(); }
public async Task Message_Processing_Throwing_Exceptions_Continues_To_Request_Messages() { // Arrange int messagesRequested = 0; int messagesDispatched = 0; var sqsQueue1 = TestQueue(() => GetErrorMessages(() => messagesRequested++)); var queues = new List <ISqsQueue> { sqsQueue1 }; IMessageDispatcher dispatcher = new FakeDispatcher(() => Interlocked.Increment(ref messagesDispatched)); var defaults = new SubscriptionGroupSettingsBuilder() .WithDefaultConcurrencyLimit(1); var settings = new Dictionary <string, SubscriptionGroupConfigBuilder> { { "test", new SubscriptionGroupConfigBuilder("test").AddQueues(queues) }, }; var subscriptionGroupFactory = new SubscriptionGroupFactory( dispatcher, MessageMonitor, LoggerFactory); ISubscriptionGroup collection = subscriptionGroupFactory.Create(defaults, settings); var cts = new CancellationTokenSource(); // Act var runTask = collection.RunAsync(cts.Token); await Patiently.AssertThatAsync(_outputHelper, () => { messagesRequested.ShouldBeGreaterThan(1); messagesDispatched.ShouldBe(0); }); cts.Cancel(); await runTask.HandleCancellation(); }
public void after_second_attempt_succeeded_then_price_order() { // given var d = new FakeDispatcher(); var m = new Runner(d); var o = new Order { OrderId = Guid.NewGuid() }; m.Handle(new OrderPlaced { Order = o }); var cookFoodCallback1 = (d.Messages[1] as Callback).Payload as CookFoodCalledBack; d.Clear(); m.Handle(cookFoodCallback1); var cookFoodCallback2 = (d.Messages[1] as Callback).Payload as CookFoodCalledBack; d.Clear(); // when var inputEvent = new FoodCooked { Order = o }; m.Handle(inputEvent); // then Assert.Single(d.Messages); Assert.IsType <PriceOrder>(d.Messages[0]); var x0 = d.Messages[0] as PriceOrder; Assert.Equal(o.OrderId, x0.Order.OrderId); Assert.Equal(inputEvent.CorrelationId, x0.CorrelationId); Assert.Equal(inputEvent.MessageId, x0.ParentId); }
public void after_first_attempt_failed_on_callback_retry() { // given var d = new FakeDispatcher(); var m = new Runner(d); var o = new Order { OrderId = Guid.NewGuid() }; m.Handle(new OrderPlaced { Order = o }); var cookFoodCallback1 = (d.Messages[1] as Callback).Payload as CookFoodCalledBack; d.Clear(); // when var inputEvent = cookFoodCallback1; m.Handle(inputEvent); // then Assert.Equal(2, d.Messages.Count); Assert.IsType <CookFood>(d.Messages[0]); Assert.IsType <Callback>(d.Messages[1]); var x0 = d.Messages[0] as CookFood; var x1 = d.Messages[1] as Callback; Assert.Equal(o.OrderId, x0.Order.OrderId); Assert.Equal(inputEvent.CorrelationId, x0.CorrelationId); Assert.Equal(inputEvent.MessageId, x0.ParentId); Assert.Equal(inputEvent.CorrelationId, x1.CorrelationId); Assert.Equal(inputEvent.MessageId, x1.ParentId); Assert.Equal(5, x1.Seconds); Assert.IsType <CookFoodCalledBack>(x1.Payload); }
public async Task WhenSubscriberNotStarted_BufferShouldFillUp_AndStopDownloading(int receivePrefetch, int receiveBufferSize, int multiplexerCapacity, int expectedDownloadCount) { var sqsQueue = TestQueue(); IMessageReceiveBuffer buffer = CreateMessageReceiveBuffer(sqsQueue, receivePrefetch, receiveBufferSize); FakeDispatcher dispatcher = new FakeDispatcher(); IMultiplexerSubscriber consumer1 = CreateSubscriber(dispatcher); IMultiplexer multiplexer = CreateMultiplexer(multiplexerCapacity); multiplexer.ReadFrom(buffer.Reader); consumer1.Subscribe(multiplexer.GetMessagesAsync()); OutputHelper.WriteLine("Multiplexer" + JsonConvert.SerializeObject(multiplexer.Interrogate())); OutputHelper.WriteLine("MessageReceiveBuffer" + JsonConvert.SerializeObject(buffer.Interrogate())); using var cts = new CancellationTokenSource(); // Act and Assert var multiplexerCompletion = multiplexer.RunAsync(cts.Token); var bufferCompletion = buffer.RunAsync(cts.Token); cts.CancelAfter(3.Seconds()); await multiplexerCompletion.HandleCancellation(); await bufferCompletion.HandleCancellation(); sqsQueue.ReceiveMessageRequests.Sum(x => x.NumMessagesReceived).ShouldBe(expectedDownloadCount); dispatcher.DispatchedMessages.Count.ShouldBe(0); // Starting the consumer after the token is cancelled will not dispatch messages await Assert.ThrowsAnyAsync <OperationCanceledException>(() => consumer1.RunAsync(cts.Token)); await Patiently.AssertThatAsync(OutputHelper, () => { sqsQueue.ReceiveMessageRequests.Sum(x => x.NumMessagesReceived).ShouldBe(expectedDownloadCount); dispatcher.DispatchedMessages.Count.ShouldBe(0); }); }
static Context_dispatcher_controller() { dispatcher = Pleasure.Mock <IDispatcher>(); IoCFactory.Instance.StubTryResolve(dispatcher.Object); controller = new FakeDispatcher(); requestBase = Pleasure.Mock <HttpRequestBase>(mock => { mock.SetupGet(r => r.Headers).Returns(new NameValueCollection { { "X-Requested-With", "XMLHttpRequest" } }); }); responseBase = Pleasure.MockStrict <HttpResponseBase>(); controller.ControllerContext = new ControllerContext(Pleasure.MockStrictAsObject <HttpContextBase>(mock => { mock.SetupGet(r => r.Request).Returns(requestBase.Object); mock.SetupGet(r => r.Response).Returns(responseBase.Object); }), new RouteData(), controller); controller.ValueProvider = Pleasure.MockStrictAsObject <IValueProvider>(mock => mock.Setup(r => r.GetValue(Pleasure.MockIt.IsAny <string>())).Returns(new ValueProviderResult(string.Empty, string.Empty, Thread.CurrentThread.CurrentCulture))); }
protected static void Establish(Type[] types = null, bool isAjax = true) { typeof(DispatcherControllerBase).GetField("types", BindingFlags.Static | BindingFlags.NonPublic).SetValue(null, new List <Type>()); dispatcher = Pleasure.Mock <IDispatcher>(); IoCFactory.Instance.StubTryResolve(dispatcher.Object); controller = new FakeDispatcher(); var requestBase = Pleasure.MockAsObject <HttpRequestBase>(mock => { if (isAjax) { mock.SetupGet(r => r.Headers).Returns(new NameValueCollection { { "X-Requested-With", "XMLHttpRequest" } }); } mock.SetupGet(r => r.Form).Returns(new NameValueCollection() { { "[0].Name", "Value" }, { "[1].Name", "Value" }, }); }); controller.ControllerContext = new ControllerContext(Pleasure.MockStrictAsObject <HttpContextBase>(mock => mock.SetupGet(r => r.Request).Returns(requestBase)), new RouteData(), controller); controller.ValueProvider = Pleasure.MockStrictAsObject <IValueProvider>(mock => mock.Setup(r => r.GetValue(Pleasure.MockIt.IsAny <string>())).Returns(new ValueProviderResult(string.Empty, string.Empty, Thread.CurrentThread.CurrentCulture))); var modelBinderDictionary = new ModelBinderDictionary(); var modelBinder = Pleasure.MockAsObject <IModelBinder>(mock => mock.Setup(r => r.BindModel(Pleasure.MockIt.IsAny <ControllerContext>(), Pleasure.MockIt.IsAny <ModelBindingContext>()))); foreach (var type in types.Recovery(new Type[] { })) { modelBinderDictionary.Add(type, modelBinder); } controller.SetValue("Binders", modelBinderDictionary); }
public async Task PerformScenario(string scenario) { Console.WriteLine("Scenario: " + scenario); var dispatcher = new FakeDispatcher(); //var sagaManagerFactory = new BaselineSagaManagerFactory(); //var sagaManagerFactory = new BasicInboxSagaManagerFactory(); //var sagaManagerFactory = new InboxWithOutOfDocumentOutboxSagaManagerFactory(); var sagaManagerFactory = new TokenBasedWithExternalOutboxSagaManagerFactory(); sagaManagerFactory.PrepareMessage(MessageId); var controller = new TestController(scenario); var processes = new Dictionary <char, SagaManagerTask> { ['A'] = new SagaManagerTask(sagaManagerFactory, dispatcher, MessageId, SagaId, "A"), ['B'] = new SagaManagerTask(sagaManagerFactory, dispatcher, MessageId, SagaId, "B") }; foreach (var process in scenario) { await processes[process].MakeStep(); } var sagaData = await sagaManagerFactory.LoadSaga(SagaId); if (sagaData != null) { Assert.AreEqual(1, ((SagaData)sagaData).Counter); } foreach (var call in controller.CallHistory) { Console.WriteLine(" - " + call); } }
public async Task PerformScenario(string scenario) { var controller = new TestController(scenario); var persister = new InMemorySagaPersister(); var inbox = new InMemoryInbox(); var dispatcher = new FakeDispatcher(); var persisterA = new TestingSagaDataPersister(persister, inbox, 'A', controller.GetBarrier); var persisterB = new TestingSagaDataPersister(persister, inbox, 'B', controller.GetBarrier); var managerA = new SagaManager(persisterA, persisterA, dispatcher); var managerB = new SagaManager(persisterB, persisterB, dispatcher); var processA = Task.Run(() => ProcessMessage(managerA, controller)); var processB = Task.Run(() => ProcessMessage(managerB, controller)); var done = Task.WhenAll(processA, processB); await done.ConfigureAwait(false); var dataContainer = await persister.LoadByCorrelationId("correlationId"); var sagaData = (SagaData)dataContainer.SagaData; Assert.AreEqual(1, sagaData.Counter); }
public void Setup() { dispatcher = new FakeDispatcher(); staticFaultMetadata = new Dictionary<string, string>(); moveToErrorsExecutor = new MoveToErrorsExecutor(dispatcher, staticFaultMetadata, headers => { }); }
public void Setup() { dispatcher = new FakeDispatcher(); }
public void SetUp() { dispatcher = new FakeDispatcher(); eventAggregator = new FakeEventAggregator(); }