public async Task ConnectionTransportCannotRetrieveMetadataWhenCustomValidationRejectsTheCertificate()
{
await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
{
var connectionString = EventHubsTestEnvironment.Instance.BuildConnectionStringForEventHub(scope.EventHubName);
var retryOptions = new EventHubsRetryOptions {
TryTimeout = TimeSpan.FromMinutes(2)
};
var clientOptions = new EventHubConnectionOptions
{
CertificateValidationCallback = (object sender, X509Certificate certificate, X509Chain chain, SslPolicyErrors errors) => false
};
await using (var connection = new TestConnectionWithRetryPolicy(connectionString))
await using (var certificateRejectingConnection = new TestConnectionWithRetryPolicy(connectionString, clientOptions))
{
connection.RetryPolicy = new BasicRetryPolicy(retryOptions);
certificateRejectingConnection.RetryPolicy = new BasicRetryPolicy(retryOptions);
var partition = (await connection.GetPartitionIdsAsync()).First();
Assert.That(async() => await certificateRejectingConnection.GetPartitionIdsAsync(), Throws.InstanceOf <AuthenticationException>());
Assert.That(async() => await certificateRejectingConnection.GetPropertiesAsync(), Throws.InstanceOf <AuthenticationException>());
Assert.That(async() => await certificateRejectingConnection.GetPartitionPropertiesAsync(partition), Throws.InstanceOf <AuthenticationException>());
}
}
}
public void GetPropertiesAsyncConsidersOperationCanceledExceptionAsRetriable(EventHubsRetryOptions retryOptions)
{
var eventHubName = "myName";
var tokenValue = "123ABC";
var retryPolicy = new BasicRetryPolicy(retryOptions);
var retriableException = new OperationCanceledException();
var mockConverter = new Mock <AmqpMessageConverter>();
var mockCredential = new Mock <EventHubTokenCredential>(Mock.Of <TokenCredential>(), "{namespace}.servicebus.windows.net");
var mockScope = new Mock <AmqpConnectionScope>();
using var cancellationSource = new CancellationTokenSource();
mockCredential
.Setup(credential => credential.GetTokenAsync(It.IsAny <TokenRequestContext>(), It.Is <CancellationToken>(value => value == cancellationSource.Token)))
.Returns(new ValueTask <AccessToken>(new AccessToken(tokenValue, DateTimeOffset.MaxValue)));
mockConverter
.Setup(converter => converter.CreateEventHubPropertiesRequest(It.Is <string>(value => value == eventHubName), It.Is <string>(value => value == tokenValue)))
.Returns(default(AmqpMessage));
mockScope
.Setup(scope => scope.OpenManagementLinkAsync(It.IsAny <TimeSpan>(), It.IsAny <CancellationToken>()))
.Throws(retriableException);
var client = new InjectableMockClient("my.eventhub.com", eventHubName, mockCredential.Object, new EventHubConnectionOptions(), mockScope.Object, mockConverter.Object);
Assert.That(async() => await client.GetPropertiesAsync(retryPolicy, cancellationSource.Token), Throws.InstanceOf(retriableException.GetType()));
mockScope.Verify(scope => scope.OpenManagementLinkAsync(It.IsAny <TimeSpan>(), It.IsAny <CancellationToken>()), Times.Exactly(1 + retryOptions.MaximumRetries));
}
/// <summary>
/// Compares retry options between two instances to determine if the
/// instances represent the same set of options.
/// </summary>
///
/// <param name="instance">The instance that this method was invoked on.</param>
/// <param name="other">The other set of retry options to consider.</param>
///
/// <returns><c>true</c>, if the two sets of options are structurally equivalent; otherwise, <c>false</c>.</returns>
///
public static bool IsEquivalentTo(this EventHubsRetryOptions instance,
EventHubsRetryOptions other)
{
// If the events are the same instance, they're equal. This should only happen
// if both are null or they are the exact same instance.
if (Object.ReferenceEquals(instance, other))
{
return(true);
}
// If one or the other is null, then they cannot be equal, since we know that
// they are not both null.
if ((instance == null) || (other == null))
{
return(false);
}
// If the contents of each attribute are equal, the instance are
// equal.
return
(
instance.Mode == other.Mode &&
instance.MaximumRetries == other.MaximumRetries &&
instance.Delay == other.Delay &&
instance.MaximumDelay == other.MaximumDelay &&
instance.TryTimeout == other.TryTimeout &&
instance.CustomRetryPolicy == other.CustomRetryPolicy
);
}
public void CreateConsumerInvokesTheTransportClient()
{
var transportClient = new ObservableTransportClientMock();
var client = new InjectableTransportClientMock(transportClient, "Endpoint=sb://not-real.servicebus.windows.net/;SharedAccessKeyName=DummyKey;SharedAccessKey=[not_real];EntityPath=fake");
var expectedPosition = EventPosition.FromOffset(65);
var expectedPartition = "2123";
var expectedConsumerGroup = EventHubConsumerClient.DefaultConsumerGroupName;
var expectedRetryPolicy = new EventHubsRetryOptions {
MaximumRetries = 67
}.ToRetryPolicy();
var expectedTrackLastEnqueued = false;
var expectedPrefetch = 99U;
var expectedOwnerLevel = 123L;
client.CreateTransportConsumer(expectedConsumerGroup, expectedPartition, expectedPosition, expectedRetryPolicy, expectedTrackLastEnqueued, expectedOwnerLevel, expectedPrefetch);
(var actualConsumerGroup, var actualPartition, EventPosition actualPosition, var actualRetry, var actualTrackLastEnqueued, var actualOwnerLevel, var actualPrefetch) = transportClient.CreateConsumerCalledWith;
Assert.That(actualPartition, Is.EqualTo(expectedPartition), "The partition should have been passed.");
Assert.That(actualConsumerGroup, Is.EqualTo(expectedConsumerGroup), "The consumer groups should match.");
Assert.That(actualPosition.Offset, Is.EqualTo(expectedPosition.Offset), "The event position to receive should match.");
Assert.That(actualRetry, Is.SameAs(expectedRetryPolicy), "The retryPolicy should match.");
Assert.That(actualOwnerLevel, Is.EqualTo(expectedOwnerLevel), "The owner levels should match.");
Assert.That(actualPrefetch, Is.EqualTo(expectedPrefetch), "The prefetch counts should match.");
Assert.That(actualTrackLastEnqueued, Is.EqualTo(expectedTrackLastEnqueued), "The flag for tracking the last enqueued event should match.");
}
public void MaximumDelayIsValidated(int seconds)
{
var options = new EventHubsRetryOptions();
var invalidValue = TimeSpan.FromSeconds(seconds);
Assert.That(() => options.MaximumDelay = invalidValue, Throws.InstanceOf <ArgumentException>());
}
public void SendBatchRespectsTheRetryPolicy(EventHubsRetryOptions retryOptions)
{
var partitionKey = "testMe";
var options = new CreateBatchOptions {
PartitionKey = partitionKey
};
var retriableException = new EventHubsException(true, "Test");
var retryPolicy = new BasicRetryPolicy(retryOptions);
var batch = new EventDataBatch(Mock.Of <TransportEventBatch>(), options.ToSendOptions());
var producer = new Mock <AmqpProducer>("aHub", null, Mock.Of <AmqpConnectionScope>(), new AmqpMessageConverter(), retryPolicy)
{
CallBase = true
};
producer
.Protected()
.Setup <Task <SendingAmqpLink> >("CreateLinkAndEnsureProducerStateAsync",
ItExpr.IsAny <string>(),
ItExpr.IsAny <TimeSpan>(),
ItExpr.IsAny <CancellationToken>())
.Throws(retriableException);
using CancellationTokenSource cancellationSource = new CancellationTokenSource();
Assert.That(async() => await producer.Object.SendAsync(batch, cancellationSource.Token), Throws.InstanceOf(retriableException.GetType()));
producer
.Protected()
.Verify("CreateLinkAndEnsureProducerStateAsync", Times.Exactly(1 + retryOptions.MaximumRetries),
ItExpr.Is <string>(value => value == null),
ItExpr.IsAny <TimeSpan>(),
ItExpr.IsAny <CancellationToken>());
}
public void GetPartitionPropertiesAsyncAppliesTheRetryPolicyForAmqpErrors(EventHubsRetryOptions retryOptions)
{
var eventHubName = "myName";
var partitionId = "Barney";
var tokenValue = "123ABC";
var retryPolicy = new BasicRetryPolicy(retryOptions);
var retriableException = AmqpError.CreateExceptionForError(new Error {
Condition = AmqpError.ServerBusyError
}, "dummy");
var mockConverter = new Mock <AmqpMessageConverter>();
var mockCredential = new Mock <EventHubTokenCredential>(Mock.Of <TokenCredential>());
var mockScope = new Mock <AmqpConnectionScope>();
using var cancellationSource = new CancellationTokenSource();
mockCredential
.Setup(credential => credential.GetTokenAsync(It.IsAny <TokenRequestContext>(), It.Is <CancellationToken>(value => value == cancellationSource.Token)))
.Returns(new ValueTask <AccessToken>(new AccessToken(tokenValue, DateTimeOffset.MaxValue)));
mockConverter
.Setup(converter => converter.CreatePartitionPropertiesRequest(It.Is <string>(value => value == eventHubName), It.Is <string>(value => value == partitionId), It.Is <string>(value => value == tokenValue)))
.Returns(default(AmqpMessage));
mockScope
.Setup(scope => scope.OpenManagementLinkAsync(It.IsAny <TimeSpan>(), It.IsAny <CancellationToken>()))
.Throws(retriableException);
var client = new InjectableMockClient("my.eventhub.com", eventHubName, mockCredential.Object, new EventHubConnectionOptions(), mockScope.Object, mockConverter.Object);
Assert.That(async() => await client.GetPartitionPropertiesAsync(partitionId, retryPolicy, cancellationSource.Token), Throws.InstanceOf(retriableException.GetType()));
mockScope.Verify(scope => scope.OpenManagementLinkAsync(It.IsAny <TimeSpan>(), It.IsAny <CancellationToken>()), Times.Exactly(1 + retryOptions.MaximumRetries));
}
public async Task ConnectionTransportCannotRetrieveMetadataWhenProxyIsInvalid()
{
await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
{
var connectionString = TestEnvironment.BuildConnectionStringForEventHub(scope.EventHubName);
var retryOptions = new EventHubsRetryOptions {
TryTimeout = TimeSpan.FromMinutes(2)
};
var clientOptions = new EventHubConnectionOptions
{
Proxy = new WebProxy("http://1.2.3.4:9999"),
TransportType = EventHubsTransportType.AmqpWebSockets
};
await using (var connection = new TestConnectionWithTransport(connectionString))
await using (var invalidProxyConnection = new TestConnectionWithTransport(connectionString, clientOptions))
{
connection.RetryPolicy = new BasicRetryPolicy(retryOptions);
invalidProxyConnection.RetryPolicy = new BasicRetryPolicy(retryOptions);
var partition = (await connection.GetPartitionIdsAsync()).First();
Assert.That(async() => await invalidProxyConnection.GetPartitionIdsAsync(), Throws.InstanceOf <WebSocketException>().Or.InstanceOf <TimeoutException>());
Assert.That(async() => await invalidProxyConnection.GetPropertiesAsync(), Throws.InstanceOf <WebSocketException>().Or.InstanceOf <TimeoutException>());
Assert.That(async() => await invalidProxyConnection.GetPartitionPropertiesAsync(partition), Throws.InstanceOf <WebSocketException>().Or.InstanceOf <TimeoutException>());
}
}
}
public void SendEnumerableRespectsTheRetryPolicy(EventHubsRetryOptions retryOptions)
{
var partitionId = "testMe";
var retriableException = new EventHubsException(true, "Test");
var retryPolicy = new BasicRetryPolicy(retryOptions);
var producer = new Mock <AmqpProducer>("aHub", partitionId, Mock.Of <AmqpConnectionScope>(), new AmqpMessageConverter(), retryPolicy)
{
CallBase = true
};
producer
.Protected()
.Setup <Task <SendingAmqpLink> >("CreateLinkAndEnsureProducerStateAsync",
ItExpr.IsAny <string>(),
ItExpr.IsAny <TimeSpan>(),
ItExpr.IsAny <CancellationToken>())
.Throws(retriableException);
using CancellationTokenSource cancellationSource = new CancellationTokenSource();
Assert.That(async() => await producer.Object.SendAsync(new[] { new EventData(new byte[] { 0x65 }) }, new SendEventOptions(), cancellationSource.Token), Throws.InstanceOf(retriableException.GetType()));
producer
.Protected()
.Verify("CreateLinkAndEnsureProducerStateAsync", Times.Exactly(1 + retryOptions.MaximumRetries),
ItExpr.Is <string>(value => value == partitionId),
ItExpr.IsAny <TimeSpan>(),
ItExpr.IsAny <CancellationToken>());
}
public void ReceiveAsyncAppliesTheRetryPolicyForAmqpErrors(EventHubsRetryOptions retryOptions)
{
var eventHub = "eventHubName";
var consumerGroup = "$DEFAULT";
var partition = "3";
var identifier = "cusTOM-1D";
var eventPosition = EventPosition.FromOffset(123);
var trackLastEnqueued = false;
var invalidateOnSteal = true;
var ownerLevel = 123L;
var tokenValue = "123ABC";
var retryPolicy = new BasicRetryPolicy(retryOptions);
var retriableException = AmqpError.CreateExceptionForError(new Error {
Condition = AmqpError.ServerBusyError
}, "dummy");
var mockConverter = new Mock <AmqpMessageConverter>();
var mockCredential = new Mock <TokenCredential>();
var mockScope = new Mock <AmqpConnectionScope>();
using var cancellationSource = new CancellationTokenSource();
mockCredential
.Setup(credential => credential.GetTokenAsync(It.IsAny <TokenRequestContext>(), It.Is <CancellationToken>(value => value == cancellationSource.Token)))
.Returns(new ValueTask <AccessToken>(new AccessToken(tokenValue, DateTimeOffset.MaxValue)));
mockScope
.Setup(scope => scope.OpenConsumerLinkAsync(
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <EventPosition>(),
It.IsAny <TimeSpan>(),
It.IsAny <TimeSpan>(),
It.IsAny <uint>(),
It.IsAny <long?>(),
It.IsAny <long?>(),
It.IsAny <bool>(),
It.IsAny <string>(),
It.IsAny <CancellationToken>()))
.Throws(retriableException);
var consumer = new AmqpConsumer(eventHub, consumerGroup, partition, identifier, eventPosition, trackLastEnqueued, invalidateOnSteal, ownerLevel, null, null, mockScope.Object, Mock.Of <AmqpMessageConverter>(), retryPolicy);
Assert.That(async() => await consumer.ReceiveAsync(100, null, cancellationSource.Token), Throws.InstanceOf(retriableException.GetType()));
mockScope
.Verify(scope => scope.OpenConsumerLinkAsync(
It.Is <string>(value => value == consumerGroup),
It.Is <string>(value => value == partition),
It.Is <EventPosition>(value => value == eventPosition),
It.IsAny <TimeSpan>(),
It.IsAny <TimeSpan>(),
It.IsAny <uint>(),
It.IsAny <long?>(),
It.Is <long?>(value => value == ownerLevel),
It.Is <bool>(value => value == trackLastEnqueued),
It.Is <string>(value => value == identifier),
It.IsAny <CancellationToken>()),
Times.Exactly(1 + retryOptions.MaximumRetries));
}
public void RetryOptionsAreOptimizedForBufferedPublishing()
{
var standardRetryOptions = new EventHubsRetryOptions();
var options = new EventHubBufferedProducerClientOptions();
Assert.That(options.RetryOptions, Is.Not.Null, "The retry options should not be null.");
Assert.That(options.RetryOptions.MaximumRetries, Is.GreaterThan(standardRetryOptions.MaximumRetries), "The buffered retry options should allow for more retries than the standard.");
Assert.That(options.RetryOptions.TryTimeout, Is.GreaterThan(standardRetryOptions.TryTimeout), "The buffered retry options should allow for a longer try timeout than the standard.");
}
public void CalulateTryTimeoutRespectsOptions(int attemptCount)
{
var timeout = TimeSpan.FromSeconds(5);
var options = new EventHubsRetryOptions {
TryTimeout = timeout
};
var policy = new BasicRetryPolicy(options);
Assert.That(policy.CalculateTryTimeout(attemptCount), Is.EqualTo(options.TryTimeout));
}
/// <summary>
/// Creates a new copy of the current <see cref="EventHubsRetryOptions" />, cloning its attributes into a new instance.
/// </summary>
///
/// <param name="instance">The instance that this method was invoked on.</param>
///
/// <returns>A new copy of <see cref="EventHubsRetryOptions" />.</returns>
///
public static EventHubsRetryOptions Clone(this EventHubsRetryOptions instance) =>
new EventHubsRetryOptions
{
Mode = instance.Mode,
CustomRetryPolicy = instance.CustomRetryPolicy,
MaximumRetries = instance.MaximumRetries,
Delay = instance.Delay,
MaximumDelay = instance.MaximumDelay,
TryTimeout = instance.TryTimeout
};
public void IsEquivalentToDetectsCustomPolicy()
{
var first = new EventHubsRetryOptions {
CustomRetryPolicy = Mock.Of <EventHubsRetryPolicy>()
};
var second = new EventHubsRetryOptions {
CustomRetryPolicy = new BasicRetryPolicy(new EventHubsRetryOptions())
};
Assert.That(first.IsEquivalentTo(second), Is.False);
}
public void IsEquivalentToDetectsTryTimeout()
{
var first = new EventHubsRetryOptions {
TryTimeout = TimeSpan.FromSeconds(9)
};
var second = new EventHubsRetryOptions {
TryTimeout = TimeSpan.FromSeconds(8)
};
Assert.That(first.IsEquivalentTo(second), Is.False);
}
public void IsEquivalentToDetectsMaximumRetries()
{
var first = new EventHubsRetryOptions {
MaximumRetries = 7
};
var second = new EventHubsRetryOptions {
MaximumRetries = 99
};
Assert.That(first.IsEquivalentTo(second), Is.False);
}
public void IsEquivalentToDetectsDelay()
{
var first = new EventHubsRetryOptions {
Delay = TimeSpan.FromSeconds(7)
};
var second = new EventHubsRetryOptions {
Delay = TimeSpan.FromMinutes(1)
};
Assert.That(first.IsEquivalentTo(second), Is.False);
}
public void IsEquivalentToDetectsModes()
{
var first = new EventHubsRetryOptions {
Mode = EventHubsRetryMode.Exponential
};
var second = new EventHubsRetryOptions {
Mode = EventHubsRetryMode.Fixed
};
Assert.That(first.IsEquivalentTo(second), Is.False);
}
public void IsEquivalentToDetectsEqualOptionSets()
{
var customPolicy = Mock.Of <EventHubsRetryPolicy>();
var first = new EventHubsRetryOptions {
CustomRetryPolicy = customPolicy
};
var second = new EventHubsRetryOptions {
CustomRetryPolicy = customPolicy
};
Assert.That(first.IsEquivalentTo(second), Is.True);
}
/// <summary>
/// Initializes a new instance of the <see cref="EventHubProducerClient" /> class.
/// </summary>
///
/// <param name="connection">The connection to use as the basis for delegation of client-type operations.</param>
/// <param name="transportProducer">The transport producer instance to use as the basis for service communication.</param>
/// <param name="partitionProducerPool">A <see cref="TransportProducerPool" /> used to manage a set of partition specific <see cref="TransportProducer" />.</param>
///
/// <remarks>
/// This constructor is intended to be used internally for functional
/// testing only.
/// </remarks>
///
internal EventHubProducerClient(EventHubConnection connection,
TransportProducer transportProducer,
TransportProducerPool partitionProducerPool = default)
{
Argument.AssertNotNull(connection, nameof(connection));
Argument.AssertNotNull(transportProducer, nameof(transportProducer));
OwnsConnection = false;
Connection = connection;
RetryPolicy = new EventHubsRetryOptions().ToRetryPolicy();
PartitionProducerPool = partitionProducerPool ?? new TransportProducerPool(Connection, RetryPolicy, eventHubProducer: transportProducer);
}
public void TryTimeoutConfiguration()
{
#region Snippet:EventHubs_Sample02_RetryOptionsTryTimeout
var options = new EventHubsRetryOptions
{
TryTimeout = TimeSpan.FromMinutes(1)
};
#endregion
Assert.That(options, Is.Not.Null);
}
public void CustomRetry()
{
#region Snippet:EventHubs_Sample02_CustomRetryUse
var options = new EventHubsRetryOptions
{
CustomRetryPolicy = new ExampleRetryPolicy()
};
#endregion
Assert.That(options, Is.Not.Null);
}
public void IsEquivalentToDetectsNullArgument()
{
var first = new EventHubsRetryOptions
{
Mode = EventHubsRetryMode.Fixed,
MaximumRetries = 99,
MaximumDelay = TimeSpan.FromMinutes(3),
Delay = TimeSpan.FromSeconds(4),
TryTimeout = TimeSpan.Zero
};
Assert.That(first.IsEquivalentTo((EventHubsRetryOptions)null), Is.False);
}
public void IsEquivalentToDetectsSameInstance()
{
var first = new EventHubsRetryOptions
{
Mode = EventHubsRetryMode.Fixed,
MaximumRetries = 99,
MaximumDelay = TimeSpan.FromMinutes(3),
Delay = TimeSpan.FromSeconds(4),
TryTimeout = TimeSpan.Zero
};
Assert.That(first.IsEquivalentTo(first), Is.True);
}
public void RespectsConnectionOptionsForConsumer(string expectedPathName, string connectionString)
{
var testEndpoint = new Uri("http://mycustomendpoint.com");
EventHubOptions options = new EventHubOptions
{
ConnectionOptions = new EventHubConnectionOptions
{
CustomEndpointAddress = testEndpoint
},
RetryOptions = new EventHubsRetryOptions
{
MaximumRetries = 10
}
};
options.AddReceiver(expectedPathName, connectionString);
var configuration = CreateConfiguration();
var factory = new EventHubClientFactory(configuration, Mock.Of <AzureComponentFactory>(), Options.Create(options), new DefaultNameResolver(configuration));
var consumer = factory.GetEventHubConsumerClient(expectedPathName, null, "consumer");
var consumerClient = (EventHubConsumerClient)typeof(EventHubConsumerClientImpl)
.GetField("_client", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(consumer);
EventHubConnection connection = (EventHubConnection)typeof(EventHubConsumerClient)
.GetProperty("Connection", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(consumerClient);
EventHubConnectionOptions connectionOptions = (EventHubConnectionOptions)typeof(EventHubConnection)
.GetProperty("Options", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(connection);
Assert.AreEqual(testEndpoint, connectionOptions.CustomEndpointAddress);
EventHubsRetryPolicy retryPolicy = (EventHubsRetryPolicy)typeof(EventHubConsumerClient)
.GetProperty("RetryPolicy", BindingFlags.NonPublic | BindingFlags.Instance)
.GetValue(consumerClient);
// Reflection was still necessary here because BasicRetryOptions (which is the concrete derived type)
// is internal.
EventHubsRetryOptions retryOptions = (EventHubsRetryOptions)retryPolicy.GetType()
.GetProperty("Options", BindingFlags.Public | BindingFlags.Instance)
.GetValue(retryPolicy);
Assert.AreEqual(10, retryOptions.MaximumRetries);
Assert.AreEqual(expectedPathName, consumer.EventHubName);
}
public void ToRetryPolicyWithCustomPolicyUsesTheCustomPolicy()
{
var options = new EventHubsRetryOptions
{
Mode = EventHubsRetryMode.Fixed,
MaximumRetries = 65,
Delay = TimeSpan.FromSeconds(1),
MaximumDelay = TimeSpan.FromSeconds(2),
TryTimeout = TimeSpan.FromSeconds(3),
CustomRetryPolicy = Mock.Of <EventHubsRetryPolicy>()
};
var policy = options.ToRetryPolicy();
Assert.That(policy, Is.Not.Null, "The policy should not be null.");
Assert.That(policy, Is.SameAs(options.CustomRetryPolicy), "The custom retry policy should have been used.");
Assert.That(policy, Is.Not.InstanceOf <BasicRetryPolicy>(), "The default policy type should not have been generated.");
}
public void ToRetryPolicyWithoutCustomPolicyCreatesThePolicy()
{
var options = new EventHubsRetryOptions
{
Mode = EventHubsRetryMode.Fixed,
MaximumRetries = 65,
Delay = TimeSpan.FromSeconds(1),
MaximumDelay = TimeSpan.FromSeconds(2),
TryTimeout = TimeSpan.FromSeconds(3),
CustomRetryPolicy = null
};
var policy = options.ToRetryPolicy();
Assert.That(policy, Is.Not.Null, "The policy should not be null.");
Assert.That(policy, Is.InstanceOf <BasicRetryPolicy>(), "The options should produce a basic retry policy.");
Assert.That(((BasicRetryPolicy)policy).Options, Is.SameAs(options), "The options should have been used for the retry policy.");
Assert.That(policy, Is.Not.SameAs(options.CustomRetryPolicy), "The custom retry policy should not have been used, since it was not populated.");
}
private void Initialize()
{
EventHubConnectionOptions connectionOptions = new EventHubConnectionOptions()
{
TransportType = EventHubsTransportType.AmqpTcp
};
EventHubsRetryOptions retryOptions = new EventHubsRetryOptions()
{
MaximumRetries = 1,
Mode = EventHubsRetryMode.Exponential
};
EventHubProducerClientOptions clientOptions = new EventHubProducerClientOptions()
{
ConnectionOptions = connectionOptions,
RetryOptions = retryOptions
};
this.EventHubProducerClient = new EventHubProducerClient(this.EventHubConnectionString, this.EventHubName, clientOptions);
this.TelemetryClient?.TrackTrace("EventHubSenderService.Initialize:Complete", SeverityLevel.Information);
}
public void CloneProducesACopy()
{
var options = new EventHubsRetryOptions
{
Mode = EventHubsRetryMode.Fixed,
MaximumRetries = 65,
Delay = TimeSpan.FromSeconds(1),
MaximumDelay = TimeSpan.FromSeconds(2),
TryTimeout = TimeSpan.FromSeconds(3),
CustomRetryPolicy = Mock.Of <EventHubsRetryPolicy>()
};
EventHubsRetryOptions clone = options.Clone();
Assert.That(clone, Is.Not.Null, "The clone should not be null.");
Assert.That(clone.Mode, Is.EqualTo(options.Mode), "The mode of the clone should match.");
Assert.That(clone.MaximumRetries, Is.EqualTo(options.MaximumRetries), "The maximum retry limit of the clone should match.");
Assert.That(clone.Delay, Is.EqualTo(options.Delay), "The delay of the clone should match.");
Assert.That(clone.MaximumDelay, Is.EqualTo(options.MaximumDelay), "The maximum delay of the clone should match.");
Assert.That(clone.TryTimeout, Is.EqualTo(options.TryTimeout), "The per-try of the clone should match.");
Assert.That(clone.CustomRetryPolicy, Is.SameAs(options.CustomRetryPolicy), "The custom retry policy should match.");
}
/// <summary>
/// Initializes a new instance of the <see cref="BasicRetryPolicy" /> class.
/// </summary>
///
/// <param name="retryOptions">The options which control the retry approach.</param>
///
public BasicRetryPolicy(EventHubsRetryOptions retryOptions)
{
Argument.AssertNotNull(retryOptions, nameof(retryOptions));
Options = retryOptions;
}
