public WhenSqsIsSlow(ITestOutputHelper testOutputHelper)
{
var loggerFactory = testOutputHelper.ToLoggerFactory();
MiddlewareBase <ReceiveMessagesContext, IList <Message> > sqsMiddleware =
new DelegateMiddleware <ReceiveMessagesContext, IList <Message> >();
var messages = new List <Message> {
new TestMessage()
};
var queue = new FakeSqsQueue(async ct =>
{
await Task.Delay(100);
Interlocked.Increment(ref _callCount);
return(messages);
});
var monitor = new TrackingLoggingMonitor(
loggerFactory.CreateLogger <TrackingLoggingMonitor>());
_messageReceiveBuffer = new MessageReceiveBuffer(
10,
10,
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(1),
queue,
sqsMiddleware,
monitor,
loggerFactory.CreateLogger <IMessageReceiveBuffer>());
}
public WhenThereAreNoSubscribers(ITestOutputHelper testOutputHelper)
{
_outputHelper = testOutputHelper;
var loggerFactory = testOutputHelper.ToLoggerFactory();
MiddlewareBase <ReceiveMessagesContext, IList <Message> > sqsMiddleware =
new DelegateMiddleware <ReceiveMessagesContext, IList <Message> >();
var messages = new List <Message> {
new TestMessage()
};
var queue = new FakeSqsQueue(ct =>
{
Interlocked.Increment(ref _callCount);
return(Task.FromResult(messages.AsEnumerable()));
});
var monitor = new TrackingLoggingMonitor(
loggerFactory.CreateLogger <TrackingLoggingMonitor>());
_messageReceiveBuffer = new MessageReceiveBuffer(
10,
10,
TimeSpan.FromSeconds(1),
TimeSpan.FromSeconds(1),
queue,
sqsMiddleware,
monitor,
loggerFactory.CreateLogger <IMessageReceiveBuffer>());
}
private static ISqsQueue TestQueue(
IMessageSerializationRegister messageSerializationRegister,
string queueName,
Action spy = null)
{
var message = new TestJustSayingMessage
{
QueueName = queueName,
};
var messages = new List <Message>
{
new TestMessage {
Body = messageSerializationRegister.Serialize(message, false)
},
};
var queue = new FakeSqsQueue(async ct =>
{
spy?.Invoke();
await Task.Delay(30, ct);
return(messages);
}, queueName);
return(queue);
}
protected override void Given()
{
_queue = CreateSuccessfulTestQueue(Guid.NewGuid().ToString(), new TestMessage());
Queues.Add(_queue);
Handler.ShouldSucceed = false;
}
protected override void Given()
{
// we expect to get max 10 messages per batch
_expectedMaxMessageCount = MessageDefaults.MaxAmazonMessageCap;
Logger.LogInformation("Expected max message count is {MaxMessageCount}", _expectedMaxMessageCount);
var response1 = new Message {
Body = AttributeMessageContentsRunning
};
var response2 = new Message {
Body = AttributeMessageContentsAfterStop
};
IEnumerable <Message> GetMessages(CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
if (_running)
{
yield return(response1);
}
else
{
yield return(response2);
}
}
}
_queue = CreateSuccessfulTestQueue(Guid.NewGuid().ToString(), ct => Task.FromResult(GetMessages(ct)));
Queues.Add(_queue);
}
private static ISqsQueue TestQueue(Func <IEnumerable <ReceiveMessageResponse> > getMessages)
{
var fakeSqs = new FakeAmazonSqs(getMessages);
var fakeQueue =
new FakeSqsQueue("test-queue", fakeSqs);
return(fakeQueue);
}
protected static FakeSqsQueue CreateSuccessfulTestQueue(
string queueName,
Func <CancellationToken, Task <IEnumerable <Message> > > messageProducer)
{
var sqsQueue = new FakeSqsQueue(messageProducer,
queueName);
return(sqsQueue);
}
protected override void Given()
{
_queue = CreateSuccessfulTestQueue(Guid.NewGuid().ToString(),
ct => Task.FromResult(new List <Message> {
new TestMessage {
Body = _messageBody
}
}.AsEnumerable()));
Queues.Add(_queue);
}
private static ISqsQueue TestQueue(Action spy = null)
{
IEnumerable <Message> GetMessages()
{
spy?.Invoke();
throw new InvalidOperationException();
}
var queue = new FakeSqsQueue(ct => Task.FromResult(GetMessages()), "test-queue");
return(queue);
}
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();
}
private static ISqsQueue TestQueue(Action spy = null)
{
ReceiveMessageResponse GetMessages()
{
spy?.Invoke();
throw new InvalidOperationException();
}
var sqs = new FakeAmazonSqs(() => GetMessages().Infinite());
var queue = new FakeSqsQueue("test-queue", sqs);
return(queue);
}
protected override void Given()
{
base.Given();
IEnumerable <Message> GetMessages(CancellationToken cancellationToken)
{
while (!cancellationToken.IsCancellationRequested)
{
yield return(new TestMessage());
}
}
_queue1 = new FakeSqsQueue(ct => Task.FromResult(GetMessages(ct)), "queue1");
_queue2 = new FakeSqsQueue(ct => Task.FromResult(GetMessages(ct)), "queue2");
}
protected override void Given()
{
_queue = CreateSuccessfulTestQueue("TestQueue", new TestMessage());
Queues.Add(_queue);
Handler.OnHandle = (msg) =>
{
if (!_firstTime)
{
return;
}
_firstTime = false;
throw new TestException("Thrown by test handler");
};
}
protected virtual void Given()
{
_typedMessage = new OrderAccepted();
_sqsMessage = new SQSMessage
{
Body = JsonConvert.SerializeObject(_typedMessage),
ReceiptHandle = "i_am_receipt_handle"
};
IEnumerable <SQSMessage> GetMessages()
{
yield return(_sqsMessage);
}
_queue = new FakeSqsQueue(ct => Task.FromResult(GetMessages()))
{
Uri = new Uri(ExpectedQueueUrl)
};
_serializationRegister.DeserializeMessage(Arg.Any <string>())
.Returns(new MessageWithAttributes(_typedMessage, new MessageAttributes()));
}
