public void UpdateSharedAccessSignatureShouldUpdateTheSharedAccessSignature() { var resource = "amqps://before/path"; var beforeKeyName = "beforeKeyName"; var afterKeyName = "afterKeyName"; var beforeKeyValue = "beforeKeyValue"; var afterKeyValue = "afterKeyValue"; var validSpan = TimeSpan.FromHours(4); var signature = new SharedAccessSignature(resource, beforeKeyName, beforeKeyValue, validSpan.Add(TimeSpan.FromHours(2))); var keyCredential = new ServiceBusSharedAccessKeyCredential(signature.Value); var sasCredential = keyCredential.AsSharedAccessSignatureCredential(resource, validSpan); // Updates var newSignature = new SharedAccessSignature(resource, afterKeyName, afterKeyValue, validSpan); keyCredential.UpdateSharedAccessSignature(newSignature.Value); Assert.That(sasCredential, Is.Not.Null, "A shared access signature credential should have been created."); var credentialSignature = GetSharedAccessSignature(sasCredential); Assert.That(credentialSignature, Is.Not.Null, "The SAS credential should contain a shared access signature."); Assert.That(credentialSignature.Resource, Is.EqualTo(signature.Resource), "The resource should match."); Assert.That(credentialSignature.SharedAccessKeyName, Is.EqualTo(afterKeyName), "The shared access key name should match."); Assert.That(credentialSignature.SharedAccessKey, Is.Null, "The shared access key should not have been set."); Assert.That(credentialSignature.SignatureExpiration, Is.EqualTo(newSignature.SignatureExpiration).Within(TimeSpan.FromSeconds(5)), "The expiration should match."); }
public async Task ClientCanConnectUsingSharedKeyCredentialWithSharedKey() { await using (var scope = await ServiceBusScope.CreateWithQueue(enablePartitioning: true, enableSession: false)) { var options = new ServiceBusClientOptions(); var audience = ServiceBusConnection.BuildConnectionResource(options.TransportType, TestEnvironment.FullyQualifiedNamespace, scope.QueueName); var credential = new ServiceBusSharedAccessKeyCredential(TestEnvironment.SharedAccessKeyName, TestEnvironment.SharedAccessKey); await using (var client = new ServiceBusClient(TestEnvironment.FullyQualifiedNamespace, credential, options)) { Assert.That(async() => { ServiceBusReceiver receiver = null; try { receiver = client.CreateReceiver(scope.QueueName); } finally { await(receiver?.DisposeAsync() ?? new ValueTask()); } }, Throws.Nothing); } } }
public void ConstructorInitializesSharedSignatureProperties() { var signature = new SharedAccessSignature("RESOURCE", "keyname", "keyvalue").Value; var credential = new ServiceBusSharedAccessKeyCredential(signature); Assert.That(credential.SharedAccessSignature, Is.EqualTo(signature), "The shared access signature name should have been set."); Assert.That(credential.SharedAccessKeyName, Is.Null, "The shared key name should have been set."); Assert.That(credential.SharedAccessKey, Is.Null, "The shared access key should not have been set."); }
public void ConstructorWithSharedKeyCredentialArgumentsValidatesOptions() { var token = new ServiceBusSharedAccessKeyCredential("key", "value"); var invalidOptions = new ServiceBusClientOptions { TransportType = ServiceBusTransportType.AmqpTcp, WebProxy = Mock.Of <IWebProxy>() }; Assert.That(() => new ServiceBusClient("fullyQualifiedNamespace", Mock.Of <TokenCredential>(), invalidOptions), Throws.InstanceOf <ArgumentException>(), "The expanded argument constructor should validate client options"); }
public void ConstructorInitializesSharedKeyProperties() { var name = "KeyName"; var value = "KeyValue"; var credential = new ServiceBusSharedAccessKeyCredential(name, value); Assert.That(credential.SharedAccessKeyName, Is.EqualTo(name), "The shared key name should have been set."); Assert.That(credential.SharedAccessKey, Is.EqualTo(value), "The shared key should have been set."); Assert.That(credential.SharedAccessSignature, Is.Null, "The shared access signature should not have been set."); }
private ServiceBusAdministrationClient GetSharedKeyTokenClient() { var properties = ServiceBusConnectionStringProperties.Parse(GetConnectionString()); var credential = new ServiceBusSharedAccessKeyCredential(properties.SharedAccessKeyName, properties.SharedAccessKey); return(InstrumentClient( new ServiceBusAdministrationClient( TestEnvironment.FullyQualifiedNamespace, credential, InstrumentClientOptions(new ServiceBusAdministrationClientOptions())))); }
/// <summary> /// Provides the invalid test cases for the constructor tests. /// </summary> /// public static IEnumerable <object[]> ConstructorSharedKeyCredentialArgumentInvalidCases() { var credential = new ServiceBusSharedAccessKeyCredential("name", "value"); yield return(new object[] { null, credential }); yield return(new object[] { "", credential }); yield return(new object[] { "FakeNamespace", null }); yield return(new object[] { "sb://fakenamspace.com", credential }); }
public void ServiceBusSharedAccessKeyCredentialShouldHoldAReferenceToASharedAccessKey() { var resource = "amqps://some.hub.com/path"; var span = TimeSpan.FromHours(4); var keyName = "keyName"; var keyValue = "keyValue"; var keyCredential = new ServiceBusSharedAccessKeyCredential(keyName, keyValue); SharedAccessSignatureCredential sasCredential = keyCredential.AsSharedAccessSignatureCredential(resource, span); SharedAccessSignatureCredential wrappedCredential = GetSharedAccessSignatureCredential(keyCredential); Assert.That(wrappedCredential, Is.EqualTo(sasCredential), "The credentials should be wrapped."); }
public void AsSharedAccessSignatureCredentialProducesTheExpectedCredentialForSharedKeys() { var resource = "amqps://some.hub.com/path"; var keyName = "sharedKey"; var keyValue = "keyValue"; var validSpan = TimeSpan.FromHours(4); var signature = new SharedAccessSignature(resource, keyName, keyValue, validSpan); var keyCredential = new ServiceBusSharedAccessKeyCredential(keyName, keyValue); var sasCredential = keyCredential.AsSharedAccessSignatureCredential(resource, validSpan); Assert.That(sasCredential, Is.Not.Null, "A shared access signature credential should have been created."); var credentialSignature = GetSharedAccessSignature(sasCredential); Assert.That(credentialSignature, Is.Not.Null, "The SAS credential should contain a shared access signature."); Assert.That(credentialSignature.Resource, Is.EqualTo(signature.Resource), "The resource should match."); Assert.That(credentialSignature.SharedAccessKeyName, Is.EqualTo(signature.SharedAccessKeyName), "The shared access key name should match."); Assert.That(credentialSignature.SharedAccessKey, Is.EqualTo(signature.SharedAccessKey), "The shared access key should match."); Assert.That(credentialSignature.SignatureExpiration, Is.EqualTo(signature.SignatureExpiration).Within(TimeSpan.FromSeconds(5)), "The expiration should match."); }
public void UpdateSharedAccessKeyShouldNotChangeOtherPropertiesForTheSharedAccessSignature() { var resource = "amqps://before/path"; var validSpan = TimeSpan.FromHours(4); var beforeKeyName = "beforeKeyName"; var afterKeyName = "afterKeyName"; var beforeKeyValue = "beforeKeyValue"; var afterKeyValue = "afterKeyValue"; var keyCredential = new ServiceBusSharedAccessKeyCredential(beforeKeyName, beforeKeyValue); // Needed to instantiate a SharedAccessTokenCredential var sasCredential = keyCredential.AsSharedAccessSignatureCredential(resource, validSpan); var credentialSignature = GetSharedAccessSignature(sasCredential); var signatureExpiration = credentialSignature.SignatureExpiration; keyCredential.UpdateSharedAccessKey(afterKeyName, afterKeyValue); Assert.That(credentialSignature.SignatureExpiration, Is.EqualTo(signatureExpiration), "The expiration of a signature should not change when the credentials are rolled."); Assert.That(credentialSignature.Resource, Is.EqualTo(resource), "The resource of a signature should not change when the credentials are rolled."); }
public void AsSharedAccessSignatureCredentialShouldNotRefreshTokenValidityForSharedAccessSignatures() { var beforeResource = "amqps://before/path"; var afterResource = "amqps://after/path"; var beforeSpan = TimeSpan.FromHours(4); var afterSpan = TimeSpan.FromHours(8); var keyName = "keyName"; var keyValue = "keyValue"; var expectedSignature = new SharedAccessSignature(beforeResource, keyName, keyValue, beforeSpan); var keyCredential = new ServiceBusSharedAccessKeyCredential(expectedSignature.Value); SharedAccessSignatureCredential sasCredential = keyCredential.AsSharedAccessSignatureCredential(beforeResource, beforeSpan); SharedAccessSignature beforeSignature = GetSharedAccessSignature(sasCredential); Assert.That(beforeSignature.SignatureExpiration, Is.EqualTo(expectedSignature.SignatureExpiration).Within(TimeSpan.FromSeconds(5)), "The expiration should match."); sasCredential = keyCredential.AsSharedAccessSignatureCredential(afterResource, afterSpan); SharedAccessSignature afterSignature = GetSharedAccessSignature(sasCredential); Assert.That(afterSignature.SignatureExpiration, Is.EqualTo(expectedSignature.SignatureExpiration).Within(TimeSpan.FromSeconds(5)), "The expiration should match."); }
public void UpdateSharedAccessKeyShoulRefreshServiceBusSharedAccessKeyCredentialNameAndKey() { var resource = "amqps://before/path"; var validSpan = TimeSpan.FromHours(4); var beforeKeyName = "beforeKeyName"; var afterKeyName = "afterKeyName"; var beforeKeyValue = "beforeKeyValue"; var afterKeyValue = "afterKeyValue"; var keyCredential = new ServiceBusSharedAccessKeyCredential(beforeKeyName, beforeKeyValue); keyCredential.UpdateSharedAccessKey(afterKeyName, afterKeyValue); var keyName = keyCredential.SharedAccessKeyName; var key = keyCredential.SharedAccessKey; var sasCredential = keyCredential.AsSharedAccessSignatureCredential(resource, validSpan); var credentialSignature = GetSharedAccessSignature(sasCredential); Assert.That(credentialSignature.SharedAccessKeyName, Is.EqualTo(afterKeyName), "The shared access key name should change after being updated."); Assert.That(credentialSignature.SharedAccessKey, Is.EqualTo(afterKeyValue), "The shared access key value should change after being updated."); Assert.That(keyName, Is.EqualTo(afterKeyName), "The shared access key name should change after being updated."); Assert.That(key, Is.EqualTo(afterKeyValue), "The shared access key value should change after being updated."); }
/// <summary> /// Retrieves the ServiceBusSharedAccessKeyCredential from the credential using its private accessor. /// </summary> /// /// <param name="instance">The instance to retrieve the key from.</param> /// /// <returns>The shared access key.</returns> /// private static SharedAccessSignatureCredential GetSharedAccessSignatureCredential(ServiceBusSharedAccessKeyCredential instance) => (SharedAccessSignatureCredential) typeof(ServiceBusSharedAccessKeyCredential) .GetProperty("SharedAccessSignatureCredential", BindingFlags.Instance | BindingFlags.NonPublic) .GetValue(instance, null);
public ReadableOptionsMock(string fullyQualifiedNamespace, ServiceBusSharedAccessKeyCredential credential, ServiceBusClientOptions clientOptions = default) : base(fullyQualifiedNamespace, credential, clientOptions) { }
public void ConstructorValidatesSharedKeyArguments(string fullyQualifiedNamespace, ServiceBusSharedAccessKeyCredential credential) { Assert.That(() => new ServiceBusClient(fullyQualifiedNamespace, credential), Throws.InstanceOf <ArgumentException>()); }