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();
}
