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 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 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 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 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 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 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 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 = 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 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 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 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
}
