/// <summary> /// Initializes client properties. /// </summary> private void Initialize() { Clusters = new ClustersOperations(this); Namespaces = new NamespacesOperations(this); PrivateEndpointConnections = new PrivateEndpointConnectionsOperations(this); PrivateLinkResources = new PrivateLinkResourcesOperations(this); NetworkSecurityPerimeterConfiguration = new NetworkSecurityPerimeterConfigurationOperations(this); NetworkSecurityPerimeterConfigurations = new NetworkSecurityPerimeterConfigurationsOperations(this); Configuration = new ConfigurationOperations(this); DisasterRecoveryConfigs = new DisasterRecoveryConfigsOperations(this); EventHubs = new EventHubsOperations(this); ConsumerGroups = new ConsumerGroupsOperations(this); Operations = new Operations(this); SchemaRegistry = new SchemaRegistryOperations(this); ApplicationGroup = new ApplicationGroupOperations(this); BaseUri = new System.Uri("https://management.azure.com"); ApiVersion = "2022-01-01-preview"; AcceptLanguage = "en-US"; LongRunningOperationRetryTimeout = 30; GenerateClientRequestId = true; SerializationSettings = new JsonSerializerSettings { Formatting = Newtonsoft.Json.Formatting.Indented, DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat, DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore, ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize, ContractResolver = new ReadOnlyJsonContractResolver(), Converters = new List <JsonConverter> { new Iso8601TimeSpanConverter() } }; SerializationSettings.Converters.Add(new TransformationJsonConverter()); DeserializationSettings = new JsonSerializerSettings { DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat, DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore, ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize, ContractResolver = new ReadOnlyJsonContractResolver(), Converters = new List <JsonConverter> { new Iso8601TimeSpanConverter() } }; SerializationSettings.Converters.Add(new PolymorphicSerializeJsonConverter <ApplicationGroupPolicy>("type")); DeserializationSettings.Converters.Add(new PolymorphicDeserializeJsonConverter <ApplicationGroupPolicy>("type")); CustomInitialize(); DeserializationSettings.Converters.Add(new TransformationJsonConverter()); DeserializationSettings.Converters.Add(new CloudErrorJsonConverter()); }
/// <summary> /// Initializes client properties. /// </summary> private void Initialize() { Operations = new Operations(this); Namespaces = new NamespacesOperations(this); DisasterRecoveryConfigs = new DisasterRecoveryConfigsOperations(this); MigrationConfigs = new MigrationConfigsOperations(this); Queues = new QueuesOperations(this); Topics = new TopicsOperations(this); Subscriptions = new SubscriptionsOperations(this); Rules = new RulesOperations(this); Regions = new RegionsOperations(this); PremiumMessagingRegions = new PremiumMessagingRegionsOperations(this); EventHubs = new EventHubsOperations(this); BaseUri = new System.Uri("https://management.azure.com"); ApiVersion = "2017-04-01"; AcceptLanguage = "en-US"; LongRunningOperationRetryTimeout = 30; GenerateClientRequestId = true; SerializationSettings = new JsonSerializerSettings { Formatting = Newtonsoft.Json.Formatting.Indented, DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat, DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore, ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize, ContractResolver = new ReadOnlyJsonContractResolver(), Converters = new List <JsonConverter> { new Iso8601TimeSpanConverter() } }; SerializationSettings.Converters.Add(new TransformationJsonConverter()); DeserializationSettings = new JsonSerializerSettings { DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat, DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore, ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize, ContractResolver = new ReadOnlyJsonContractResolver(), Converters = new List <JsonConverter> { new Iso8601TimeSpanConverter() } }; CustomInitialize(); DeserializationSettings.Converters.Add(new TransformationJsonConverter()); DeserializationSettings.Converters.Add(new CloudErrorJsonConverter()); }
/// <summary> /// Initializes client properties. /// </summary> private void Initialize() { Operations = new Operations(this); Namespaces = new NamespacesOperations(this); HybridConnections = new HybridConnectionsOperations(this); WCFRelays = new WCFRelaysOperations(this); BaseUri = new System.Uri("https://management.azure.com"); ApiVersion = "2017-04-01"; AcceptLanguage = "en-US"; LongRunningOperationRetryTimeout = 30; GenerateClientRequestId = true; SerializationSettings = new JsonSerializerSettings { Formatting = Newtonsoft.Json.Formatting.Indented, DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat, DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore, ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize, ContractResolver = new ReadOnlyJsonContractResolver(), Converters = new List <JsonConverter> { new Iso8601TimeSpanConverter() } }; SerializationSettings.Converters.Add(new TransformationJsonConverter()); DeserializationSettings = new JsonSerializerSettings { DateFormatHandling = Newtonsoft.Json.DateFormatHandling.IsoDateFormat, DateTimeZoneHandling = Newtonsoft.Json.DateTimeZoneHandling.Utc, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore, ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Serialize, ContractResolver = new ReadOnlyJsonContractResolver(), Converters = new List <JsonConverter> { new Iso8601TimeSpanConverter() } }; CustomInitialize(); DeserializationSettings.Converters.Add(new TransformationJsonConverter()); DeserializationSettings.Converters.Add(new CloudErrorJsonConverter()); }
public async Task EventhubCreateGetUpdateDeleteAuthorizationRules_Length() { var location = await GetLocation(); var resourceGroupName = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); Subscription sub = await ArmClient.GetDefaultSubscriptionAsync(); await sub.GetResourceGroups().CreateOrUpdateAsync(resourceGroupName, new ResourceGroupData(location));; var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroupName, namespaceName, new EHNamespace() { Location = location, //Sku = new Sku("as") Tags = { { "tag1", "value1" }, { "tag2", "value2" } } } ); var np = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np.Name, namespaceName); DelayInTest(5); //get the created namespace var getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroupName, namespaceName); if (string.Compare(getNamespaceResponse.Value.ProvisioningState, "Succeeded", true) != 0) { DelayInTest(5); } getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroupName, namespaceName); Assert.NotNull(getNamespaceResponse); Assert.AreEqual("Succeeded", getNamespaceResponse.Value.ProvisioningState, StringComparer.CurrentCultureIgnoreCase.ToString()); Assert.AreEqual(location, getNamespaceResponse.Value.Location); // Create Eventhub var eventHubName = Helper.EventHubPrefix + "thisisthenamewithmorethan53charschecktoverifytheremovlaof50charsnamelengthlimit"; var createEventHubResponse = await EventHubsOperations.CreateOrUpdateAsync(resourceGroupName, namespaceName, eventHubName, new Eventhub() { MessageRetentionInDays = 5 }); Assert.NotNull(createEventHubResponse); Assert.AreEqual(createEventHubResponse.Value.Name, eventHubName); //Get the created EventHub var getEventHubResponse = await EventHubsOperations.GetAsync(resourceGroupName, namespaceName, eventHubName); Assert.NotNull(getEventHubResponse.Value); Assert.AreEqual(EntityStatus.Active, getEventHubResponse.Value.Status); Assert.AreEqual(getEventHubResponse.Value.Name, eventHubName); // Create a EventHub AuthorizationRule var authorizationRuleName = Helper.AuthorizationRulesPrefix + "thisisthenamewithmorethan53charschecktoverifytheremovlaof50charsnamelengthlimit"; string createPrimaryKey = Recording.GetVariable("CreatePrimaryKey", Helper.GenerateRandomKey()); var createAutorizationRuleParameter = new AuthorizationRule() { Rights = { AccessRights.Listen, AccessRights.Send } }; var createEventhubAuthorizationRuleResponse = await EventHubsOperations.CreateOrUpdateAuthorizationRuleAsync(resourceGroupName, namespaceName, eventHubName, authorizationRuleName, createAutorizationRuleParameter); Assert.NotNull(createEventhubAuthorizationRuleResponse); Assert.True(createEventhubAuthorizationRuleResponse.Value.Rights.Count == createAutorizationRuleParameter.Rights.Count); Assert.True(isContains(createAutorizationRuleParameter.Rights, createEventhubAuthorizationRuleResponse.Value.Rights)); // Get created Eventhub AuthorizationRules var getEventhubAuthorizationRulesResponse = await EventHubsOperations.GetAuthorizationRuleAsync(resourceGroupName, namespaceName, eventHubName, authorizationRuleName); Assert.NotNull(getEventhubAuthorizationRulesResponse); Assert.True(getEventhubAuthorizationRulesResponse.Value.Rights.Count == createAutorizationRuleParameter.Rights.Count); Assert.True(isContains(createAutorizationRuleParameter.Rights, getEventhubAuthorizationRulesResponse.Value.Rights)); // Get all Eventhub AuthorizationRules var getAllNamespaceAuthorizationRulesResponse = EventHubsOperations.ListAuthorizationRulesAsync(resourceGroupName, namespaceName, eventHubName); Assert.NotNull(getAllNamespaceAuthorizationRulesResponse); var getAllNSPAuthRulesRespList = await getAllNamespaceAuthorizationRulesResponse.ToEnumerableAsync(); Assert.True(getAllNSPAuthRulesRespList.Count() == 1); bool isContainauthorizationRuleName = false; foreach (var detail in getAllNSPAuthRulesRespList) { if (detail.Name == authorizationRuleName) { isContainauthorizationRuleName = true; break; } } Assert.True(isContainauthorizationRuleName); // Update Eventhub authorizationRule string updatePrimaryKey = Recording.GetVariable("UpdatePrimaryKey", Helper.GenerateRandomKey()); AuthorizationRule updateEventhubAuthorizationRuleParameter = new AuthorizationRule(); updateEventhubAuthorizationRuleParameter.Rights.Add(AccessRights.Listen); var updateEventhubAuthorizationRuleResponse = await EventHubsOperations.CreateOrUpdateAuthorizationRuleAsync(resourceGroupName, namespaceName, eventHubName, authorizationRuleName, updateEventhubAuthorizationRuleParameter); Assert.NotNull(updateEventhubAuthorizationRuleResponse); Assert.AreEqual(authorizationRuleName, updateEventhubAuthorizationRuleResponse.Value.Name); Assert.True(updateEventhubAuthorizationRuleResponse.Value.Rights.Count == updateEventhubAuthorizationRuleParameter.Rights.Count); Assert.True(isContains(updateEventhubAuthorizationRuleParameter.Rights, updateEventhubAuthorizationRuleResponse.Value.Rights)); // Get the updated Eventhub AuthorizationRule var getEventhubAuthorizationRuleResponse = await EventHubsOperations.GetAuthorizationRuleAsync(resourceGroupName, namespaceName, eventHubName, authorizationRuleName); Assert.NotNull(getEventhubAuthorizationRuleResponse); Assert.AreEqual(authorizationRuleName, getEventhubAuthorizationRuleResponse.Value.Name); Assert.True(getEventhubAuthorizationRuleResponse.Value.Rights.Count == updateEventhubAuthorizationRuleParameter.Rights.Count); Assert.True(isContains(updateEventhubAuthorizationRuleParameter.Rights, getEventhubAuthorizationRuleResponse.Value.Rights)); // Get the connectionString to the Eventhub for a Authorization rule created var listKeysResponse = await EventHubsOperations.ListKeysAsync(resourceGroupName, namespaceName, eventHubName, authorizationRuleName); Assert.NotNull(listKeysResponse); Assert.NotNull(listKeysResponse.Value.PrimaryConnectionString); Assert.NotNull(listKeysResponse.Value.SecondaryConnectionString); //New connection string var regenerateConnection_primary = await EventHubsOperations.RegenerateKeysAsync(resourceGroupName, namespaceName, eventHubName, authorizationRuleName, new RegenerateAccessKeyParameters(KeyType.PrimaryKey)); Assert.NotNull(regenerateConnection_primary); // Assert.AreNotEqual(listKeysResponse.Value.PrimaryConnectionString, regenerateConnection_primary.Value.PrimaryConnectionString); Assert.AreEqual(listKeysResponse.Value.SecondaryConnectionString, regenerateConnection_primary.Value.SecondaryConnectionString); var regenerateConnection_Secondary = await EventHubsOperations.RegenerateKeysAsync(resourceGroupName, namespaceName, eventHubName, authorizationRuleName, new RegenerateAccessKeyParameters(KeyType.SecondaryKey)); Assert.NotNull(regenerateConnection_Secondary); // Assert.AreNotEqual(listKeysResponse.Value.SecondaryConnectionString, regenerateConnection_Secondary.Value.SecondaryConnectionString); Assert.AreEqual(regenerateConnection_primary.Value.PrimaryConnectionString, regenerateConnection_Secondary.Value.PrimaryConnectionString); // Delete Eventhub authorizationRule await EventHubsOperations.DeleteAuthorizationRuleAsync(resourceGroupName, namespaceName, eventHubName, authorizationRuleName); DelayInTest(5); // Delete Eventhub and check for the NotFound exception await EventHubsOperations.DeleteAsync(resourceGroupName, namespaceName, eventHubName); // Delete namespace and check for the NotFound exception await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroupName, namespaceName)); }
public async Task EventHubskiptop() { var location = GetLocation(); var resourceGroup = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); await Helper.TryRegisterResourceGroupAsync(ResourceGroupsOperations, location.Result, resourceGroup); var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroup, namespaceName, new EHNamespace() { Location = location.Result, Sku = new Sku(SkuName.Standard) { Tier = SkuTier.Standard }, Tags = new Dictionary <string, string>() { { "tag1", "value1" }, { "tag2", "value2" } } } ); var np = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np.Name, namespaceName); DelayInTest(5); // Create Eventhub var eventHubName = Recording.GenerateAssetName(Helper.EventHubPrefix); for (int ehCount = 0; ehCount < 10; ehCount++) { var eventhubNameLoop = eventHubName + "_" + ehCount.ToString(); var createEventHubResponseForLoop = await EventHubsOperations.CreateOrUpdateAsync(resourceGroup, namespaceName, eventhubNameLoop, new Eventhub()); Assert.NotNull(createEventHubResponseForLoop); Assert.AreEqual(createEventHubResponseForLoop.Value.Name, eventhubNameLoop); } //get EventHubs in the same namespace var createEventHubResponseList = EventHubsOperations.ListByNamespaceAsync(resourceGroup, namespaceName); var createEHResplist = await createEventHubResponseList.ToEnumerableAsync(); //may cause a misktake Assert.AreEqual(10, createEHResplist.Count()); var gettop10EventHub = EventHubsOperations.ListByNamespaceAsync(resourceGroup, namespaceName, skip: 5, top: 5); var ListByNamespAsync = await gettop10EventHub.ToEnumerableAsync(); Assert.AreEqual(5, ListByNamespAsync.Count()); // Create a ConsumerGroup var consumergroupName = Recording.GenerateAssetName(Helper.ConsumerGroupPrefix); for (int consumergroupCount = 0; consumergroupCount < 10; consumergroupCount++) { var consumergroupNameLoop = consumergroupName + "_" + consumergroupCount.ToString(); var createConsumerGroupResponseForLoop = await ConsumerGroupsOperations.CreateOrUpdateAsync(resourceGroup, namespaceName, createEHResplist.ElementAt <Eventhub>(0).Name, consumergroupNameLoop, new ConsumerGroup()); Assert.NotNull(createConsumerGroupResponseForLoop); Assert.AreEqual(createConsumerGroupResponseForLoop.Value.Name, consumergroupNameLoop); } var createConsumerGroupResponseList = ConsumerGroupsOperations.ListByEventHubAsync(resourceGroup, namespaceName, createEHResplist.ElementAt <Eventhub>(0).Name); var createConResList = await createConsumerGroupResponseList.ToEnumerableAsync(); Assert.AreEqual(11, createConResList.Count <ConsumerGroup>()); var gettop10ConsumerGroup = ConsumerGroupsOperations.ListByEventHubAsync(resourceGroup, namespaceName, createEHResplist.ElementAt <Eventhub>(0).Name, skip: 5, top: 4); var ConsGrClientList = await gettop10ConsumerGroup.ToEnumerableAsync(); Assert.AreEqual(6, ConsGrClientList.Count <ConsumerGroup>()); // Delete namespace and check for the NotFound exception await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroup, namespaceName)); }
public async Task DisasterRecoveryCreateGetUpdateDelete() { var location = "South Central US"; var location2 = "North Central US"; var resourceGroup = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); await Helper.TryRegisterResourceGroupAsync(ResourceGroupsOperations, location, resourceGroup); var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); // Create namespace 1 var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroup, namespaceName, new EHNamespace() { Location = location, Sku = new Sku(SkuName.Standard) { Tier = SkuTier.Standard, Capacity = 1 }, Tags = new Dictionary <string, string>() { { "tag1", "value1" }, { "tag2", "value2" } } } ); var np1 = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np1.Name, namespaceName); DelayInTest(5); // Create namespace 2 var namespaceName2 = Recording.GenerateAssetName(Helper.NamespacePrefix); var createNamespaceResponse2 = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroup, namespaceName2, new EHNamespace() { Location = location2, //Sku = new Sku //{ // Name = SkuName.Standard, // Tier = SkuTier.Standard, // Capacity = 1 //}, Tags = new Dictionary <string, string>() { { "tag1", "value1" }, { "tag2", "value2" } } } ); var np2 = (await WaitForCompletionAsync(createNamespaceResponse2)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np2.Name, namespaceName2); DelayInTest(5); // Create a namespace AuthorizationRule var authorizationRuleName = Recording.GenerateAssetName(Helper.AuthorizationRulesPrefix); var createAutorizationRuleParameter = new AuthorizationRule() { Rights = new List <AccessRights>() { AccessRights.Listen, AccessRights.Send } }; var createNamespaceAuthorizationRuleResponse = await NamespacesOperations.CreateOrUpdateAuthorizationRuleAsync(resourceGroup, namespaceName, authorizationRuleName, createAutorizationRuleParameter); Assert.NotNull(createNamespaceAuthorizationRuleResponse); Assert.True(createNamespaceAuthorizationRuleResponse.Value.Rights.Count == createAutorizationRuleParameter.Rights.Count); Assert.True(isContains(createAutorizationRuleParameter.Rights, createNamespaceAuthorizationRuleResponse.Value.Rights)); // Get created namespace AuthorizationRules var getNamespaceAuthorizationRulesResponse = await NamespacesOperations.GetAuthorizationRuleAsync(resourceGroup, namespaceName, authorizationRuleName); Assert.NotNull(getNamespaceAuthorizationRulesResponse); Assert.True(getNamespaceAuthorizationRulesResponse.Value.Rights.Count == createAutorizationRuleParameter.Rights.Count); Assert.True(isContains(createAutorizationRuleParameter.Rights, getNamespaceAuthorizationRulesResponse.Value.Rights)); var getNamespaceAuthorizationRulesListKeysResponse = NamespacesOperations.ListKeysAsync(resourceGroup, namespaceName, authorizationRuleName); // Create a Disaster Recovery - var disasterRecoveryName = Recording.GenerateAssetName(Helper.DisasterRecoveryPrefix); //CheckNameavaliability for Alias var checknameAlias = await DisasterRecoveryConfigsOperations.CheckNameAvailabilityAsync(resourceGroup, namespaceName, new CheckNameAvailabilityParameter(disasterRecoveryName)); Assert.True(checknameAlias.Value.NameAvailable, "The Alias Name: '" + disasterRecoveryName + "' is not avilable"); //CheckNameAvaliability for Alias with same as namespace name (alternateName will be used in this case) var checknameAliasSame = await DisasterRecoveryConfigsOperations.CheckNameAvailabilityAsync(resourceGroup, namespaceName, new CheckNameAvailabilityParameter(namespaceName)); // Assert.True(checknameAliasSame.NameAvailable, "The Alias Name: '" + namespaceName + "' is not avilable"); var DisasterRecoveryResponse = await DisasterRecoveryConfigsOperations.CreateOrUpdateAsync(resourceGroup, namespaceName, disasterRecoveryName, new ArmDisasterRecovery() { PartnerNamespace = np2.Id }); Assert.NotNull(DisasterRecoveryResponse); DelayInTest(30); //// Get the created DisasterRecovery config - Primary var disasterRecoveryGetResponse = await DisasterRecoveryConfigsOperations.GetAsync(resourceGroup, namespaceName, disasterRecoveryName); Assert.NotNull(disasterRecoveryGetResponse); if (disasterRecoveryGetResponse.Value.PendingReplicationOperationsCount.HasValue) { Assert.True(disasterRecoveryGetResponse.Value.PendingReplicationOperationsCount >= 0); } else { Assert.False(disasterRecoveryGetResponse.Value.PendingReplicationOperationsCount.HasValue); } Assert.AreEqual(RoleDisasterRecovery.Primary, disasterRecoveryGetResponse.Value.Role); //// Get the created DisasterRecovery config - Secondary var disasterRecoveryGetResponse_Sec = await DisasterRecoveryConfigsOperations.GetAsync(resourceGroup, namespaceName2, disasterRecoveryName); Assert.AreEqual(RoleDisasterRecovery.Secondary, disasterRecoveryGetResponse_Sec.Value.Role); //Get authorization rule thorugh Alias var getAuthoRuleAliasResponse = await DisasterRecoveryConfigsOperations.GetAuthorizationRuleAsync(resourceGroup, namespaceName, disasterRecoveryName, authorizationRuleName); Assert.AreEqual(getAuthoRuleAliasResponse.Value.Name, getNamespaceAuthorizationRulesResponse.Value.Name); var getAuthoruleListKeysResponse = await DisasterRecoveryConfigsOperations.ListKeysAsync(resourceGroup, namespaceName, disasterRecoveryName, authorizationRuleName); Assert.True(string.IsNullOrEmpty(getAuthoruleListKeysResponse.Value.PrimaryConnectionString)); Assert.True(string.IsNullOrEmpty(getAuthoruleListKeysResponse.Value.SecondaryConnectionString)); while (DisasterRecoveryConfigsOperations.GetAsync(resourceGroup, namespaceName, disasterRecoveryName).Result.Value.ProvisioningState != ProvisioningStateDR.Succeeded) { DelayInTest(10); } disasterRecoveryGetResponse = await DisasterRecoveryConfigsOperations.GetAsync(resourceGroup, namespaceName, disasterRecoveryName); if (disasterRecoveryGetResponse.Value.PendingReplicationOperationsCount.HasValue) { Assert.True(disasterRecoveryGetResponse.Value.PendingReplicationOperationsCount >= 0); } else { Assert.False(disasterRecoveryGetResponse.Value.PendingReplicationOperationsCount.HasValue); } //// Break Pairing await DisasterRecoveryConfigsOperations.BreakPairingAsync(resourceGroup, namespaceName, disasterRecoveryName); DelayInTest(10); while (DisasterRecoveryConfigsOperations.GetAsync(resourceGroup, namespaceName, disasterRecoveryName).Result.Value.ProvisioningState != ProvisioningStateDR.Succeeded) { DelayInTest(10); } var DisasterRecoveryResponse_update = await DisasterRecoveryConfigsOperations.CreateOrUpdateAsync(resourceGroup, namespaceName, disasterRecoveryName, new ArmDisasterRecovery() { PartnerNamespace = np2.Id }); Assert.NotNull(DisasterRecoveryResponse_update); DelayInTest(10); var getGeoDRResponse = await DisasterRecoveryConfigsOperations.GetAsync(resourceGroup, namespaceName, disasterRecoveryName); while (getGeoDRResponse.Value.ProvisioningState != ProvisioningStateDR.Succeeded) { getGeoDRResponse = await DisasterRecoveryConfigsOperations.GetAsync(resourceGroup, namespaceName, disasterRecoveryName); DelayInTest(10); } getGeoDRResponse = await DisasterRecoveryConfigsOperations.GetAsync(resourceGroup, namespaceName, disasterRecoveryName); if (getGeoDRResponse.Value.PendingReplicationOperationsCount.HasValue) { Assert.True(getGeoDRResponse.Value.PendingReplicationOperationsCount >= 0); } else { Assert.False(getGeoDRResponse.Value.PendingReplicationOperationsCount.HasValue); } // Fail over await DisasterRecoveryConfigsOperations.FailOverAsync(resourceGroup, namespaceName2, disasterRecoveryName); DelayInTest(10); while (DisasterRecoveryConfigsOperations.GetAsync(resourceGroup, namespaceName2, disasterRecoveryName).Result.Value.ProvisioningState != ProvisioningStateDR.Succeeded) { DelayInTest(10); } // Get all Disaster Recovery for a given NameSpace var getListisasterRecoveryResponse = DisasterRecoveryConfigsOperations.ListAsync(resourceGroup, namespaceName2); Assert.NotNull(getListisasterRecoveryResponse); //Assert.True(getListisasterRecoveryResponse.AsPages.Count<ArmDisasterRecovery>() >= 1); // Delete the DisasterRecovery await DisasterRecoveryConfigsOperations.DeleteAsync(resourceGroup, namespaceName2, disasterRecoveryName); // Delete Namespace using Async await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroup, namespaceName)); await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroup, namespaceName2)); }
public async Task NamespaceCreateGetUpdateDelete() { var location = GetLocation(); var resourceGroup = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); await Helper.TryRegisterResourceGroupAsync(ResourceGroupsOperations, location.Result, resourceGroup); var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); var operationsResponse = Operations.ListAsync(); var checkNameAvailable = NamespacesOperations.CheckNameAvailabilityAsync(new CheckNameAvailabilityParameter(namespaceName)); var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroup, namespaceName, new EHNamespace() { Location = location.Result } ); var np = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np.Name, namespaceName); DelayInTest(60); //get the created namespace var getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroup, namespaceName); if (string.Compare(getNamespaceResponse.Value.ProvisioningState, "Succeeded", true) != 0) { DelayInTest(10); } getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroup, namespaceName); Assert.NotNull(getNamespaceResponse); Assert.AreEqual("Succeeded", getNamespaceResponse.Value.ProvisioningState, StringComparer.CurrentCultureIgnoreCase.ToString()); Assert.AreEqual(location.Result, getNamespaceResponse.Value.Location); // Get all namespaces created within a resourceGroup var getAllNamespacesResponse = NamespacesOperations.ListByResourceGroupAsync(resourceGroup); Assert.NotNull(getAllNamespacesResponse); //Assert.True(getAllNamespacesResponse.AsPages.c >= 1); bool isContainnamespaceName = false; bool isContainresourceGroup = false; var list = await getAllNamespacesResponse.ToEnumerableAsync(); foreach (var name in list) { if (name.Name == namespaceName) { isContainnamespaceName = true; } } foreach (var name in list) { if (name.Id.Contains(resourceGroup)) { isContainresourceGroup = true; break; } } Assert.True(isContainnamespaceName); Assert.True(isContainresourceGroup); // Get all namespaces created within the subscription irrespective of the resourceGroup var getAllNpResponse = NamespacesOperations.ListAsync(); Assert.NotNull(getAllNamespacesResponse); // Update namespace tags and make the namespace critical var updateNamespaceParameter = new EHNamespace() { Tags = new Dictionary <string, string>() { { "tag3", "value3" }, { "tag4", "value4" } } }; // Will uncomment the assertions once the service is deployed var updateNamespaceResponse = NamespacesOperations.UpdateAsync(resourceGroup, namespaceName, updateNamespaceParameter); Assert.NotNull(updateNamespaceResponse); // Get the updated namespace and also verify the Tags. getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroup, namespaceName); DelayInTest(15); Assert.NotNull(getNamespaceResponse); Assert.AreEqual(location.Result, getNamespaceResponse.Value.Location); Assert.AreEqual(namespaceName, getNamespaceResponse.Value.Name); Assert.AreEqual(2, getNamespaceResponse.Value.Tags.Count); bool IsContainKey = false; bool IsContainValue = false; foreach (var tag in updateNamespaceParameter.Tags) { foreach (var t in getNamespaceResponse.Value.Tags) { if (t.Key == tag.Key) { IsContainKey = true; break; } } foreach (var t in getNamespaceResponse.Value.Tags) { if (t.Value == tag.Value) { IsContainValue = true; break; } } } Assert.True(IsContainKey); Assert.True(IsContainValue); //delete namespace await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroup, namespaceName)); }
public async Task NetworkRuleSetCreateGetUpdateDelete() { var location = await GetLocation(); var resourceGroupName = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); Subscription sub = await ArmClient.GetDefaultSubscriptionAsync(); ResourceGroup resourceGroup = await sub.GetResourceGroups().CreateOrUpdate(resourceGroupName, new ResourceGroupData(location)).WaitForCompletionAsync(); // Prepare VNet var vnetName = Recording.GenerateAssetName("sdktestvnet"); var parameters = new VirtualNetworkData { AddressSpace = new AddressSpace { AddressPrefixes = { "10.0.0.0/16" } }, Subnets = { new SubnetData { Name = "default1", AddressPrefix = "10.0.0.0/24", ServiceEndpoints ={ new ServiceEndpointPropertiesFormat { Service = "Microsoft.EventHub" } } }, new SubnetData { Name = "default2", AddressPrefix = "10.0.1.0/24", ServiceEndpoints ={ new ServiceEndpointPropertiesFormat { Service = "Microsoft.EventHub" } } }, new SubnetData { Name = "default3", AddressPrefix = "10.0.2.0/24", ServiceEndpoints ={ new ServiceEndpointPropertiesFormat { Service = "Microsoft.EventHub" } } } }, Location = "eastus2" }; await WaitForCompletionAsync(await resourceGroup.GetVirtualNetworks().CreateOrUpdateAsync(vnetName, parameters)); // Create a namespace var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroupName, namespaceName, new EHNamespace() { Location = location, Tags = { { "tag1", "value1" }, { "tag2", "value2" } } } ); var np = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np.Name, namespaceName); DelayInTest(5); //get the created namespace var getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroupName, namespaceName); if (string.Compare(getNamespaceResponse.Value.ProvisioningState, "Succeeded", true) != 0) { DelayInTest(5); } getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroupName, namespaceName); Assert.NotNull(getNamespaceResponse); Assert.AreEqual("Succeeded", getNamespaceResponse.Value.ProvisioningState, StringComparer.CurrentCultureIgnoreCase.ToString()); Assert.AreEqual(location, getNamespaceResponse.Value.Location, StringComparer.CurrentCultureIgnoreCase.ToString()); var netWorkRuleSet = await NamespacesOperations.CreateOrUpdateNetworkRuleSetAsync(resourceGroupName, namespaceName, new NetworkRuleSet() { DefaultAction = DefaultAction.Deny, VirtualNetworkRules = { new NWRuleSetVirtualNetworkRules() { Subnet = new ResourceManager.EventHubs.Models.Subnet("/subscriptions/" + SubscriptionId + "/resourcegroups/" + resourceGroupName + "/providers/Microsoft.Network/virtualNetworks/" + vnetName + "/subnets/default1") }, new NWRuleSetVirtualNetworkRules() { Subnet = new ResourceManager.EventHubs.Models.Subnet("/subscriptions/" + SubscriptionId + "/resourcegroups/" + resourceGroupName + "/providers/Microsoft.Network/virtualNetworks/" + vnetName + "/subnets/default2") }, new NWRuleSetVirtualNetworkRules() { Subnet = new ResourceManager.EventHubs.Models.Subnet("/subscriptions/" + SubscriptionId + "/resourcegroups/" + resourceGroupName + "/providers/Microsoft.Network/virtualNetworks/" + vnetName + "/subnets/default3") } }, IpRules = { new NWRuleSetIpRules() { IpMask = "1.1.1.1", Action = "Allow" }, new NWRuleSetIpRules() { IpMask = "1.1.1.2", Action = "Allow" }, new NWRuleSetIpRules() { IpMask = "1.1.1.3", Action = "Allow" }, new NWRuleSetIpRules() { IpMask = "1.1.1.4", Action = "Allow" }, new NWRuleSetIpRules() { IpMask = "1.1.1.5", Action = "Allow" } } }); var getNetworkRuleSet = await NamespacesOperations.GetNetworkRuleSetAsync(resourceGroupName, namespaceName); var netWorkRuleSet1 = await NamespacesOperations.CreateOrUpdateNetworkRuleSetAsync(resourceGroupName, namespaceName, new NetworkRuleSet() { DefaultAction = "Allow" }); var getNetworkRuleSet1 = await NamespacesOperations.GetNetworkRuleSetAsync(resourceGroupName, namespaceName); DelayInTest(60); //Delete namespace await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroupName, namespaceName)); }
public async Task NetworkRuleSetCreateGetUpdateDelete() { var location = GetLocation(); var resourceGroup = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); await Helper.TryRegisterResourceGroupAsync(ResourceGroupsOperations, location.Result, resourceGroup); //Create a namespace var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroup, namespaceName, new EHNamespace() { Location = location.Result, Tags = { { "tag1", "value1" }, { "tag2", "value2" } } } ); var np = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np.Name, namespaceName); DelayInTest(5); //get the created namespace var getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroup, namespaceName); if (string.Compare(getNamespaceResponse.Value.ProvisioningState, "Succeeded", true) != 0) { DelayInTest(5); } getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroup, namespaceName); Assert.NotNull(getNamespaceResponse); Assert.AreEqual("Succeeded", getNamespaceResponse.Value.ProvisioningState, StringComparer.CurrentCultureIgnoreCase.ToString()); Assert.AreEqual(location.Result, getNamespaceResponse.Value.Location, StringComparer.CurrentCultureIgnoreCase.ToString()); var netWorkRuleSet = await NamespacesOperations.CreateOrUpdateNetworkRuleSetAsync(resourceGroup, namespaceName, new NetworkRuleSet() { DefaultAction = DefaultAction.Deny, VirtualNetworkRules = { new NWRuleSetVirtualNetworkRules() { Subnet = new Subnet("/subscriptions/" + SubscriptionId + "/resourcegroups/" + resourceGroup + "/providers/Microsoft.Network/virtualNetworks/sbehvnettest1/subnets/default") }, new NWRuleSetVirtualNetworkRules() { Subnet = new Subnet("/subscriptions/" + SubscriptionId + "/resourcegroups/" + resourceGroup + "/providers/Microsoft.Network/virtualNetworks/sbehvnettest1/subnets/sbdefault") }, new NWRuleSetVirtualNetworkRules() { Subnet = new Subnet("/subscriptions/" + SubscriptionId + "/resourcegroups/" + resourceGroup + "/providers/Microsoft.Network/virtualNetworks/sbehvnettest1/subnets/sbdefault01") } }, IpRules = { new NWRuleSetIpRules() { IpMask = "1.1.1.1", Action = "Allow" }, new NWRuleSetIpRules() { IpMask = "1.1.1.2", Action = "Allow" }, new NWRuleSetIpRules() { IpMask = "1.1.1.3", Action = "Allow" }, new NWRuleSetIpRules() { IpMask = "1.1.1.4", Action = "Allow" }, new NWRuleSetIpRules() { IpMask = "1.1.1.5", Action = "Allow" } } }); var getNetworkRuleSet = await NamespacesOperations.GetNetworkRuleSetAsync(resourceGroup, namespaceName); var netWorkRuleSet1 = await NamespacesOperations.CreateOrUpdateNetworkRuleSetAsync(resourceGroup, namespaceName, new NetworkRuleSet() { DefaultAction = "Allow" }); var getNetworkRuleSet1 = await NamespacesOperations.GetNetworkRuleSetAsync(resourceGroup, namespaceName); DelayInTest(60); //Delete namespace await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroup, namespaceName)); }
public async Task EventCreateGetUpdateDelete() { var location = await GetLocation(); var resourceGroupName = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); ResourceGroup resourceGroup = (await ArmClient.DefaultSubscription.GetResourceGroups().CreateOrUpdateAsync(resourceGroupName, new ResourceGroupData(location))).Value; // Prepare Storage Account var accountName = Recording.GenerateAssetName("sdktestaccount"); var storageAccountCreateParameters = new StorageAccountCreateParameters( new ResourceManager.Storage.Models.Sku("Standard_LRS"), Kind.StorageV2, "eastus2" ) { AccessTier = AccessTier.Hot }; StorageAccountContainer storageAccountContainer = resourceGroup.GetStorageAccounts(); await storageAccountContainer.CreateOrUpdateAsync(accountName, storageAccountCreateParameters); // Create NameSpace var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroupName, namespaceName, new EHNamespace() { Location = location } ); var np = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np.Name, namespaceName); DelayInTest(5); // Create Eventhub var eventhubName = Recording.GenerateAssetName(Helper.EventHubPrefix); var createEventhubResponse = await EventHubsOperations.CreateOrUpdateAsync(resourceGroupName, namespaceName, eventhubName, new Eventhub() { MessageRetentionInDays = 4, PartitionCount = 4, Status = EntityStatus.Active, CaptureDescription = new CaptureDescription() { Enabled = true, Encoding = EncodingCaptureDescription.Avro, IntervalInSeconds = 120, SizeLimitInBytes = 10485763, Destination = new Destination() { Name = "EventHubArchive.AzureBlockBlob", BlobContainer = "container", ArchiveNameFormat = "{Namespace}/{EventHub}/{PartitionId}/{Year}/{Month}/{Day}/{Hour}/{Minute}/{Second}", StorageAccountResourceId = "/subscriptions/" + SubscriptionId + "/resourcegroups/" + resourceGroupName + "/providers/Microsoft.Storage/storageAccounts/" + accountName }, SkipEmptyArchives = true } }); Assert.NotNull(createEventhubResponse); Assert.AreEqual(createEventhubResponse.Value.Name, eventhubName); Assert.True(createEventhubResponse.Value.CaptureDescription.SkipEmptyArchives); //Get the created EventHub var getEventHubResponse = await EventHubsOperations.GetAsync(resourceGroupName, namespaceName, eventhubName); Assert.NotNull(getEventHubResponse.Value); Assert.AreEqual(EntityStatus.Active, getEventHubResponse.Value.Status); Assert.AreEqual(getEventHubResponse.Value.Name, eventhubName); //Get all Event Hubs for a given NameSpace var getListEventHubResponse = EventHubsOperations.ListByNamespaceAsync(resourceGroupName, namespaceName); var list = await getListEventHubResponse.ToEnumerableAsync(); Assert.NotNull(getListEventHubResponse); Assert.True(list.Count() >= 1); // Update the EventHub getEventHubResponse.Value.CaptureDescription.IntervalInSeconds = 130; getEventHubResponse.Value.CaptureDescription.SizeLimitInBytes = 10485900; getEventHubResponse.Value.MessageRetentionInDays = 5; //TODO time exception var UpdateEventHubResponse = (await EventHubsOperations.CreateOrUpdateAsync(resourceGroupName, namespaceName, eventhubName, getEventHubResponse.Value)).Value; Assert.NotNull(UpdateEventHubResponse); // Get the updated EventHub and verify the properties var getEventResponse = await EventHubsOperations.GetAsync(resourceGroupName, namespaceName, eventhubName); Assert.NotNull(getEventResponse); Assert.AreEqual(EntityStatus.Active, getEventResponse.Value.Status); Assert.AreEqual(5, getEventResponse.Value.MessageRetentionInDays); // Delete the Evnet Hub var deleteEventResponse = await EventHubsOperations.DeleteAsync(resourceGroupName, namespaceName, eventhubName); // Delete namespace and check for the NotFound exception var deleteNamespaceResponse = await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroupName, namespaceName)); }
public async Task DisasterRecoveryAlertnateNameCreateGetUpdateDelete() { var location = "South Central US"; var location2 = "North Central US"; var resourceGroupName = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); await ArmClient.DefaultSubscription.GetResourceGroups().CreateOrUpdateAsync(resourceGroupName, new ResourceGroupData(location));; var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); // Create namespace 1 var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroupName, namespaceName, new EHNamespace() { Location = location, Sku = new Sku(SkuName.Standard) { Tier = SkuTier.Standard, Capacity = 1 }, Tags = { { "tag1", "value1" }, { "tag2", "value2" } } } ); var np1 = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np1.Name, namespaceName); DelayInTest(5); // Create namespace 2 var namespaceName2 = Recording.GenerateAssetName(Helper.NamespacePrefix); var createNamespaceResponse2 = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroupName, namespaceName2, new EHNamespace() { Location = location2, Sku = new Sku(SkuName.Standard) { Tier = SkuTier.Standard, Capacity = 1 }, Tags = { { "tag1", "value1" }, { "tag2", "value2" } } } ); var np2 = (await WaitForCompletionAsync(createNamespaceResponse2)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np2.Name, namespaceName2); DelayInTest(5); // Create a namespace AuthorizationRule var authorizationRuleName = Recording.GenerateAssetName(Helper.AuthorizationRulesPrefix); var createAutorizationRuleParameter = new AuthorizationRule() { Rights = { AccessRights.Listen, AccessRights.Send } }; var createNamespaceAuthorizationRuleResponse = await NamespacesOperations.CreateOrUpdateAuthorizationRuleAsync(resourceGroupName, namespaceName, authorizationRuleName, createAutorizationRuleParameter); Assert.NotNull(createNamespaceAuthorizationRuleResponse); Assert.True(createNamespaceAuthorizationRuleResponse.Value.Rights.Count == createAutorizationRuleParameter.Rights.Count); Assert.True(isContains(createAutorizationRuleParameter.Rights, createNamespaceAuthorizationRuleResponse.Value.Rights)); // Get created namespace AuthorizationRules var getNamespaceAuthorizationRulesResponse = await NamespacesOperations.GetAuthorizationRuleAsync(resourceGroupName, namespaceName, authorizationRuleName); Assert.NotNull(getNamespaceAuthorizationRulesResponse); Assert.True(getNamespaceAuthorizationRulesResponse.Value.Rights.Count == createAutorizationRuleParameter.Rights.Count); Assert.True(isContains(createAutorizationRuleParameter.Rights, getNamespaceAuthorizationRulesResponse.Value.Rights)); var getNamespaceAuthorizationRulesListKeysResponse = NamespacesOperations.ListKeysAsync(resourceGroupName, namespaceName, authorizationRuleName); // Create a Disaster Recovery - var alternateName = Recording.GenerateAssetName(Helper.DisasterRecoveryPrefix); //CheckNameavaliability for Alias var checknameAlias = await DisasterRecoveryConfigsOperations.CheckNameAvailabilityAsync(resourceGroupName, namespaceName, new CheckNameAvailabilityParameter(namespaceName)); Assert.True(checknameAlias.Value.NameAvailable, "The Alias Name: '" + namespaceName + "' is not avilable"); var DisasterRecoveryResponse = await DisasterRecoveryConfigsOperations.CreateOrUpdateAsync(resourceGroupName, namespaceName, namespaceName, new ArmDisasterRecovery() { PartnerNamespace = np2.Id, AlternateName = alternateName }); Assert.NotNull(DisasterRecoveryResponse); DelayInTest(30); //// Get the created DisasterRecovery config - Primary var disasterRecoveryGetResponse = await DisasterRecoveryConfigsOperations.GetAsync(resourceGroupName, namespaceName, namespaceName); Assert.NotNull(disasterRecoveryGetResponse); Assert.AreEqual(RoleDisasterRecovery.Primary, disasterRecoveryGetResponse.Value.Role); //// Get the created DisasterRecovery config - Secondary var disasterRecoveryGetResponse_Sec = await DisasterRecoveryConfigsOperations.GetAsync(resourceGroupName, namespaceName2, namespaceName); Assert.NotNull(disasterRecoveryGetResponse_Sec); Assert.AreEqual(RoleDisasterRecovery.Secondary, disasterRecoveryGetResponse_Sec.Value.Role); //Get authorization rule thorugh Alias var getAuthoRuleAliasResponse = await DisasterRecoveryConfigsOperations.GetAuthorizationRuleAsync(resourceGroupName, namespaceName, namespaceName, authorizationRuleName); Assert.AreEqual(getAuthoRuleAliasResponse.Value.Name, getNamespaceAuthorizationRulesResponse.Value.Name); var getAuthoruleListKeysResponse = await DisasterRecoveryConfigsOperations.ListKeysAsync(resourceGroupName, namespaceName, namespaceName, authorizationRuleName); var disasterRecoveryGetResponse_Accepted = await DisasterRecoveryConfigsOperations.GetAsync(resourceGroupName, namespaceName, namespaceName); while (DisasterRecoveryConfigsOperations.GetAsync(resourceGroupName, namespaceName, namespaceName).Result.Value.ProvisioningState != ProvisioningStateDR.Succeeded) { DelayInTest(10); } //// Break Pairing await DisasterRecoveryConfigsOperations.BreakPairingAsync(resourceGroupName, namespaceName, namespaceName); DelayInTest(10); disasterRecoveryGetResponse_Accepted = await DisasterRecoveryConfigsOperations.GetAsync(resourceGroupName, namespaceName, namespaceName); while (DisasterRecoveryConfigsOperations.GetAsync(resourceGroupName, namespaceName, namespaceName).Result.Value.ProvisioningState != ProvisioningStateDR.Succeeded) { DelayInTest(10); } var DisasterRecoveryResponse_update = DisasterRecoveryConfigsOperations.CreateOrUpdateAsync(resourceGroupName, namespaceName, namespaceName, new ArmDisasterRecovery() { PartnerNamespace = np2.Id, AlternateName = alternateName }); Assert.NotNull(DisasterRecoveryResponse_update); DelayInTest(10); while (DisasterRecoveryConfigsOperations.GetAsync(resourceGroupName, namespaceName, namespaceName).Result.Value.ProvisioningState != ProvisioningStateDR.Succeeded) { DelayInTest(10); } // Fail over await DisasterRecoveryConfigsOperations.FailOverAsync(resourceGroupName, namespaceName2, namespaceName); DelayInTest(10); while (DisasterRecoveryConfigsOperations.GetAsync(resourceGroupName, namespaceName2, namespaceName).Result.Value.ProvisioningState != ProvisioningStateDR.Succeeded) { DelayInTest(10); } // Get all Disaster Recovery for a given NameSpace var getListisasterRecoveryResponse = DisasterRecoveryConfigsOperations.ListAsync(resourceGroupName, namespaceName2); Assert.NotNull(getListisasterRecoveryResponse); //Assert.True(getListisasterRecoveryResponse.AsPages.Count<ArmDisasterRecovery>() >= 1); // Delete the DisasterRecovery await DisasterRecoveryConfigsOperations.DeleteAsync(resourceGroupName, namespaceName2, namespaceName); // Delete Namespace using Async //await NamespacesClient.StartDeleteAsync(resourceGroupName, namespaceName, new CancellationToken()).ConfigureAwait(false); ////NamespacesClient.DeleteWithHttpMessages(resourceGroupName, namespaceName, null, new CancellationToken()).ConfigureAwait(false); //await NamespacesClient.StartDeleteAsync(resourceGroupName, namespaceName2, new CancellationToken()).ConfigureAwait(false); }
public async Task EventCreateGetUpdateDelete() { var location = GetLocation(); var resourceGroup = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); await Helper.TryRegisterResourceGroupAsync(ResourceGroupsOperations, location.Result, resourceGroup); var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroup, namespaceName, new EHNamespace() { Location = location.Result } ); var np = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np.Name, namespaceName); DelayInTest(5); // Create Eventhub var eventhubName = Recording.GenerateAssetName(Helper.EventHubPrefix); //You Need to create a storage account first --Youri 8.5.2020 var createEventhubResponse = await EventHubsOperations.CreateOrUpdateAsync(resourceGroup, namespaceName, eventhubName, new Eventhub() { MessageRetentionInDays = 4, PartitionCount = 4, Status = EntityStatus.Active, CaptureDescription = new CaptureDescription() { Enabled = true, Encoding = EncodingCaptureDescription.Avro, IntervalInSeconds = 120, SizeLimitInBytes = 10485763, Destination = new Destination() { Name = "EventHubArchive.AzureBlockBlob", BlobContainer = "container", ArchiveNameFormat = "{Namespace}/{EventHub}/{PartitionId}/{Year}/{Month}/{Day}/{Hour}/{Minute}/{Second}", StorageAccountResourceId = "/subscriptions/" + SubscriptionId + "/resourcegroups/" + resourceGroup + "/providers/Microsoft.Storage/storageAccounts/testingsdkeventhub88" }, SkipEmptyArchives = true } }); Assert.NotNull(createEventhubResponse); Assert.AreEqual(createEventhubResponse.Value.Name, eventhubName); Assert.True(createEventhubResponse.Value.CaptureDescription.SkipEmptyArchives); //Get the created EventHub var getEventHubResponse = await EventHubsOperations.GetAsync(resourceGroup, namespaceName, eventhubName); Assert.NotNull(getEventHubResponse.Value); Assert.AreEqual(EntityStatus.Active, getEventHubResponse.Value.Status); Assert.AreEqual(getEventHubResponse.Value.Name, eventhubName); //Get all Event Hubs for a given NameSpace var getListEventHubResponse = EventHubsOperations.ListByNamespaceAsync(resourceGroup, namespaceName); var list = await getListEventHubResponse.ToEnumerableAsync(); Assert.NotNull(getListEventHubResponse); Assert.True(list.Count() >= 1); // Update the EventHub getEventHubResponse.Value.CaptureDescription.IntervalInSeconds = 130; getEventHubResponse.Value.CaptureDescription.SizeLimitInBytes = 10485900; getEventHubResponse.Value.MessageRetentionInDays = 5; //TODO time exception var UpdateEventHubResponse = (await EventHubsOperations.CreateOrUpdateAsync(resourceGroup, namespaceName, eventhubName, getEventHubResponse.Value)).Value; Assert.NotNull(UpdateEventHubResponse); // Get the updated EventHub and verify the properties var getEventResponse = await EventHubsOperations.GetAsync(resourceGroup, namespaceName, eventhubName); Assert.NotNull(getEventResponse); Assert.AreEqual(EntityStatus.Active, getEventResponse.Value.Status); Assert.AreEqual(5, getEventResponse.Value.MessageRetentionInDays); // Delete the Evnet Hub var deleteEventResponse = await EventHubsOperations.DeleteAsync(resourceGroup, namespaceName, eventhubName); // Delete namespace and check for the NotFound exception var deleteNamespaceResponse = await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroup, namespaceName)); }
public async Task NamespaceCreateGetUpdateDeleteAuthorizationRules() { var location = await GetLocation(); var resourceGroupName = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); await ArmClient.DefaultSubscription.GetResourceGroups().CreateOrUpdateAsync(resourceGroupName, new ResourceGroupData(location));; var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroupName, namespaceName, new EHNamespace() { Location = location, //Sku = new Sku("as") Tags = { { "tag1", "value1" }, { "tag2", "value2" } } } ); var np = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np.Name, namespaceName); DelayInTest(5); //get the created namespace var getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroupName, namespaceName); if (string.Compare(getNamespaceResponse.Value.ProvisioningState, "Succeeded", true) != 0) { DelayInTest(5); } getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroupName, namespaceName); Assert.NotNull(getNamespaceResponse); Assert.AreEqual("Succeeded", getNamespaceResponse.Value.ProvisioningState, StringComparer.CurrentCultureIgnoreCase.ToString()); Assert.AreEqual(location, getNamespaceResponse.Value.Location); // Create a namespace AuthorizationRule var authorizationRuleName = Recording.GenerateAssetName(Helper.AuthorizationRulesPrefix); string createPrimaryKey = Recording.GetVariable("authorizaRuNa", Helper.GenerateRandomKey()); var createAutorizationRuleParameter = new AuthorizationRule() { Rights = { AccessRights.Listen, AccessRights.Send } }; var createNamespaceAuthorizationRuleResponse = await NamespacesOperations.CreateOrUpdateAuthorizationRuleAsync(resourceGroupName, namespaceName, authorizationRuleName, createAutorizationRuleParameter); Assert.NotNull(createNamespaceAuthorizationRuleResponse); Assert.True(createNamespaceAuthorizationRuleResponse.Value.Rights.Count == createAutorizationRuleParameter.Rights.Count); Assert.True(isContains(createAutorizationRuleParameter.Rights, createNamespaceAuthorizationRuleResponse.Value.Rights)); // Get default namespace AuthorizationRules var getNamespaceAuthorizationRulesResponse = await NamespacesOperations.GetAuthorizationRuleAsync(resourceGroupName, namespaceName, Helper.DefaultNamespaceAuthorizationRule); Assert.NotNull(getNamespaceAuthorizationRulesResponse); Assert.AreEqual(getNamespaceAuthorizationRulesResponse.Value.Name, Helper.DefaultNamespaceAuthorizationRule); var accessRights = new List <AccessRights>() { AccessRights.Listen, AccessRights.Send, AccessRights.Manage }; Assert.True(isContains(getNamespaceAuthorizationRulesResponse.Value.Rights, accessRights)); // Get created namespace AuthorizationRules getNamespaceAuthorizationRulesResponse = await NamespacesOperations.GetAuthorizationRuleAsync(resourceGroupName, namespaceName, authorizationRuleName); Assert.NotNull(getNamespaceAuthorizationRulesResponse); Assert.True(getNamespaceAuthorizationRulesResponse.Value.Rights.Count == createAutorizationRuleParameter.Rights.Count); Assert.True(isContains(createAutorizationRuleParameter.Rights, getNamespaceAuthorizationRulesResponse.Value.Rights)); // Get all namespaces AuthorizationRules var getAllNamespaceAuthorizationRulesResponse = NamespacesOperations.ListAuthorizationRulesAsync(resourceGroupName, namespaceName); Assert.NotNull(getAllNamespaceAuthorizationRulesResponse); var getAllNpsAuthResp = await getAllNamespaceAuthorizationRulesResponse.ToEnumerableAsync(); Assert.True(getAllNpsAuthResp.Count() > 1); bool isContainAuthorizationRuleName = false; bool isContainEventHubManagementHelper = false; foreach (var Authrule in getAllNpsAuthResp) { if (Authrule.Name == authorizationRuleName) { isContainAuthorizationRuleName = true; break; } } foreach (var Authrule in getAllNpsAuthResp) { if (Authrule.Name == Helper.DefaultNamespaceAuthorizationRule) { isContainEventHubManagementHelper = true; break; } } Assert.True(isContainAuthorizationRuleName); Assert.True(isContainEventHubManagementHelper); // Update namespace authorizationRule string updatePrimaryKey = Recording.GetVariable("UpdatePrimaryKey", Helper.GenerateRandomKey()); AuthorizationRule updateNamespaceAuthorizationRuleParameter = new AuthorizationRule(); updateNamespaceAuthorizationRuleParameter.Rights.Add(AccessRights.Listen); var updateNamespaceAuthorizationRuleResponse = await NamespacesOperations.CreateOrUpdateAuthorizationRuleAsync(resourceGroupName, namespaceName, authorizationRuleName, updateNamespaceAuthorizationRuleParameter); Assert.NotNull(updateNamespaceAuthorizationRuleResponse); Assert.AreEqual(authorizationRuleName, updateNamespaceAuthorizationRuleResponse.Value.Name); Assert.True(updateNamespaceAuthorizationRuleResponse.Value.Rights.Count == updateNamespaceAuthorizationRuleParameter.Rights.Count); Assert.True(isContains(updateNamespaceAuthorizationRuleParameter.Rights, updateNamespaceAuthorizationRuleResponse.Value.Rights)); // Get the updated namespace AuthorizationRule var getNamespaceAuthorizationRuleResponse = await NamespacesOperations.GetAuthorizationRuleAsync(resourceGroupName, namespaceName, authorizationRuleName); Assert.NotNull(getNamespaceAuthorizationRuleResponse); Assert.AreEqual(authorizationRuleName, getNamespaceAuthorizationRuleResponse.Value.Name); Assert.True(getNamespaceAuthorizationRuleResponse.Value.Rights.Count == updateNamespaceAuthorizationRuleParameter.Rights.Count); Assert.True(isContains(updateNamespaceAuthorizationRuleParameter.Rights, getNamespaceAuthorizationRuleResponse.Value.Rights)); // Get the connection string to the namespace for a Authorization rule created var listKeysResponse = await NamespacesOperations.ListKeysAsync(resourceGroupName, namespaceName, authorizationRuleName); Assert.NotNull(listKeysResponse); Assert.NotNull(listKeysResponse.Value.PrimaryConnectionString); Assert.NotNull(listKeysResponse.Value.SecondaryConnectionString); // Regenerate connection string to the namespace for a Authorization rule created var NewKeysResponse_primary = await NamespacesOperations.RegenerateKeysAsync(resourceGroupName, namespaceName, authorizationRuleName, new RegenerateAccessKeyParameters(KeyType.PrimaryKey)); Assert.NotNull(NewKeysResponse_primary); // Assert.AreNotEqual(NewKeysResponse_primary.Value.PrimaryConnectionString, listKeysResponse.Value.PrimaryConnectionString); Assert.AreEqual(NewKeysResponse_primary.Value.SecondaryConnectionString, listKeysResponse.Value.SecondaryConnectionString); // Regenerate connection string to the namespace for a Authorization rule created var NewKeysResponse_secondary = await NamespacesOperations.RegenerateKeysAsync(resourceGroupName, namespaceName, authorizationRuleName, new RegenerateAccessKeyParameters(KeyType.SecondaryKey)); Assert.NotNull(NewKeysResponse_secondary); // Assert.AreNotEqual(NewKeysResponse_secondary.Value.PrimaryConnectionString, listKeysResponse.Value.PrimaryConnectionString); // Assert.AreNotEqual(NewKeysResponse_secondary.Value.SecondaryConnectionString, listKeysResponse.Value.SecondaryConnectionString); // Delete namespace authorizationRule await NamespacesOperations.DeleteAuthorizationRuleAsync(resourceGroupName, namespaceName, authorizationRuleName); DelayInTest(5); // Delete namespace await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroupName, namespaceName)); }
public async Task EventhubCreateGetUpdateDeleteAuthorizationRules() { var location = GetLocation(); var resourceGroup = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); await Helper.TryRegisterResourceGroupAsync(ResourceGroupsOperations, location.Result, resourceGroup); var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroup, namespaceName, new EHNamespace() { Location = location.Result, Sku = new Sku(SkuName.Standard) { Tier = SkuTier.Standard }, Tags = new Dictionary <string, string>() { { "tag1", "value1" }, { "tag2", "value2" } } } ); var np = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np.Name, namespaceName); DelayInTest(5); //get the created namespace var getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroup, namespaceName); if (string.Compare(getNamespaceResponse.Value.ProvisioningState, "Succeeded", true) != 0) { DelayInTest(5); } getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroup, namespaceName); Assert.NotNull(getNamespaceResponse); Assert.AreEqual("Succeeded", getNamespaceResponse.Value.ProvisioningState, StringComparer.CurrentCultureIgnoreCase.ToString()); Assert.AreEqual(location.Result, getNamespaceResponse.Value.Location); // Create Eventhub var eventHubName = Recording.GenerateAssetName(Helper.EventHubPrefix); var createEventHubResponse = await EventHubsOperations.CreateOrUpdateAsync(resourceGroup, namespaceName, eventHubName, new Eventhub() { MessageRetentionInDays = 5 }); Assert.NotNull(createEventHubResponse); Assert.AreEqual(createEventHubResponse.Value.Name, eventHubName); //Get the created EventHub var getEventHubResponse = await EventHubsOperations.GetAsync(resourceGroup, namespaceName, eventHubName); Assert.NotNull(getEventHubResponse.Value); Assert.AreEqual(EntityStatus.Active, getEventHubResponse.Value.Status); Assert.AreEqual(getEventHubResponse.Value.Name, eventHubName); // Create a EventHub AuthorizationRule var authorizationRuleName = Recording.GenerateAssetName(Helper.AuthorizationRulesPrefix); string createPrimaryKey = Recording.GetVariable("CreatePrimaryKey", Helper.GenerateRandomKey()); var createAutorizationRuleParameter = new AuthorizationRule() { Rights = new List <AccessRights>() { AccessRights.Listen, AccessRights.Send } }; var createEventhubAuthorizationRuleResponse = await EventHubsOperations.CreateOrUpdateAuthorizationRuleAsync(resourceGroup, namespaceName, eventHubName, authorizationRuleName, createAutorizationRuleParameter); Assert.NotNull(createEventhubAuthorizationRuleResponse); Assert.True(createEventhubAuthorizationRuleResponse.Value.Rights.Count == createAutorizationRuleParameter.Rights.Count); Assert.True(isContains(createAutorizationRuleParameter.Rights, createEventhubAuthorizationRuleResponse.Value.Rights)); // Get created Eventhub AuthorizationRules var getEventhubAuthorizationRulesResponse = await EventHubsOperations.GetAuthorizationRuleAsync(resourceGroup, namespaceName, eventHubName, authorizationRuleName); Assert.NotNull(getEventhubAuthorizationRulesResponse); Assert.True(getEventhubAuthorizationRulesResponse.Value.Rights.Count == createAutorizationRuleParameter.Rights.Count); Assert.True(isContains(createAutorizationRuleParameter.Rights, getEventhubAuthorizationRulesResponse.Value.Rights)); // Get all Eventhub AuthorizationRules var getAllNamespaceAuthorizationRulesResponse = EventHubsOperations.ListAuthorizationRulesAsync(resourceGroup, namespaceName, eventHubName); Assert.NotNull(getAllNamespaceAuthorizationRulesResponse); var getAllNSPAuthRulesRespList = await getAllNamespaceAuthorizationRulesResponse.ToEnumerableAsync(); Assert.True(getAllNSPAuthRulesRespList.Count() == 1); bool isContainauthorizationRuleName = false; foreach (var detail in getAllNSPAuthRulesRespList) { if (detail.Name == authorizationRuleName) { isContainauthorizationRuleName = true; break; } } Assert.True(isContainauthorizationRuleName); // Update Eventhub authorizationRule string updatePrimaryKey = Recording.GetVariable("UpdatePrimaryKey", Helper.GenerateRandomKey()); AuthorizationRule updateEventhubAuthorizationRuleParameter = new AuthorizationRule(); updateEventhubAuthorizationRuleParameter.Rights = new List <AccessRights>() { AccessRights.Listen }; var updateEventhubAuthorizationRuleResponse = await EventHubsOperations.CreateOrUpdateAuthorizationRuleAsync(resourceGroup, namespaceName, eventHubName, authorizationRuleName, updateEventhubAuthorizationRuleParameter); Assert.NotNull(updateEventhubAuthorizationRuleResponse); Assert.AreEqual(authorizationRuleName, updateEventhubAuthorizationRuleResponse.Value.Name); Assert.True(updateEventhubAuthorizationRuleResponse.Value.Rights.Count == updateEventhubAuthorizationRuleParameter.Rights.Count); Assert.True(isContains(updateEventhubAuthorizationRuleParameter.Rights, updateEventhubAuthorizationRuleResponse.Value.Rights)); // Get the updated Eventhub AuthorizationRule var getEventhubAuthorizationRuleResponse = await EventHubsOperations.GetAuthorizationRuleAsync(resourceGroup, namespaceName, eventHubName, authorizationRuleName); Assert.NotNull(getEventhubAuthorizationRuleResponse); Assert.AreEqual(authorizationRuleName, getEventhubAuthorizationRuleResponse.Value.Name); Assert.True(getEventhubAuthorizationRuleResponse.Value.Rights.Count == updateEventhubAuthorizationRuleParameter.Rights.Count); Assert.True(isContains(updateEventhubAuthorizationRuleParameter.Rights, getEventhubAuthorizationRuleResponse.Value.Rights)); // Get the connectionString to the Eventhub for a Authorization rule created var listKeysResponse = await EventHubsOperations.ListKeysAsync(resourceGroup, namespaceName, eventHubName, authorizationRuleName); Assert.NotNull(listKeysResponse); Assert.NotNull(listKeysResponse.Value.PrimaryConnectionString); Assert.NotNull(listKeysResponse.Value.SecondaryConnectionString); //New connection string var regenerateConnection_primary = await EventHubsOperations.RegenerateKeysAsync(resourceGroup, namespaceName, eventHubName, authorizationRuleName, new RegenerateAccessKeyParameters(KeyType.PrimaryKey)); Assert.NotNull(regenerateConnection_primary); Assert.AreNotEqual(listKeysResponse.Value.PrimaryConnectionString, regenerateConnection_primary.Value.PrimaryConnectionString); Assert.AreEqual(listKeysResponse.Value.SecondaryConnectionString, regenerateConnection_primary.Value.SecondaryConnectionString); var regenerateConnection_Secondary = await EventHubsOperations.RegenerateKeysAsync(resourceGroup, namespaceName, eventHubName, authorizationRuleName, new RegenerateAccessKeyParameters(KeyType.SecondaryKey)); Assert.NotNull(regenerateConnection_Secondary); Assert.AreNotEqual(listKeysResponse.Value.SecondaryConnectionString, regenerateConnection_Secondary.Value.SecondaryConnectionString); Assert.AreEqual(regenerateConnection_primary.Value.PrimaryConnectionString, regenerateConnection_Secondary.Value.PrimaryConnectionString); // Delete Eventhub authorizationRule await EventHubsOperations.DeleteAuthorizationRuleAsync(resourceGroup, namespaceName, eventHubName, authorizationRuleName); DelayInTest(5); // Delete Eventhub and check for the NotFound exception await EventHubsOperations.DeleteAsync(resourceGroup, namespaceName, eventHubName); // Delete namespace and check for the NotFound exception await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroup, namespaceName)); }
public async Task NamespaceKafkaCreateGetUpdateDelete() { var location = "West US"; var resourceGroupName = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); await ArmClient.DefaultSubscription.GetResourceGroups().CreateOrUpdateAsync(resourceGroupName, new ResourceGroupData(location)); var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroupName, namespaceName, new EHNamespace() { Location = location, Tags = { { "tag1", "value1" }, { "tag2", "value2" } }, IsAutoInflateEnabled = true, MaximumThroughputUnits = 10, KafkaEnabled = true } ); var np = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np.Name, namespaceName); Assert.True(np.KafkaEnabled, "KafkaEnabled is false"); DelayInTest(5); //get the created namespace var getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroupName, namespaceName); if (string.Compare(getNamespaceResponse.Value.ProvisioningState, "Succeeded", true) != 0) { DelayInTest(5); } getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroupName, namespaceName); Assert.NotNull(getNamespaceResponse); Assert.AreEqual("Succeeded", getNamespaceResponse.Value.ProvisioningState, StringComparer.CurrentCultureIgnoreCase.ToString()); Assert.AreEqual(location, getNamespaceResponse.Value.Location); // Get all namespaces created within a resourceGroupName var getAllNamespacesResponse = NamespacesOperations.ListByResourceGroupAsync(resourceGroupName); Assert.NotNull(getAllNamespacesResponse); //Assert.True(getAllNamespacesResponse.AsPages.c >= 1); var getAllNamespRespList = await getAllNamespacesResponse.ToEnumerableAsync(); bool isContainnamespaceName = false; bool isContainresourceGroup = false; foreach (var name in getAllNamespRespList) { if (name.Name == namespaceName) { isContainnamespaceName = true; break; } } foreach (var name in getAllNamespRespList) { if (name.Id.Contains(resourceGroupName)) { isContainresourceGroup = true; break; } } Assert.True(isContainnamespaceName); Assert.True(isContainresourceGroup); // Get all namespaces created within the subscription irrespective of the resourceGroupName getAllNamespacesResponse = NamespacesOperations.ListAsync(); Assert.NotNull(getAllNamespacesResponse); bool isContainNamespacename = false; getAllNamespRespList = await getAllNamespacesResponse.ToEnumerableAsync(); foreach (var getNameSpResp in getAllNamespRespList) { if (getNameSpResp.Name == namespaceName) { isContainNamespacename = true; break; } } Assert.IsTrue(isContainNamespacename); // Update namespace tags and make the namespace critical var updateNamespaceParameter = new EHNamespace() { Tags = { { "tag3", "value3" }, { "tag4", "value4" } } }; // Will uncomment the assertions once the service is deployed var updateNamespaceResponse = await NamespacesOperations.UpdateAsync(resourceGroupName, namespaceName, updateNamespaceParameter); Assert.NotNull(updateNamespaceResponse); Assert.True(updateNamespaceResponse.Value.ProvisioningState.Equals("Active", StringComparison.CurrentCultureIgnoreCase) || updateNamespaceResponse.Value.ProvisioningState.Equals("Updating", StringComparison.CurrentCultureIgnoreCase)); Assert.AreEqual(namespaceName, updateNamespaceResponse.Value.Name); // Get the updated namespace and also verify the Tags. getNamespaceResponse = await NamespacesOperations.GetAsync(resourceGroupName, namespaceName); Assert.NotNull(getNamespaceResponse); Assert.AreEqual(location, getNamespaceResponse.Value.Location); Assert.AreEqual(namespaceName, getNamespaceResponse.Value.Name); Assert.AreEqual(2, getNamespaceResponse.Value.Tags.Count); bool isContainKey = false; bool isContainValue = false; foreach (var tag in updateNamespaceParameter.Tags) { foreach (var key in getNamespaceResponse.Value.Tags) { if (key.Key == tag.Key) { isContainKey = true; break; } } foreach (var value in getNamespaceResponse.Value.Tags) { if (value.Value == tag.Value) { isContainValue = true; break; } } //Assert.Contains(getNamespaceResponse.Value.Tags, t => t.Key.Equals(tag.Key)); //Assert.Contains(getNamespaceResponse.Value.Tags, t => t.Value.Equals(tag.Value)); } Assert.True(isContainKey); Assert.True(isContainValue); DelayInTest(5); // Delete namespace await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroupName, namespaceName)); }
public async Task ConsumerGroupsCreateGetUpdateDelete() { var location = await GetLocation(); var resourceGroupName = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); await ArmClient.DefaultSubscription.GetResourceGroups().CreateOrUpdateAsync(resourceGroupName, new ResourceGroupData(location)); var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroupName, namespaceName, new EHNamespace() { Location = location, Sku = new Sku(SkuName.Standard) { Tier = SkuTier.Standard, }, Tags = { { "tag1", "value1" }, { "tag2", "value2" } } } ); var np = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np.Name, namespaceName); DelayInTest(5); // Create Eventhub var eventhubName = Recording.GenerateAssetName(Helper.EventHubPrefix); var createEventhubResponse = await EventHubsOperations.CreateOrUpdateAsync(resourceGroupName, namespaceName, eventhubName, new Eventhub() { MessageRetentionInDays = 5 }); Assert.NotNull(createEventhubResponse); Assert.AreEqual(createEventhubResponse.Value.Name, eventhubName); //Get the created EventHub var getEventHubResponse = await EventHubsOperations.GetAsync(resourceGroupName, namespaceName, eventhubName); Assert.NotNull(getEventHubResponse); Assert.AreEqual(EntityStatus.Active, getEventHubResponse.Value.Status); Assert.AreEqual(getEventHubResponse.Value.Name, eventhubName); // Create ConsumerGroup. var consumergroupName = Recording.GenerateAssetName(Helper.ConsumerGroupPrefix); string UserMetadata = "Newly Created"; var createConsumergroupResponse = await ConsumerGroupsOperations.CreateOrUpdateAsync(resourceGroupName, namespaceName, eventhubName, consumergroupName, new ConsumerGroup { UserMetadata = UserMetadata }); Assert.NotNull(createConsumergroupResponse); Assert.AreEqual(createConsumergroupResponse.Value.Name, consumergroupName); // Get Created ConsumerGroup var getConsumergroupGetResponse = await ConsumerGroupsOperations.GetAsync(resourceGroupName, namespaceName, eventhubName, consumergroupName); Assert.NotNull(getConsumergroupGetResponse); Assert.AreEqual(getConsumergroupGetResponse.Value.Name, consumergroupName); // Get all ConsumerGroup var getSubscriptionsListAllResponse = ConsumerGroupsOperations.ListByEventHubAsync(resourceGroupName, namespaceName, eventhubName); Assert.NotNull(getSubscriptionsListAllResponse); bool isContainresourceGroup = false; var list = await getSubscriptionsListAllResponse.ToEnumerableAsync(); foreach (var detail in list) { if (detail.Id.Contains(resourceGroupName)) { isContainresourceGroup = true; break; } } Assert.True(isContainresourceGroup); //Update the Created consumergroup createConsumergroupResponse.Value.UserMetadata = "Updated the user meta data"; var updateconsumergroupResponse = ConsumerGroupsOperations.CreateOrUpdateAsync(resourceGroupName, namespaceName, eventhubName, consumergroupName, createConsumergroupResponse); Assert.NotNull(updateconsumergroupResponse); Assert.AreEqual(updateconsumergroupResponse.Result.Value.Name, createConsumergroupResponse.Value.Name); Assert.AreEqual("Updated the user meta data", updateconsumergroupResponse.Result.Value.UserMetadata); // Get Created ConsumerGroup var getConsumergroupResponse = ConsumerGroupsOperations.GetAsync(resourceGroupName, namespaceName, eventhubName, consumergroupName); Assert.NotNull(getConsumergroupResponse); Assert.AreEqual(getConsumergroupResponse.Result.Value.Name, consumergroupName); Assert.AreEqual(getConsumergroupResponse.Result.Value.UserMetadata, updateconsumergroupResponse.Result.Value.UserMetadata); // Delete Created ConsumerGroup and check for the NotFound exception await ConsumerGroupsOperations.DeleteAsync(resourceGroupName, namespaceName, eventhubName, consumergroupName); // Delete Created EventHub and check for the NotFound exception await EventHubsOperations.DeleteAsync(resourceGroupName, namespaceName, eventhubName); // Delete namespace await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroupName, namespaceName)); //Subscription end }
public async Task ConsumerGroupsCreateGetUpdateDelete_Length() { var location = GetLocation(); var resourceGroup = Recording.GenerateAssetName(Helper.ResourceGroupPrefix); await Helper.TryRegisterResourceGroupAsync(ResourceGroupsOperations, location.Result, resourceGroup); var namespaceName = Recording.GenerateAssetName(Helper.NamespacePrefix); var createNamespaceResponse = await NamespacesOperations.StartCreateOrUpdateAsync(resourceGroup, namespaceName, new EHNamespace() { Location = location.Result, Sku = new Sku(SkuName.Standard) { Tier = SkuTier.Standard }, Tags = new Dictionary <string, string>() { { "tag1", "value1" }, { "tag2", "value2" } } } ); var np = (await WaitForCompletionAsync(createNamespaceResponse)).Value; Assert.NotNull(createNamespaceResponse); Assert.AreEqual(np.Name, namespaceName); DelayInTest(5); // Create Eventhub var eventhubName = Helper.EventHubPrefix + "thisisthenamewithmorethan53charschecktoverifytheremovlaof50charsnamelengthlimit"; var createEventhubResponse = await EventHubsOperations.CreateOrUpdateAsync(resourceGroup, namespaceName, eventhubName, new Eventhub() { MessageRetentionInDays = 5 }); Assert.NotNull(createEventhubResponse); Assert.AreEqual(createEventhubResponse.Value.Name, eventhubName); //Get the created EventHub var geteventhubResponse = await EventHubsOperations.GetAsync(resourceGroup, namespaceName, eventhubName); Assert.NotNull(geteventhubResponse); Assert.AreEqual(EntityStatus.Active, geteventhubResponse.Value.Status); Assert.AreEqual(geteventhubResponse.Value.Name, eventhubName); // Create ConsumerGroup. var consumergroupName = "thisisthenamewithmorethan53charschecktoverifqwert"; string UserMetadata = "Newly Created"; var createConsumergroupResponse = await ConsumerGroupsOperations.CreateOrUpdateAsync(resourceGroup, namespaceName, eventhubName, consumergroupName, new ConsumerGroup { UserMetadata = UserMetadata }); Assert.NotNull(createConsumergroupResponse); Assert.AreEqual(createConsumergroupResponse.Value.Name, consumergroupName); // Get Created ConsumerGroup var getConsumergroupGetResponse = ConsumerGroupsOperations.GetAsync(resourceGroup, namespaceName, eventhubName, consumergroupName); Assert.NotNull(getConsumergroupGetResponse); Assert.AreEqual(getConsumergroupGetResponse.Result.Value.Name, consumergroupName); // Get all ConsumerGroup var getSubscriptionsListAllResponse = ConsumerGroupsOperations.ListByEventHubAsync(resourceGroup, namespaceName, eventhubName); Assert.NotNull(getSubscriptionsListAllResponse); bool isContainresourceGroup = false; var list = await getSubscriptionsListAllResponse.ToEnumerableAsync(); foreach (var detail in list) { if (detail.Id.Contains(resourceGroup)) { isContainresourceGroup = true; break; } } Assert.True(isContainresourceGroup); //Assert.True(getSubscriptionsListAllResponse.All(ns => ns.Id.Contains(resourceGroup))); //Update the Created consumergroup createConsumergroupResponse.Value.UserMetadata = "Updated the user meta data"; var updateconsumergroupResponse = await ConsumerGroupsOperations.CreateOrUpdateAsync(resourceGroup, namespaceName, eventhubName, consumergroupName, createConsumergroupResponse); Assert.NotNull(updateconsumergroupResponse); Assert.AreEqual(updateconsumergroupResponse.Value.Name, createConsumergroupResponse.Value.Name); Assert.AreEqual("Updated the user meta data", updateconsumergroupResponse.Value.UserMetadata); // Get Created ConsumerGroup var getConsumergroupResponse = await ConsumerGroupsOperations.GetAsync(resourceGroup, namespaceName, eventhubName, consumergroupName); Assert.NotNull(getConsumergroupResponse); Assert.AreEqual(getConsumergroupResponse.Value.Name, consumergroupName); Assert.AreEqual(getConsumergroupResponse.Value.UserMetadata, updateconsumergroupResponse.Value.UserMetadata); // Delete Created ConsumerGroup and check for the NotFound exception await ConsumerGroupsOperations.DeleteAsync(resourceGroup, namespaceName, eventhubName, consumergroupName); // Delete Created EventHub and check for the NotFound exception await EventHubsOperations.DeleteAsync(resourceGroup, namespaceName, eventhubName); // Delete namespace await WaitForCompletionAsync(await NamespacesOperations.StartDeleteAsync(resourceGroup, namespaceName)); //Subscription end }