public void Setup()
{
_mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict);
var client = new ServiceBusClient(_testConnection);
ServiceBusProcessorOptions processorOptions = new ServiceBusProcessorOptions();
ServiceBusProcessor messageProcessor = client.CreateProcessor(_entityPath);
_mockMessageProcessor = new Mock <MessageProcessor>(MockBehavior.Strict, messageProcessor);
_serviceBusOptions = new ServiceBusOptions();
_mockMessagingProvider = new Mock <MessagingProvider>(MockBehavior.Strict, new OptionsWrapper <ServiceBusOptions>(_serviceBusOptions));
_mockMessagingProvider
.Setup(p => p.CreateMessageProcessor(_entityPath, _testConnection))
.Returns(_mockMessageProcessor.Object);
_mockServiceBusAccount = new Mock <ServiceBusAccount>(MockBehavior.Strict);
_mockServiceBusAccount.Setup(a => a.ConnectionString).Returns(_testConnection);
_loggerFactory = new LoggerFactory();
_loggerProvider = new TestLoggerProvider();
_loggerFactory.AddProvider(_loggerProvider);
_listener = new ServiceBusListener(_functionId, EntityType.Queue, _entityPath, false, _mockExecutor.Object, _serviceBusOptions, _mockServiceBusAccount.Object,
_mockMessagingProvider.Object, _loggerFactory, false);
_scaleMonitor = (ServiceBusScaleMonitor)_listener.GetMonitor();
}
public ServiceBusListenerTests()
{
_mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict);
string testConnection = "Endpoint=sb://test.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=abc123=";
_messagingFactory = MessagingFactory.CreateFromConnectionString(testConnection);
OnMessageOptions messageOptions = new OnMessageOptions();
_mockMessageProcessor = new Mock <MessageProcessor>(MockBehavior.Strict, messageOptions);
ServiceBusConfiguration config = new ServiceBusConfiguration
{
MessageOptions = messageOptions
};
_mockMessagingProvider = new Mock <MessagingProvider>(MockBehavior.Strict, config);
config.MessagingProvider = _mockMessagingProvider.Object;
_mockMessagingProvider.Setup(p => p.CreateMessageProcessor(_entityPath))
.Returns(_mockMessageProcessor.Object);
ServiceBusTriggerExecutor triggerExecutor = new ServiceBusTriggerExecutor(_mockExecutor.Object);
_listener = new ServiceBusListener(_messagingFactory, _entityPath, triggerExecutor, config);
}
public void Should_abandon_message_if_errors()
{
// Given
var subscriberOne = A.Fake <IDynamicSubscriber>();
string foo = null;
long baz = 0;
A.CallTo(() => subscriberOne.CanProcess(A <IServiceBusMessage> ._))
.Returns(true);
A.CallTo(() => subscriberOne.Process(A <IServiceBusMessage> ._, A <object> ._))
.Invokes(foc =>
{
throw new InvalidOperationException();
});
var listener = new ServiceBusListener(
new[] { subscriberOne },
new SimpleJsonSerialiser(),
this.bus);
var message = this.GetMessage("foo", "{ \"Foo\" : \"Bar\", \"Baz\" : 23 }");
listener.Connect(this.connectionString, this.queueName);
// When
this.bus.CallBack.Invoke(message).Wait();
// Then
message.Completed.ShouldBeFalse();
message.Abandoned.ShouldBeTrue();
}
public void Should_complete_message_if_no_error()
{
// Given
var subscriberOne = A.Fake <IDynamicSubscriber>();
string foo = null;
long baz = 0;
A.CallTo(() => subscriberOne.CanProcess(A <IServiceBusMessage> ._))
.Returns(true);
A.CallTo(() => subscriberOne.Process(A <IServiceBusMessage> ._, A <object> ._))
.Invokes(foc =>
{
dynamic model = foc.Arguments[1];
foo = model.Foo;
baz = model.Baz;
}).Returns(Task.FromResult(0));
var listener = new ServiceBusListener(
new[] { subscriberOne },
new SimpleJsonSerialiser(),
this.bus);
var message = this.GetMessage("foo", "{ \"Foo\" : \"Bar\", \"Baz\" : 23 }");
listener.Connect(this.connectionString, this.queueName);
// When
this.bus.CallBack.Invoke(message).Wait();
// Then
message.Completed.ShouldBeTrue();
message.Abandoned.ShouldBeFalse();
}
public ServiceBusListenerTests()
{
_mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict);
MessageHandlerOptions messageOptions = new MessageHandlerOptions(ExceptionReceivedHandler);
MessageReceiver messageReceiver = new MessageReceiver(_testConnection, _entityPath);
_mockMessageProcessor = new Mock <MessageProcessor>(MockBehavior.Strict, messageReceiver, messageOptions);
ServiceBusOptions config = new ServiceBusOptions
{
MessageHandlerOptions = messageOptions
};
_mockMessagingProvider = new Mock <MessagingProvider>(MockBehavior.Strict, new OptionsWrapper <ServiceBusOptions>(config));
_mockMessagingProvider
.Setup(p => p.CreateMessageProcessor(_entityPath, _testConnection))
.Returns(_mockMessageProcessor.Object);
ServiceBusTriggerExecutor triggerExecutor = new ServiceBusTriggerExecutor(_mockExecutor.Object);
Mock <ServiceBusAccount> mockServiceBusAccount = new Mock <ServiceBusAccount>(MockBehavior.Strict);
mockServiceBusAccount.Setup(a => a.ConnectionString).Returns(_testConnection);
_loggerFactory = new LoggerFactory();
_loggerProvider = new TestLoggerProvider();
_loggerFactory.AddProvider(_loggerProvider);
_listener = new ServiceBusListener(_functionId, EntityType.Queue, _entityPath, false, triggerExecutor, config, mockServiceBusAccount.Object,
_mockMessagingProvider.Object, _loggerFactory);
}
public ServiceBusListenerTests()
{
_mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict);
MessageHandlerOptions messageOptions = new MessageHandlerOptions(ExceptionReceivedHandler);
MessageReceiver messageReceiver = new MessageReceiver(_testConnection, _entityPath);
_mockMessageProcessor = new Mock <MessageProcessor>(MockBehavior.Strict, messageReceiver, messageOptions);
ServiceBusConfiguration config = new ServiceBusConfiguration
{
MessageOptions = messageOptions
};
_mockMessagingProvider = new Mock <MessagingProvider>(MockBehavior.Strict, config);
config.MessagingProvider = _mockMessagingProvider.Object;
_mockMessagingProvider.Setup(p => p.CreateMessageProcessor(_entityPath, _testConnection))
.Returns(_mockMessageProcessor.Object);
ServiceBusTriggerExecutor triggerExecutor = new ServiceBusTriggerExecutor(_mockExecutor.Object);
var mockServiceBusAccount = new Mock <ServiceBusAccount>(MockBehavior.Strict);
mockServiceBusAccount.Setup(a => a.ConnectionString).Returns(_testConnection);
_listener = new ServiceBusListener(_entityPath, triggerExecutor, config, mockServiceBusAccount.Object);
}
public void Should_only_call_subscriber_who_can_process()
{
// Given
var subscriberOne = A.Fake <IDynamicSubscriber>();
A.CallTo(() => subscriberOne.CanProcess(A <IServiceBusMessage> ._)).Returns(true);
var subscriberTwo = A.Fake <IDynamicSubscriber>();
A.CallTo(() => subscriberTwo.CanProcess(A <IServiceBusMessage> ._)).Returns(false);
var listener = new ServiceBusListener(
new[] { subscriberOne, subscriberTwo },
this.serialiser,
this.bus);
var message = this.GetMessage("foo");
listener.Connect(this.connectionString, this.queueName);
// When
this.bus.CallBack.Invoke(message).Wait();
// Then
A.CallTo(() => subscriberOne.Process(A <IServiceBusMessage> ._, A <object> ._))
.MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => subscriberTwo.Process(A <IServiceBusMessage> ._, A <object> ._))
.MustNotHaveHappened();
}
static SitemapEventRegistrator()
{
SitemapGeneratorScheduler = ServiceLocator.GetService <ISitemapGeneratorScheduler>();
var settings = ServiceLocator.GetService <IServiceBusSettings>();
ServiceBusListener = new ServiceBusListener(settings, "Events");
}
public async Task GetMetrics_HandlesExceptions()
{
// MessagingEntityNotFoundException
_mockMessagingProvider
.Setup(p => p.CreateBatchMessageReceiver(_entityPath, _testConnection))
.Throws(new ServiceBusException("", reason: ServiceBusFailureReason.MessagingEntityNotFound));
ServiceBusListener listener = new ServiceBusListener(_functionId, EntityType.Queue, _entityPath, false, _mockExecutor.Object, _serviceBusOptions,
_mockServiceBusAccount.Object, _mockMessagingProvider.Object, _loggerFactory, false);
var metrics = await((ServiceBusScaleMonitor)listener.GetMonitor()).GetMetricsAsync();
Assert.AreEqual(0, metrics.PartitionCount);
Assert.AreEqual(0, metrics.MessageCount);
Assert.AreEqual(TimeSpan.FromSeconds(0), metrics.QueueTime);
Assert.AreNotEqual(default(DateTime), metrics.Timestamp);
var warning = _loggerProvider.GetAllLogMessages().Single(p => p.Level == LogLevel.Warning);
Assert.AreEqual($"ServiceBus queue '{_entityPath}' was not found.", warning.FormattedMessage);
_loggerProvider.ClearAllLogMessages();
// UnauthorizedAccessException
_mockMessagingProvider
.Setup(p => p.CreateBatchMessageReceiver(_entityPath, _testConnection))
.Throws(new UnauthorizedAccessException(""));
listener = new ServiceBusListener(_functionId, EntityType.Queue, _entityPath, false, _mockExecutor.Object, _serviceBusOptions,
_mockServiceBusAccount.Object, _mockMessagingProvider.Object, _loggerFactory, false);
metrics = await((ServiceBusScaleMonitor)listener.GetMonitor()).GetMetricsAsync();
Assert.AreEqual(0, metrics.PartitionCount);
Assert.AreEqual(0, metrics.MessageCount);
Assert.AreEqual(TimeSpan.FromSeconds(0), metrics.QueueTime);
Assert.AreNotEqual(default(DateTime), metrics.Timestamp);
warning = _loggerProvider.GetAllLogMessages().Single(p => p.Level == LogLevel.Warning);
Assert.AreEqual($"Connection string does not have Manage claim for queue '{_entityPath}'. Failed to get queue description to derive queue length metrics. " +
$"Falling back to using first message enqueued time.",
warning.FormattedMessage);
_loggerProvider.ClearAllLogMessages();
// Generic Exception
_mockMessagingProvider
.Setup(p => p.CreateBatchMessageReceiver(_entityPath, _testConnection))
.Throws(new Exception("Uh oh"));
listener = new ServiceBusListener(_functionId, EntityType.Queue, _entityPath, false, _mockExecutor.Object, _serviceBusOptions,
_mockServiceBusAccount.Object, _mockMessagingProvider.Object, _loggerFactory, false);
metrics = await((ServiceBusScaleMonitor)listener.GetMonitor()).GetMetricsAsync();
Assert.AreEqual(0, metrics.PartitionCount);
Assert.AreEqual(0, metrics.MessageCount);
Assert.AreEqual(TimeSpan.FromSeconds(0), metrics.QueueTime);
Assert.AreNotEqual(default(DateTime), metrics.Timestamp);
warning = _loggerProvider.GetAllLogMessages().Single(p => p.Level == LogLevel.Warning);
Assert.AreEqual($"Error querying for Service Bus queue scale status: Uh oh", warning.FormattedMessage);
}
static async Task Main(string[] args)
{
Console.WriteLine("Hello SpeedTestLogger!");
var config = new LoggerConfiguration();
var serviceBusListener = new ServiceBusListener(config);
await serviceBusListener.Listen(async (msg) => await DoWork(config));
}
public static IApplicationBuilder UseServiceBusListener(this IApplicationBuilder app)
{
_listener = (ServiceBusListener)app.ApplicationServices.GetService(typeof(ServiceBusListener));
IApplicationLifetime lifetime = (IApplicationLifetime)app.ApplicationServices.GetService(typeof(IApplicationLifetime));
lifetime.ApplicationStarted.Register(OnStarted);
lifetime.ApplicationStopping.Register(OnStopping);
return(app);
}
public async Task Stop_Will_Return_True()
{
//Arrange
var listener = new ServiceBusListener(_mockSerialiser.Object, _mockHandlerResolver.Object,
_mockHandlerInvoker.Object);
//Act
var result = await listener.Stop();
//Assert
Assert.That(result, Is.True);
}
public void Setup()
{
_mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict);
_client = new ServiceBusClient(_testConnection);
ServiceBusProcessorOptions processorOptions = new ServiceBusProcessorOptions();
ServiceBusProcessor messageProcessor = _client.CreateProcessor(_entityPath);
ServiceBusReceiver receiver = _client.CreateReceiver(_entityPath);
_mockMessageProcessor = new Mock <MessageProcessor>(MockBehavior.Strict, messageProcessor);
var configuration = ConfigurationUtilities.CreateConfiguration(new KeyValuePair <string, string>(_connection, _testConnection));
_serviceBusOptions = new ServiceBusOptions();
_mockProvider = new Mock <MessagingProvider>(new OptionsWrapper <ServiceBusOptions>(_serviceBusOptions));
_mockClientFactory = new Mock <ServiceBusClientFactory>(
configuration,
Mock.Of <AzureComponentFactory>(),
_mockProvider.Object,
new AzureEventSourceLogForwarder(new NullLoggerFactory()),
new OptionsWrapper <ServiceBusOptions>(_serviceBusOptions));
_mockProvider
.Setup(p => p.CreateMessageProcessor(_client, _entityPath, It.IsAny <ServiceBusProcessorOptions>()))
.Returns(_mockMessageProcessor.Object);
_mockProvider
.Setup(p => p.CreateClient(_testConnection, It.IsAny <ServiceBusClientOptions>()))
.Returns(_client);
_loggerFactory = new LoggerFactory();
_loggerProvider = new TestLoggerProvider();
_loggerFactory.AddProvider(_loggerProvider);
var concurrencyOptions = new OptionsWrapper <ConcurrencyOptions>(new ConcurrencyOptions());
var mockConcurrencyThrottleManager = new Mock <IConcurrencyThrottleManager>(MockBehavior.Strict);
var concurrencyManager = new ConcurrencyManager(concurrencyOptions, _loggerFactory, mockConcurrencyThrottleManager.Object);
_listener = new ServiceBusListener(
_functionId,
ServiceBusEntityType.Queue,
_entityPath,
false,
_serviceBusOptions.AutoCompleteMessages,
_mockExecutor.Object,
_serviceBusOptions,
_connection,
_mockProvider.Object,
_loggerFactory,
false,
_mockClientFactory.Object,
concurrencyManager);
_scaleMonitor = (ServiceBusScaleMonitor)_listener.GetMonitor();
}
public async Task <IListener> CreateListenerAsync(ListenerFactoryContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
IListenerFactory factory = new ServiceBusListenerFactory(_account, _entityPath, _isSessionsEnabled, context.Executor, _options, _messagingProvider);
_listener = (ServiceBusListener)await factory.CreateAsync(context.CancellationToken);
return(_listener);
}
public ServiceBusListenerTests()
{
_mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict);
_client = new ServiceBusClient(_testConnection);
ServiceBusProcessor processor = _client.CreateProcessor(_entityPath);
ServiceBusReceiver receiver = _client.CreateReceiver(_entityPath);
var configuration = ConfigurationUtilities.CreateConfiguration(new KeyValuePair <string, string>("connection", _testConnection));
ServiceBusOptions config = new ServiceBusOptions
{
ProcessErrorAsync = ExceptionReceivedHandler
};
_mockMessageProcessor = new Mock <MessageProcessor>(MockBehavior.Strict, processor);
_mockMessagingProvider = new Mock <MessagingProvider>(new OptionsWrapper <ServiceBusOptions>(config));
_mockClientFactory = new Mock <ServiceBusClientFactory>(configuration, Mock.Of <AzureComponentFactory>(), _mockMessagingProvider.Object, new AzureEventSourceLogForwarder(new NullLoggerFactory()), new OptionsWrapper <ServiceBusOptions>(new ServiceBusOptions()));
_mockMessagingProvider
.Setup(p => p.CreateMessageProcessor(It.IsAny <ServiceBusClient>(), _entityPath, It.IsAny <ServiceBusProcessorOptions>()))
.Returns(_mockMessageProcessor.Object);
_mockMessagingProvider
.Setup(p => p.CreateBatchMessageReceiver(It.IsAny <ServiceBusClient>(), _entityPath, default))
.Returns(receiver);
_loggerFactory = new LoggerFactory();
_loggerProvider = new TestLoggerProvider();
_loggerFactory.AddProvider(_loggerProvider);
var concurrencyOptions = new OptionsWrapper <ConcurrencyOptions>(new ConcurrencyOptions());
_mockConcurrencyThrottleManager = new Mock <IConcurrencyThrottleManager>(MockBehavior.Strict);
var concurrencyManager = new ConcurrencyManager(concurrencyOptions, _loggerFactory, _mockConcurrencyThrottleManager.Object);
_listener = new ServiceBusListener(
_functionId,
ServiceBusEntityType.Queue,
_entityPath,
false,
config.AutoCompleteMessages,
_mockExecutor.Object,
config,
"connection",
_mockMessagingProvider.Object,
_loggerFactory,
false,
_mockClientFactory.Object,
concurrencyManager);
_listener.Started = true;
}
public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
ParameterInfo parameter = context.Parameter;
var attribute = TypeUtility.GetResolvedAttribute <ServiceBusTriggerAttribute>(parameter);
if (attribute == null)
{
return(Task.FromResult <ITriggerBinding>(null));
}
string queueName = null;
string topicName = null;
string subscriptionName = null;
string entityPath = null;
EntityType entityType;
if (attribute.QueueName != null)
{
queueName = Resolve(attribute.QueueName);
entityPath = queueName;
entityType = EntityType.Queue;
}
else
{
topicName = Resolve(attribute.TopicName);
subscriptionName = Resolve(attribute.SubscriptionName);
entityPath = EntityNameHelper.FormatSubscriptionPath(topicName, subscriptionName);
entityType = EntityType.Topic;
}
attribute.Connection = Resolve(attribute.Connection);
ServiceBusAccount account = new ServiceBusAccount(_options, _configuration, attribute);
Func <ListenerFactoryContext, bool, Task <IListener> > createListener =
(factoryContext, singleDispatch) =>
{
IListener listener = new ServiceBusListener(factoryContext.Descriptor.Id, entityType, entityPath, attribute.IsSessionsEnabled, factoryContext.Executor, _options, account, _messagingProvider, _loggerFactory, singleDispatch);
return(Task.FromResult(listener));
};
#pragma warning disable 618
ITriggerBinding binding = BindingFactory.GetTriggerBinding(new ServiceBusTriggerBindingStrategy(), parameter, _converterManager, createListener);
#pragma warning restore 618
return(Task.FromResult <ITriggerBinding>(binding));
}
public async Task Failing_To_Attach_To_Transport_Manager_Will_Return_False()
{
//Arrange
var transport = new Mock <ITransport>();
var transportManager = new ServiceBusTransportManager(transport.Object, Mock.Of <ICircuitBreaker>(), Mock.Of <IEventLogger>());
var listener = new ServiceBusListener(_mockSerialiser.Object, _mockHandlerResolver.Object,
_mockHandlerInvoker.Object);
//Act
var result = await listener.AttachTo(transportManager);
//Assert
Assert.That(result, Is.False);
}
public void Should_use_passed_in_queue_parameters_if_specified()
{
// Given
var description = new QueueDescription(this.queueName);
var listener = new ServiceBusListener(
Enumerable.Empty<ISubscriber>(),
this.serialiser,
this.bus);
// When
listener.Connect(this.connectionString, this.queueName, description);
// Then
this.bus.VerifyQueueDescription.ShouldBeSameAs(description);
}
public void Should_connect()
{
// Given
var listener = new ServiceBusListener(
Enumerable.Empty <ISubscriber>(),
this.serialiser,
this.bus);
// When
listener.Connect(this.connectionString, this.queueName);
// Then
this.bus.ConnectionString.ShouldEqual(this.connectionString);
this.bus.QueueName.ShouldEqual(this.queueName);
}
public void Should_use_passed_in_queue_parameters_if_specified()
{
// Given
var description = new QueueDescription(this.queueName);
var listener = new ServiceBusListener(
Enumerable.Empty <ISubscriber>(),
this.serialiser,
this.bus);
// When
listener.Connect(this.connectionString, this.queueName, description);
// Then
this.bus.VerifyQueueDescription.ShouldBeSameAs(description);
}
public void Should_connect()
{
// Given
var listener = new ServiceBusListener(
Enumerable.Empty<ISubscriber>(),
this.serialiser,
this.bus);
// When
listener.Connect(this.connectionString, this.queueName);
// Then
this.bus.ConnectionString.ShouldEqual(this.connectionString);
this.bus.QueueName.ShouldEqual(this.queueName);
}
public Task <ITriggerBinding> TryCreateAsync(TriggerBindingProviderContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
ParameterInfo parameter = context.Parameter;
var attribute = TypeUtility.GetResolvedAttribute <ServiceBusTriggerAttribute>(parameter);
if (attribute == null)
{
return(Task.FromResult <ITriggerBinding>(null));
}
attribute.Connection = _nameResolver.ResolveWholeString(attribute.Connection);
string entityPath;
ServiceBusEntityType serviceBusEntityType;
if (attribute.QueueName != null)
{
var queueName = _nameResolver.ResolveWholeString(attribute.QueueName);
entityPath = queueName;
serviceBusEntityType = ServiceBusEntityType.Queue;
}
else
{
var topicName = _nameResolver.ResolveWholeString(attribute.TopicName);
var subscriptionName = _nameResolver.ResolveWholeString(attribute.SubscriptionName);
entityPath = EntityNameFormatter.FormatSubscriptionPath(topicName, subscriptionName);
serviceBusEntityType = ServiceBusEntityType.Topic;
}
Func <ListenerFactoryContext, bool, Task <IListener> > createListener =
(factoryContext, singleDispatch) =>
{
var autoCompleteMessagesOptionEvaluatedValue = GetAutoCompleteMessagesOptionToUse(attribute, factoryContext.Descriptor.ShortName);
IListener listener = new ServiceBusListener(factoryContext.Descriptor.Id, serviceBusEntityType, entityPath, attribute.IsSessionsEnabled, autoCompleteMessagesOptionEvaluatedValue, factoryContext.Executor, _options, attribute.Connection, _messagingProvider, _loggerFactory, singleDispatch, _clientFactory, _concurrencyManager);
return(Task.FromResult(listener));
};
#pragma warning disable 618
ITriggerBinding binding = BindingFactory.GetTriggerBinding(new ServiceBusTriggerBindingStrategy(), parameter, _converterManager, createListener);
#pragma warning restore 618
return(Task.FromResult <ITriggerBinding>(binding));
}
public void Should_verify_queue_on_connect()
{
// Given
var listener = new ServiceBusListener(
Enumerable.Empty<ISubscriber>(),
this.serialiser,
this.bus);
// When
listener.Connect(this.connectionString, this.queueName);
// Then
this.bus.VerifyQueueConnectionString.ShouldEqual(this.connectionString);
this.bus.VerifyQueueDescription.ShouldNotBeNull();
this.bus.VerifyQueueDescription.Path.ShouldEqual(this.queueName);
}
public async Task GetMetrics_DoesNotPeekBatchesWhenFirstAttemptReturnsNull()
{
_mockMessageReceiver.Setup(x => x.PeekMessageAsync(It.IsAny <long>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(() => null);
_mockMessageReceiver.Verify(x => x.PeekMessagesAsync(It.IsAny <int>(), It.IsAny <long>(), It.IsAny <CancellationToken>()), Times.Never);
ServiceBusListener listener = CreateListener();
var metrics = await((ServiceBusScaleMonitor)listener.GetMonitor()).GetMetricsAsync();
Assert.AreEqual(0, metrics.PartitionCount);
Assert.AreEqual(0, metrics.MessageCount);
Assert.AreEqual(TimeSpan.FromSeconds(0), metrics.QueueTime);
Assert.AreNotEqual(default(DateTime), metrics.Timestamp);
}
public void Should_verify_queue_on_connect()
{
// Given
var listener = new ServiceBusListener(
Enumerable.Empty <ISubscriber>(),
this.serialiser,
this.bus);
// When
listener.Connect(this.connectionString, this.queueName);
// Then
this.bus.VerifyQueueConnectionString.ShouldEqual(this.connectionString);
this.bus.VerifyQueueDescription.ShouldNotBeNull();
this.bus.VerifyQueueDescription.Path.ShouldEqual(this.queueName);
}
public async Task GetMetrics_CalculatesMetrics()
{
var message = ServiceBusModelFactory.ServiceBusReceivedMessage(enqueuedTime: DateTimeOffset.UtcNow.Subtract(TimeSpan.FromSeconds(30)));
_mockMessageReceiver.Setup(x => x.PeekMessageAsync(It.IsAny <long>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(message);
ServiceBusListener listener = CreateListener();
var metrics = await((ServiceBusScaleMonitor)listener.GetMonitor()).GetMetricsAsync();
Assert.AreEqual(0, metrics.PartitionCount);
Assert.AreEqual(1, metrics.MessageCount);
Assert.That(metrics.QueueTime, Is.GreaterThanOrEqualTo(TimeSpan.FromSeconds(30)));
Assert.AreNotEqual(default(DateTime), metrics.Timestamp);
}
public void If_Empty_Byte_Array_Is_Received_Then_A_Null_Reference_Exception_Should_Be_Thrown()
{
//Arrange
var mockBytes = new byte[] { };
var listener = new ServiceBusListener(_mockSerialiser.Object, _mockHandlerResolver.Object,
_mockHandlerInvoker.Object);
//Act
async Task Delegate()
{
await listener.ReceiveMessage(mockBytes, CancellationToken.None);
}
//Assert
Assert.That(Delegate, Throws.TypeOf <NullReferenceException>());
}
public async Task Listener_Can_Be_Attached_To_An_Active_Transport_Manager()
{
//Arrange
var transport = new Mock <ITransport>();
transport.Setup(x => x.Configuration).Returns(new TransportConfiguration());
var transportManager = new ServiceBusTransportManager(transport.Object, Mock.Of <ICircuitBreaker>(), Mock.Of <IEventLogger>());
var listener = new ServiceBusListener(_mockSerialiser.Object, _mockHandlerResolver.Object,
_mockHandlerInvoker.Object);
//Act
var result = await listener.AttachTo(transportManager);
//Assert
Assert.That(result, Is.True);
Assert.That(transport.Object.Configuration.Listeners, Has.Exactly(1).EqualTo(listener));
}
public void Receive_Message_Transactional_Will_Throw_A_Not_Implemented_Exception()
{
//Arrange
var mockBytes = new byte[] { 72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33 };
var mockTransaction = new Mock <ITransaction>();
var listener = new ServiceBusListener(_mockSerialiser.Object, _mockHandlerResolver.Object,
_mockHandlerInvoker.Object);
//Act
async Task Delegate()
{
await listener.ReceiveMessageTransactional(mockBytes, mockTransaction.Object, CancellationToken.None);
}
//Assert
Assert.That(Delegate, Throws.TypeOf <NotImplementedException>());
}
static void Main(string[] args)
{
Console.Write("Enter connectionstring: ");
var connectionString = Console.ReadLine();
Console.Write("Enter queue name: ");
var queueName = Console.ReadLine();
var listener = new ServiceBusListener(new[] { new BusSubscriber() });
listener.Connect(connectionString, queueName);
while (true)
{
Thread.Sleep(1000);
}
}
public async Task GetMetrics_DoesNotPeekBatchesWhenFirstAttemptReturnsActive()
{
var activeMessage = ServiceBusModelFactory.ServiceBusReceivedMessage(enqueuedTime: DateTimeOffset.UtcNow.Subtract(TimeSpan.FromSeconds(30)), sequenceNumber: 2);
_mockMessageReceiver.Setup(x => x.PeekMessageAsync(It.IsAny <long>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(activeMessage);
_mockMessageReceiver.Verify(x => x.PeekMessagesAsync(It.IsAny <int>(), It.IsAny <long>(), It.IsAny <CancellationToken>()), Times.Never);
ServiceBusListener listener = CreateListener();
var metrics = await((ServiceBusScaleMonitor)listener.GetMonitor()).GetMetricsAsync();
Assert.AreEqual(0, metrics.PartitionCount);
Assert.AreEqual(1, metrics.MessageCount);
Assert.That(metrics.QueueTime, Is.GreaterThanOrEqualTo(TimeSpan.FromSeconds(30)));
Assert.AreNotEqual(default(DateTime), metrics.Timestamp);
}
public async Task GetMetrics_IgnoresEmptyBatch()
{
var deferredMessage = ServiceBusModelFactory.ServiceBusReceivedMessage(serviceBusMessageState: ServiceBusMessageState.Deferred);
_mockMessageReceiver.Setup(x => x.PeekMessageAsync(It.IsAny <long>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(deferredMessage);
_mockMessageReceiver.Setup(x => x.PeekMessagesAsync(It.IsAny <int>(), It.IsAny <long>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new List <ServiceBusReceivedMessage>());
ServiceBusListener listener = CreateListener();
var metrics = await((ServiceBusScaleMonitor)listener.GetMonitor()).GetMetricsAsync();
Assert.AreEqual(0, metrics.PartitionCount);
Assert.AreEqual(0, metrics.MessageCount);
Assert.AreEqual(TimeSpan.FromSeconds(0), metrics.QueueTime);
Assert.AreNotEqual(default(DateTime), metrics.Timestamp);
}
public ServiceBusListenerTests()
{
_mockExecutor = new Mock <ITriggeredFunctionExecutor>(MockBehavior.Strict);
var client = new ServiceBusClient(_testConnection);
ServiceBusProcessor processor = client.CreateProcessor(_entityPath);
ServiceBusReceiver receiver = client.CreateReceiver(_entityPath);
var configuration = ConfigurationUtilities.CreateConfiguration(new KeyValuePair <string, string>("connection", _testConnection));
ServiceBusOptions config = new ServiceBusOptions
{
ExceptionHandler = ExceptionReceivedHandler
};
_mockMessageProcessor = new Mock <MessageProcessor>(MockBehavior.Strict, processor, receiver);
_mockMessagingProvider = new Mock <MessagingProvider>(new OptionsWrapper <ServiceBusOptions>(config));
_mockClientFactory = new Mock <ServiceBusClientFactory>(configuration, Mock.Of <AzureComponentFactory>(), _mockMessagingProvider.Object);
_mockMessagingProvider
.Setup(p => p.CreateMessageProcessor(It.IsAny <ServiceBusClient>(), _entityPath))
.Returns(_mockMessageProcessor.Object);
_mockMessagingProvider
.Setup(p => p.CreateBatchMessageReceiver(It.IsAny <ServiceBusClient>(), _entityPath))
.Returns(receiver);
_loggerFactory = new LoggerFactory();
_loggerProvider = new TestLoggerProvider();
_loggerFactory.AddProvider(_loggerProvider);
_listener = new ServiceBusListener(
_functionId,
EntityType.Queue,
_entityPath,
false,
_mockExecutor.Object,
config,
"connection",
_mockMessagingProvider.Object,
_loggerFactory,
false,
_mockClientFactory.Object);
}
public void Should_complete_message_if_no_error()
{
// Given
var subscriberOne = A.Fake<IDynamicSubscriber>();
string foo = null;
long baz = 0;
A.CallTo(() => subscriberOne.CanProcess(A<IServiceBusMessage>._))
.Returns(true);
A.CallTo(() => subscriberOne.Process(A<IServiceBusMessage>._, A<object>._))
.Invokes(foc =>
{
dynamic model = foc.Arguments[1];
foo = model.Foo;
baz = model.Baz;
}).Returns(Task.FromResult(0));
var listener = new ServiceBusListener(
new[] { subscriberOne },
new SimpleJsonSerialiser(),
this.bus);
var message = this.GetMessage("foo", "{ \"Foo\" : \"Bar\", \"Baz\" : 23 }");
listener.Connect(this.connectionString, this.queueName);
// When
this.bus.CallBack.Invoke(message).Wait();
// Then
message.Completed.ShouldBeTrue();
message.Abandoned.ShouldBeFalse();
}
public void Should_abandon_message_if_errors()
{
// Given
var subscriberOne = A.Fake<IDynamicSubscriber>();
string foo = null;
long baz = 0;
A.CallTo(() => subscriberOne.CanProcess(A<IServiceBusMessage>._))
.Returns(true);
A.CallTo(() => subscriberOne.Process(A<IServiceBusMessage>._, A<object>._))
.Invokes(foc =>
{
throw new InvalidOperationException();
});
var listener = new ServiceBusListener(
new[] { subscriberOne },
new SimpleJsonSerialiser(),
this.bus);
var message = this.GetMessage("foo", "{ \"Foo\" : \"Bar\", \"Baz\" : 23 }");
listener.Connect(this.connectionString, this.queueName);
// When
this.bus.CallBack.Invoke(message).Wait();
// Then
message.Completed.ShouldBeFalse();
message.Abandoned.ShouldBeTrue();
}
public void Should_call_can_process_on_each_subscriber()
{
// Given
var subscriberOne = A.Fake<ISubscriber>();
var subscriberTwo = A.Fake<ISubscriber>();
var listener = new ServiceBusListener(
new[] { subscriberOne, subscriberTwo },
this.serialiser,
this.bus);
var message = this.GetMessage("foo");
listener.Connect(this.connectionString, this.queueName);
// When
this.bus.CallBack.Invoke(message).Wait();
// Then
A.CallTo(() => subscriberOne.CanProcess(A<IServiceBusMessage>._))
.MustHaveHappened(Repeated.Exactly.Once);
A.CallTo(() => subscriberTwo.CanProcess(A<IServiceBusMessage>._))
.MustHaveHappened(Repeated.Exactly.Once);
}