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 EventHubsSharedAccessKeyCredential(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.");
        }
示例#2
0
 public MinimalProcessorMock(int eventBatchMaximumCount,
                             string consumerGroup,
                             string fullyQualifiedNamespace,
                             string eventHubName,
                             EventHubsSharedAccessKeyCredential credential,
                             EventProcessorOptions options = default) : base(eventBatchMaximumCount, consumerGroup, fullyQualifiedNamespace, eventHubName, credential, options)
 {
 }
        public void ConstructorInitializesSharedSignatureProperties()
        {
            var signature  = new SharedAccessSignature("RESOURCE", "keyname", "keyvalue").Value;
            var credential = new EventHubsSharedAccessKeyCredential(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 ConstructorInitializesSharedKeyProperties()
        {
            var name       = "KeyName";
            var value      = "KeyValue";
            var credential = new EventHubsSharedAccessKeyCredential(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.");
        }
        public async Task ConnectionCanConnectToEventHubsUsingSharedKeyCredential()
        {
            await using (EventHubScope scope = await EventHubScope.CreateAsync(1))
            {
                var credential = new EventHubsSharedAccessKeyCredential(EventHubsTestEnvironment.Instance.SharedAccessKeyName, EventHubsTestEnvironment.Instance.SharedAccessKey);

                await using (var connection = new TestConnectionWithTransport(EventHubsTestEnvironment.Instance.FullyQualifiedNamespace, scope.EventHubName, credential))
                {
                    Assert.That(() => connection.GetPropertiesAsync(), Throws.Nothing);
                }
            }
        }
        /// <summary>
        ///   Creates an <see cref="EventProcessorClient" /> that uses mock storage and
        ///   a connection based on an identity credential.
        /// </summary>
        ///
        /// <param name="consumerGroup">The consumer group for the processor.</param>
        /// <param name="eventHubName">The name of the Event Hub for the processor.</param>
        /// <param name="options">The set of client options to pass.</param>
        ///
        /// <returns>The processor instance.</returns>
        ///
        private EventProcessorClient CreateProcessorWithSharedAccessKey(string consumerGroup,
                                                                        string eventHubName,
                                                                        StorageManager storageManager = default,
                                                                        EventProcessorOptions options = default)
        {
            var credential = new EventHubsSharedAccessKeyCredential(EventHubsTestEnvironment.Instance.SharedAccessKeyName, EventHubsTestEnvironment.Instance.SharedAccessKey);

            EventHubConnection createConnection() => new EventHubConnection(EventHubsTestEnvironment.Instance.FullyQualifiedNamespace, eventHubName, credential);

            storageManager ??= new InMemoryStorageManager(_ => {});
            return(new TestEventProcessorClient(storageManager, consumerGroup, EventHubsTestEnvironment.Instance.FullyQualifiedNamespace, eventHubName, credential, createConnection, options));
        }
        public void EventHubSharedKeyCredentialShouldHoldAReferenceToASharedAccessKey()
        {
            var resource      = "amqps://some.hub.com/path";
            var span          = TimeSpan.FromHours(4);
            var keyName       = "keyName";
            var keyValue      = "keyValue";
            var keyCredential = new EventHubsSharedAccessKeyCredential(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 EventHubsSharedAccessKeyCredential(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 EventHubsSharedAccessKeyCredential(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 EventHubsSharedAccessKeyCredential(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 UpdateSharedAccessKeyShoulRefreshEventHubSharedKeyCredentialNameAndKey()
        {
            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 EventHubsSharedAccessKeyCredential(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.");
        }
 public TestConnectionWithTransport(string fullyQualifiedNamespace,
                                    string eventHubName,
                                    EventHubsSharedAccessKeyCredential credential,
                                    EventHubConnectionOptions connectionOptions = default) : base(fullyQualifiedNamespace, eventHubName, credential, connectionOptions)
 {
 }
 /// <summary>
 ///   Retrieves the EventHubSharedKeyCredential 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(EventHubsSharedAccessKeyCredential instance) =>
 (SharedAccessSignatureCredential)
 typeof(EventHubsSharedAccessKeyCredential)
 .GetProperty("SharedAccessSignatureCredential", BindingFlags.Instance | BindingFlags.NonPublic)
 .GetValue(instance, null);