public async Task ConnectionTransportCannotRetrieveMetadataWhenProxyIsInvalid()
{
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
{
Proxy = new WebProxy("http://1.2.3.4:9999"),
TransportType = EventHubsTransportType.AmqpWebSockets
};
await using (var connection = new TestConnectionWithRetryPolicy(connectionString))
await using (var invalidProxyConnection = new TestConnectionWithRetryPolicy(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 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 async Task ConnectionCanConnectToEventHubsUsingSharedKeyCredential()
{
await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
{
var credential = new AzureNamedKeyCredential(EventHubsTestEnvironment.Instance.SharedAccessKeyName, EventHubsTestEnvironment.Instance.SharedAccessKey);
await using (var connection = new TestConnectionWithRetryPolicy(EventHubsTestEnvironment.Instance.FullyQualifiedNamespace, scope.EventHubName, credential))
{
Assert.That(() => connection.GetPropertiesAsync(), Throws.Nothing);
}
}
}
public async Task ConnectionCanConnectToEventHubsUsingConnectionStringAndEventHub()
{
await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
{
var connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
await using (var connection = new TestConnectionWithRetryPolicy(connectionString, scope.EventHubName))
{
Assert.That(() => connection.GetPropertiesAsync(), Throws.Nothing);
}
}
}
public async Task ConnectionTransportCannotRetrievePartitionPropertiesWhenPartitionIdIsInvalid(string invalidPartition)
{
await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
{
var connectionString = EventHubsTestEnvironment.Instance.BuildConnectionStringForEventHub(scope.EventHubName);
await using (var connection = new TestConnectionWithRetryPolicy(connectionString))
{
Assert.That(async() => await connection.GetPartitionPropertiesAsync(invalidPartition), Throws.TypeOf <ArgumentOutOfRangeException>());
}
}
}
public async Task ConnectionCanConnectToEventHubsUsingAnIdentityCredential()
{
await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
{
var options = new EventHubConnectionOptions();
var credential = EventHubsTestEnvironment.Instance.Credential;
await using (var connection = new TestConnectionWithRetryPolicy(EventHubsTestEnvironment.Instance.FullyQualifiedNamespace, scope.EventHubName, credential))
{
Assert.That(() => connection.GetPropertiesAsync(), Throws.Nothing);
}
}
}
public async Task ConnectionCanConnectToEventHubsUsingSasCredential()
{
await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
{
var resource = EventHubConnection.BuildConnectionSignatureAuthorizationResource(EventHubsTransportType.AmqpTcp, EventHubsTestEnvironment.Instance.FullyQualifiedNamespace, scope.EventHubName);
var signature = new SharedAccessSignature(resource, EventHubsTestEnvironment.Instance.SharedAccessKeyName, EventHubsTestEnvironment.Instance.SharedAccessKey);
var credential = new AzureSasCredential(signature.Value);
await using (var connection = new TestConnectionWithRetryPolicy(EventHubsTestEnvironment.Instance.FullyQualifiedNamespace, scope.EventHubName, credential))
{
Assert.That(() => connection.GetPropertiesAsync(), Throws.Nothing);
}
}
}
public async Task ConnectionCanConnectToEventHubsUsingSharedAccessSignatureConnectionString()
{
await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
{
var options = new EventHubConnectionOptions();
var audience = EventHubConnection.BuildConnectionSignatureAuthorizationResource(options.TransportType, EventHubsTestEnvironment.Instance.FullyQualifiedNamespace, scope.EventHubName);
EventHubsTestEnvironment tempQualifier = EventHubsTestEnvironment.Instance;
var signature = new SharedAccessSignature(audience, tempQualifier.SharedAccessKeyName, tempQualifier.SharedAccessKey, TimeSpan.FromMinutes(30));
var connectionString = $"Endpoint=sb://{tempQualifier.FullyQualifiedNamespace };EntityPath={ scope.EventHubName };SharedAccessSignature={ signature.Value }";
await using (var connection = new TestConnectionWithRetryPolicy(connectionString, options))
{
Assert.That(() => connection.GetPropertiesAsync(), Throws.Nothing);
}
}
}
public async Task ConnectionTransportPartitionIdsMatchPartitionProperties()
{
await using (EventHubScope scope = await EventHubScope.CreateAsync(4))
{
var connectionString = EventHubsTestEnvironment.Instance.BuildConnectionStringForEventHub(scope.EventHubName);
await using (var connection = new TestConnectionWithRetryPolicy(connectionString))
{
EventHubProperties properties = await connection.GetPropertiesAsync();
var partitions = await connection.GetPartitionIdsAsync();
Assert.That(properties, Is.Not.Null, "A set of properties should have been returned.");
Assert.That(properties.PartitionIds, Is.Not.Null, "A set of partition identifiers for the properties should have been returned.");
Assert.That(partitions, Is.Not.Null, "A set of partition identifiers should have been returned.");
Assert.That(partitions, Is.EquivalentTo(properties.PartitionIds), "The partition identifiers returned directly should match those returned with properties.");
}
}
}
public async Task ConnectionTransportCanRetrieveProperties(EventHubsTransportType transportType)
{
var partitionCount = 4;
await using (EventHubScope scope = await EventHubScope.CreateAsync(partitionCount))
{
var connectionString = EventHubsTestEnvironment.Instance.EventHubsConnectionString;
await using (var connection = new TestConnectionWithRetryPolicy(connectionString, scope.EventHubName, new EventHubConnectionOptions {
TransportType = transportType
}))
{
EventHubProperties properties = await connection.GetPropertiesAsync();
Assert.That(properties, Is.Not.Null, "A set of properties should have been returned.");
Assert.That(properties.Name, Is.EqualTo(scope.EventHubName), "The property Event Hub name should match the scope.");
Assert.That(properties.PartitionIds.Length, Is.EqualTo(partitionCount), "The properties should have the requested number of partitions.");
Assert.That(properties.CreatedOn, Is.EqualTo(DateTimeOffset.UtcNow).Within(TimeSpan.FromSeconds(60)), "The Event Hub should have been created just about now.");
}
}
}
public async Task ConnectionTransportCanRetrievePartitionProperties(EventHubsTransportType transportType)
{
var partitionCount = 4;
await using (EventHubScope scope = await EventHubScope.CreateAsync(partitionCount))
{
var options = new EventHubConnectionOptions();
var credential = new SharedAccessCredential
(
new SharedAccessSignature
(
$"{ options.TransportType.GetUriScheme() }://{ EventHubsTestEnvironment.Instance.FullyQualifiedNamespace }/{ scope.EventHubName }".ToLowerInvariant(),
EventHubsTestEnvironment.Instance.SharedAccessKeyName,
EventHubsTestEnvironment.Instance.SharedAccessKey,
TimeSpan.FromHours(4)
)
);
await using (var connection = new TestConnectionWithRetryPolicy(EventHubsTestEnvironment.Instance.FullyQualifiedNamespace, scope.EventHubName, credential, new EventHubConnectionOptions {
TransportType = transportType
}))
{
var cancellation = new CancellationTokenSource(TimeSpan.FromSeconds(20));
var properties = await connection.GetPropertiesAsync();
var partition = properties.PartitionIds.First();
var partitionProperties = await connection.GetPartitionPropertiesAsync(partition, cancellation.Token);
Assert.That(partitionProperties, Is.Not.Null, "A set of partition properties should have been returned.");
Assert.That(partitionProperties.Id, Is.EqualTo(partition), "The partition identifier should match.");
Assert.That(partitionProperties.EventHubName, Is.EqualTo(scope.EventHubName).Using((IEqualityComparer <string>)StringComparer.InvariantCultureIgnoreCase), "The Event Hub path should match.");
Assert.That(partitionProperties.BeginningSequenceNumber, Is.Not.EqualTo(default(long)), "The beginning sequence number should have been populated.");
Assert.That(partitionProperties.LastEnqueuedSequenceNumber, Is.Not.EqualTo(default(long)), "The last sequence number should have been populated.");
Assert.That(partitionProperties.LastEnqueuedOffset, Is.Not.EqualTo(default(long)), "The last offset should have been populated.");
}
}
}
public async Task ConnectionTransportCannotRetrieveMetadataWhenClosed()
{
await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
{
var connectionString = EventHubsTestEnvironment.Instance.BuildConnectionStringForEventHub(scope.EventHubName);
await using (var connection = new TestConnectionWithRetryPolicy(connectionString))
{
var partition = (await connection.GetPartitionIdsAsync()).First();
Assert.That(async() => await connection.GetPropertiesAsync(), Throws.Nothing);
Assert.That(async() => await connection.GetPartitionPropertiesAsync(partition), Throws.Nothing);
await connection.CloseAsync();
await Task.Delay(TimeSpan.FromSeconds(5));
Assert.That(async() => await connection.GetPartitionIdsAsync(), Throws.InstanceOf <EventHubsException>().And.Property(nameof(EventHubsException.Reason)).EqualTo(EventHubsException.FailureReason.ClientClosed));
Assert.That(async() => await connection.GetPropertiesAsync(), Throws.InstanceOf <EventHubsException>().And.Property(nameof(EventHubsException.Reason)).EqualTo(EventHubsException.FailureReason.ClientClosed));
Assert.That(async() => await connection.GetPartitionPropertiesAsync(partition), Throws.InstanceOf <EventHubsException>().And.Property(nameof(EventHubsException.Reason)).EqualTo(EventHubsException.FailureReason.ClientClosed));
}
}
}
public async Task ConnectionCanConnectToEventHubsUsingArguments()
{
await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
{
var options = new EventHubConnectionOptions();
var credential = new SharedAccessCredential
(
new SharedAccessSignature
(
$"{ options.TransportType.GetUriScheme() }://{ EventHubsTestEnvironment.Instance.FullyQualifiedNamespace }/{ scope.EventHubName }".ToLowerInvariant(),
EventHubsTestEnvironment.Instance.SharedAccessKeyName,
EventHubsTestEnvironment.Instance.SharedAccessKey,
TimeSpan.FromHours(4)
)
);
await using (var connection = new TestConnectionWithRetryPolicy(EventHubsTestEnvironment.Instance.FullyQualifiedNamespace, scope.EventHubName, credential))
{
Assert.That(() => connection.GetPropertiesAsync(), Throws.Nothing);
}
}
}