public PSSharedAccessAuthorizationRuleAttributes CreateOrUpdateServiceBusTopicAuthorizationRules(string resourceGroupName, string namespaceName, string topicName, string authorizationRuleName, PSSharedAccessAuthorizationRuleAttributes parameters)
{
var parameter1 = new SBAuthorizationRule()
{
Rights = parameters.Rights.ToList()
};
var response = Client.Topics.CreateOrUpdateAuthorizationRule(resourceGroupName, namespaceName, topicName, authorizationRuleName, parameter1);
return(new PSSharedAccessAuthorizationRuleAttributes(response));
}
public SharedAccessAuthorizationRuleAttributes(SBAuthorizationRule authRuleResource)
{
if (authRuleResource != null)
{
if (authRuleResource.Id != null)
{
Id = authRuleResource.Id;
}
if (authRuleResource.Name != null)
{
Name = authRuleResource.Name;
}
if (authRuleResource.Type != null)
{
Type = authRuleResource.Type;
}
if (authRuleResource.Rights != null)
{
Rights = authRuleResource.Rights;
}
}
}
public PSSharedAccessAuthorizationRuleAttributes GetServiceBusTopicAuthorizationRules(string resourceGroupName, string namespaceName, string topicName, string authRuleName)
{
SBAuthorizationRule response = Client.Topics.GetAuthorizationRule(resourceGroupName, namespaceName, topicName, authRuleName);
return(new PSSharedAccessAuthorizationRuleAttributes(response));
}
/// <summary>
/// Creates an authorization rule for the specified topic.
/// <see href="https://msdn.microsoft.com/en-us/library/azure/mt720678.aspx" />
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Name of the Resource group within the Azure subscription.
/// </param>
/// <param name='namespaceName'>
/// The namespace name
/// </param>
/// <param name='topicName'>
/// The topic name.
/// </param>
/// <param name='authorizationRuleName'>
/// The authorization rule name.
/// </param>
/// <param name='parameters'>
/// The shared access authorization rule.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <SBAuthorizationRule> CreateOrUpdateAuthorizationRuleAsync(this ITopicsOperations operations, string resourceGroupName, string namespaceName, string topicName, string authorizationRuleName, SBAuthorizationRule parameters, CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.CreateOrUpdateAuthorizationRuleWithHttpMessagesAsync(resourceGroupName, namespaceName, topicName, authorizationRuleName, parameters, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Creates an authorization rule for the specified topic.
/// <see href="https://msdn.microsoft.com/en-us/library/azure/mt720678.aspx" />
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Name of the Resource group within the Azure subscription.
/// </param>
/// <param name='namespaceName'>
/// The namespace name
/// </param>
/// <param name='topicName'>
/// The topic name.
/// </param>
/// <param name='authorizationRuleName'>
/// The authorization rule name.
/// </param>
/// <param name='parameters'>
/// The shared access authorization rule.
/// </param>
public static SBAuthorizationRule CreateOrUpdateAuthorizationRule(this ITopicsOperations operations, string resourceGroupName, string namespaceName, string topicName, string authorizationRuleName, SBAuthorizationRule parameters)
{
return(operations.CreateOrUpdateAuthorizationRuleAsync(resourceGroupName, namespaceName, topicName, authorizationRuleName, parameters).GetAwaiter().GetResult());
}
public void QueuesCreateGetUpdateDeleteAuthorizationRules()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
InitializeClients(context);
var location = this.ResourceManagementClient.GetLocationFromProvider();
var resourceGroup = this.ResourceManagementClient.TryGetResourceGroup(location);
if (string.IsNullOrWhiteSpace(resourceGroup))
{
resourceGroup = TestUtilities.GenerateName(ServiceBusManagementHelper.ResourceGroupPrefix);
this.ResourceManagementClient.TryRegisterResourceGroup(location, resourceGroup);
}
// Create a namespace
var namespaceName = TestUtilities.GenerateName(ServiceBusManagementHelper.NamespacePrefix);
var createNamespaceResponse = this.ServiceBusManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName,
new SBNamespace()
{
Location = location,
Sku = new SBSku
{
Name = SkuName.Standard,
Tier = SkuTier.Standard
}
});
Assert.NotNull(createNamespaceResponse);
Assert.Equal(createNamespaceResponse.Name, namespaceName);
TestUtilities.Wait(TimeSpan.FromSeconds(5));
//Get the created namespace
var getNamespaceResponse = ServiceBusManagementClient.Namespaces.Get(resourceGroup, namespaceName);
if (string.Compare(getNamespaceResponse.ProvisioningState, "Succeeded", true) != 0)
{
TestUtilities.Wait(TimeSpan.FromSeconds(5));
}
getNamespaceResponse = ServiceBusManagementClient.Namespaces.Get(resourceGroup, namespaceName);
Assert.NotNull(getNamespaceResponse);
Assert.Equal("Succeeded", getNamespaceResponse.ProvisioningState, StringComparer.CurrentCultureIgnoreCase);
Assert.Equal(location, getNamespaceResponse.Location, StringComparer.CurrentCultureIgnoreCase);
// Create Queue
var queueName = TestUtilities.GenerateName(ServiceBusManagementHelper.QueuesPrefix);
var createQueueResponse = this.ServiceBusManagementClient.Queues.CreateOrUpdate(resourceGroup, namespaceName, queueName,
new SBQueue()
{
EnablePartitioning = true
});
Assert.NotNull(createQueueResponse);
Assert.Equal(createQueueResponse.Name, queueName);
// Get the created Queue
var getQueueResponse = ServiceBusManagementClient.Queues.Get(resourceGroup, namespaceName, queueName);
Assert.NotNull(getQueueResponse);
Assert.Equal(EntityStatus.Active, getQueueResponse.Status);
Assert.Equal(getQueueResponse.Name, queueName);
// Create a queue AuthorizationRule
var authorizationRuleName = TestUtilities.GenerateName(ServiceBusManagementHelper.AuthorizationRulesPrefix);
string createPrimaryKey = HttpMockServer.GetVariable("CreatePrimaryKey", ServiceBusManagementHelper.GenerateRandomKey());
var createAutorizationRuleParameter = new SBAuthorizationRule()
{
Rights = new List <AccessRights?>()
{
AccessRights.Listen, AccessRights.Send
}
};
var jsonStr = ServiceBusManagementHelper.ConvertObjectToJSon(createAutorizationRuleParameter);
var createQueueAuthorizationRuleResponse = ServiceBusManagementClient.Queues.CreateOrUpdateAuthorizationRule(resourceGroup, namespaceName, queueName,
authorizationRuleName, createAutorizationRuleParameter);
Assert.NotNull(createQueueAuthorizationRuleResponse);
Assert.True(createQueueAuthorizationRuleResponse.Rights.Count == createAutorizationRuleParameter.Rights.Count);
foreach (var right in createAutorizationRuleParameter.Rights)
{
Assert.Contains(createQueueAuthorizationRuleResponse.Rights, r => r == right);
}
// Get created queues AuthorizationRules
var getQueueAuthorizationRulesResponse = ServiceBusManagementClient.Queues.GetAuthorizationRule(resourceGroup, namespaceName, queueName, authorizationRuleName);
Assert.NotNull(getQueueAuthorizationRulesResponse);
Assert.True(getQueueAuthorizationRulesResponse.Rights.Count == createAutorizationRuleParameter.Rights.Count);
foreach (var right in createAutorizationRuleParameter.Rights)
{
Assert.Contains(getQueueAuthorizationRulesResponse.Rights, r => r == right);
}
// Get all queues AuthorizationRules
var getAllNamespaceAuthorizationRulesResponse = ServiceBusManagementClient.Queues.ListAuthorizationRules(resourceGroup, namespaceName, queueName);
Assert.NotNull(getAllNamespaceAuthorizationRulesResponse);
Assert.Single(getAllNamespaceAuthorizationRulesResponse);
Assert.Contains(getAllNamespaceAuthorizationRulesResponse, ns => ns.Name == authorizationRuleName);
// Update queues authorizationRule
string updatePrimaryKey = HttpMockServer.GetVariable("UpdatePrimaryKey", ServiceBusManagementHelper.GenerateRandomKey());
SBAuthorizationRule updateQueuesAuthorizationRuleParameter = new SBAuthorizationRule();
updateQueuesAuthorizationRuleParameter.Rights = new List <AccessRights?>()
{
AccessRights.Listen
};
var updateQueueAuthorizationRuleResponse = ServiceBusManagementClient.Queues.CreateOrUpdateAuthorizationRule(resourceGroup,
namespaceName, queueName, authorizationRuleName, updateQueuesAuthorizationRuleParameter);
Assert.NotNull(updateQueueAuthorizationRuleResponse);
Assert.Equal(authorizationRuleName, updateQueueAuthorizationRuleResponse.Name);
Assert.True(updateQueueAuthorizationRuleResponse.Rights.Count == updateQueuesAuthorizationRuleParameter.Rights.Count);
foreach (var right in updateQueuesAuthorizationRuleParameter.Rights)
{
Assert.Contains(updateQueueAuthorizationRuleResponse.Rights, r => r.Equals(right));
}
// Get the updated queues AuthorizationRule
var getQueueAuthorizationRuleResponse = ServiceBusManagementClient.Queues.GetAuthorizationRule(resourceGroup, namespaceName, queueName,
authorizationRuleName);
Assert.NotNull(getQueueAuthorizationRuleResponse);
Assert.Equal(authorizationRuleName, getQueueAuthorizationRuleResponse.Name);
Assert.True(getQueueAuthorizationRuleResponse.Rights.Count == updateQueuesAuthorizationRuleParameter.Rights.Count);
foreach (var right in updateQueuesAuthorizationRuleParameter.Rights)
{
Assert.Contains(getQueueAuthorizationRuleResponse.Rights, r => r.Equals(right));
}
// Get the connectionString to the queues for a Authorization rule created
var listKeysResponse = ServiceBusManagementClient.Queues.ListKeys(resourceGroup, namespaceName, queueName, authorizationRuleName);
Assert.NotNull(listKeysResponse);
Assert.NotNull(listKeysResponse.PrimaryConnectionString);
Assert.NotNull(listKeysResponse.SecondaryConnectionString);
// Regenerate Keys for the create Authorization rules
var regenerateKeysParameters = new RegenerateAccessKeyParameters();
regenerateKeysParameters.KeyType = KeyType.PrimaryKey;
var regenerateKeysResposnse = ServiceBusManagementClient.Queues.RegenerateKeys(resourceGroup, namespaceName, queueName, authorizationRuleName, regenerateKeysParameters);
Assert.NotEqual(listKeysResponse.PrimaryKey, regenerateKeysResposnse.PrimaryKey);
Assert.NotNull(regenerateKeysResposnse.SecondaryConnectionString);
Assert.NotNull(regenerateKeysResposnse.SecondaryKey);
regenerateKeysParameters.KeyType = KeyType.SecondaryKey;
regenerateKeysResposnse = ServiceBusManagementClient.Queues.RegenerateKeys(resourceGroup, namespaceName, queueName, authorizationRuleName, regenerateKeysParameters);
Assert.NotEqual(listKeysResponse.SecondaryKey, regenerateKeysResposnse.SecondaryKey);
Assert.NotNull(regenerateKeysResposnse.PrimaryConnectionString);
Assert.NotNull(regenerateKeysResposnse.SecondaryConnectionString);
Assert.NotNull(regenerateKeysResposnse.PrimaryKey);
// Delete Queue authorizationRule
ServiceBusManagementClient.Queues.DeleteAuthorizationRule(resourceGroup, namespaceName, queueName, authorizationRuleName);
TestUtilities.Wait(TimeSpan.FromSeconds(5));
// Delete queue
ServiceBusManagementClient.Queues.Delete(resourceGroup, namespaceName, queueName);
// Delete namespace
ServiceBusManagementClient.Namespaces.Delete(resourceGroup, namespaceName);
}
}
public void DisasterRecoveryCreateGetUpdateDelete()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
InitializeClients(context);
var location = "West Central US";
var location2 = "West Central US";
var resourceGroup = this.ResourceManagementClient.TryGetResourceGroup(location);
if (string.IsNullOrWhiteSpace(resourceGroup))
{
resourceGroup = TestUtilities.GenerateName(ServiceBusManagementHelper.ResourceGroupPrefix);
this.ResourceManagementClient.TryRegisterResourceGroup(location, resourceGroup);
}
var namespaceName = TestUtilities.GenerateName(ServiceBusManagementHelper.NamespacePrefix);
// Create namespace 1
var createNamespaceResponse = this.ServiceBusManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName,
new SBNamespace()
{
Location = location,
Sku = new SBSku
{
Name = SkuName.Premium,
Tier = SkuTier.Premium,
Capacity = 1
},
Tags = new Dictionary <string, string>()
{
{ "tag1", "value1" },
{ "tag2", "value2" }
}
});
Assert.NotNull(createNamespaceResponse);
Assert.Equal(createNamespaceResponse.Name, namespaceName);
TestUtilities.Wait(TimeSpan.FromSeconds(30));
//var createNamespaceResponse = this.ServiceBusManagementClient.Namespaces.Get(resourceGroup, namespaceName);
//// Create namespace 2
var namespaceName2 = TestUtilities.GenerateName(ServiceBusManagementHelper.NamespacePrefix);
var createNamespaceResponse2 = this.ServiceBusManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName2,
new SBNamespace()
{
Location = location2,
Sku = new SBSku
{
Name = SkuName.Premium,
Tier = SkuTier.Premium,
Capacity = 1
},
Tags = new Dictionary <string, string>()
{
{ "tag1", "value1" },
{ "tag2", "value2" }
}
});
Assert.NotNull(createNamespaceResponse2);
Assert.Equal(createNamespaceResponse2.Name, namespaceName2);
TestUtilities.Wait(TimeSpan.FromSeconds(5));
// Create a namespace AuthorizationRule
var authorizationRuleName = TestUtilities.GenerateName(ServiceBusManagementHelper.AuthorizationRulesPrefix);
var createAutorizationRuleParameter = new SBAuthorizationRule()
{
Rights = new List <AccessRights?>()
{
AccessRights.Listen, AccessRights.Send
}
};
var createNamespaceAuthorizationRuleResponse = ServiceBusManagementClient.Namespaces.CreateOrUpdateAuthorizationRule(resourceGroup, namespaceName,
authorizationRuleName, createAutorizationRuleParameter);
Assert.NotNull(createNamespaceAuthorizationRuleResponse);
Assert.True(createNamespaceAuthorizationRuleResponse.Rights.Count == createAutorizationRuleParameter.Rights.Count);
foreach (var right in createAutorizationRuleParameter.Rights)
{
Assert.Contains(createNamespaceAuthorizationRuleResponse.Rights, r => r == right);
}
// Get created namespace AuthorizationRules
var getNamespaceAuthorizationRulesResponse = ServiceBusManagementClient.Namespaces.GetAuthorizationRule(resourceGroup, namespaceName, authorizationRuleName);
Assert.NotNull(getNamespaceAuthorizationRulesResponse);
Assert.True(getNamespaceAuthorizationRulesResponse.Rights.Count == createAutorizationRuleParameter.Rights.Count);
foreach (var right in createAutorizationRuleParameter.Rights)
{
Assert.Contains(getNamespaceAuthorizationRulesResponse.Rights, r => r == right);
}
var getNamespaceAuthorizationRulesListKeysResponse = ServiceBusManagementClient.Namespaces.ListKeys(resourceGroup, namespaceName, authorizationRuleName);
// Create a Disaster Recovery -
var disasterRecoveryName = TestUtilities.GenerateName(ServiceBusManagementHelper.DisasterRecoveryPrefix);
//CheckNameavaliability for Alias
var checknameAlias = ServiceBusManagementClient.DisasterRecoveryConfigs.CheckNameAvailabilityMethod(resourceGroup, namespaceName, new CheckNameAvailability(disasterRecoveryName));
Assert.True(checknameAlias.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 = ServiceBusManagementClient.DisasterRecoveryConfigs.CheckNameAvailabilityMethod(resourceGroup, namespaceName, new CheckNameAvailability(namespaceName));
Assert.True(checknameAliasSame.NameAvailable, "The Alias Name: '" + namespaceName + "' is not avilable");
var DisasterRecoveryResponse = ServiceBusManagementClient.DisasterRecoveryConfigs.CreateOrUpdate(resourceGroup, namespaceName, disasterRecoveryName, new ArmDisasterRecovery()
{
PartnerNamespace = createNamespaceResponse2.Id
});
Assert.NotNull(DisasterRecoveryResponse);
TestUtilities.Wait(TimeSpan.FromSeconds(30));
//// Get the created DisasterRecovery config - Primary
var disasterRecoveryGetResponse = ServiceBusManagementClient.DisasterRecoveryConfigs.Get(resourceGroup, namespaceName, disasterRecoveryName);
Assert.NotNull(disasterRecoveryGetResponse);
Assert.Equal(RoleDisasterRecovery.Primary, disasterRecoveryGetResponse.Role);
//// Get the created DisasterRecovery config - Secondary
var disasterRecoveryGetResponse_Sec = ServiceBusManagementClient.DisasterRecoveryConfigs.Get(resourceGroup, namespaceName2, disasterRecoveryName);
Assert.NotNull(disasterRecoveryGetResponse_Sec);
Assert.Equal(RoleDisasterRecovery.Secondary, disasterRecoveryGetResponse_Sec.Role);
//Get authorization rule thorugh Alias
var getAuthoRuleAliasResponse = ServiceBusManagementClient.DisasterRecoveryConfigs.GetAuthorizationRule(resourceGroup, namespaceName, disasterRecoveryName, authorizationRuleName);
Assert.Equal(getAuthoRuleAliasResponse.Name, getNamespaceAuthorizationRulesResponse.Name);
var getAuthoruleListKeysResponse = ServiceBusManagementClient.DisasterRecoveryConfigs.ListKeys(resourceGroup, namespaceName, disasterRecoveryName, authorizationRuleName);
var disasterRecoveryGetResponse_Accepted = ServiceBusManagementClient.DisasterRecoveryConfigs.Get(resourceGroup, namespaceName, disasterRecoveryName);
while (ServiceBusManagementClient.DisasterRecoveryConfigs.Get(resourceGroup, namespaceName, disasterRecoveryName).ProvisioningState != ProvisioningStateDR.Succeeded)
{
TestUtilities.Wait(TimeSpan.FromSeconds(10));
}
//// Break Pairing
ServiceBusManagementClient.DisasterRecoveryConfigs.BreakPairing(resourceGroup, namespaceName, disasterRecoveryName);
TestUtilities.Wait(TimeSpan.FromSeconds(10));
while (ServiceBusManagementClient.DisasterRecoveryConfigs.Get(resourceGroup, namespaceName, disasterRecoveryName).ProvisioningState != ProvisioningStateDR.Succeeded)
{
TestUtilities.Wait(TimeSpan.FromSeconds(10));
}
var DisasterRecoveryResponse_update = ServiceBusManagementClient.DisasterRecoveryConfigs.CreateOrUpdate(resourceGroup, namespaceName, disasterRecoveryName, new ArmDisasterRecovery()
{
PartnerNamespace = createNamespaceResponse2.Id
});
Assert.NotNull(DisasterRecoveryResponse_update);
TestUtilities.Wait(TimeSpan.FromSeconds(10));
while (ServiceBusManagementClient.DisasterRecoveryConfigs.Get(resourceGroup, namespaceName, disasterRecoveryName).ProvisioningState != ProvisioningStateDR.Succeeded)
{
TestUtilities.Wait(TimeSpan.FromSeconds(10));
}
// Fail over
ServiceBusManagementClient.DisasterRecoveryConfigs.FailOver(resourceGroup, namespaceName2, disasterRecoveryName);
TestUtilities.Wait(TimeSpan.FromSeconds(10));
while (ServiceBusManagementClient.DisasterRecoveryConfigs.Get(resourceGroup, namespaceName2, disasterRecoveryName).ProvisioningState != ProvisioningStateDR.Succeeded)
{
TestUtilities.Wait(TimeSpan.FromSeconds(10));
}
// Get all Disaster Recovery for a given NameSpace
var getListisasterRecoveryResponse = ServiceBusManagementClient.DisasterRecoveryConfigs.List(resourceGroup, namespaceName2);
Assert.NotNull(getListisasterRecoveryResponse);
Assert.True(getListisasterRecoveryResponse.Count <ArmDisasterRecovery>() >= 1);
// Delete the DisasterRecovery
ServiceBusManagementClient.DisasterRecoveryConfigs.Delete(resourceGroup, namespaceName2, disasterRecoveryName);
// Delete Namespace using Async
ServiceBusManagementClient.Namespaces.DeleteWithHttpMessagesAsync(resourceGroup, namespaceName, null, new CancellationToken()).ConfigureAwait(false);
ServiceBusManagementClient.Namespaces.DeleteWithHttpMessagesAsync(resourceGroup, namespaceName2, null, new CancellationToken()).ConfigureAwait(false);
}
}
public SharedAccessAuthorizationRuleAttributes GetServiceBusQueueAuthorizationRules(string resourceGroupName, string namespaceName, string queueName, string authRuleName)
{
SBAuthorizationRule response = Client.Queues.GetAuthorizationRule(resourceGroupName, namespaceName, queueName, authRuleName);
return(new SharedAccessAuthorizationRuleAttributes(response));
}
protected override async Task <SecretData> RotateValue(Parameters parameters, RotationContext context, CancellationToken cancellationToken)
{
var client = await CreateManagementClient(parameters, cancellationToken);
var accessPolicyName = context.SecretName + "-access-policy";
var rule = new SBAuthorizationRule(new List <AccessRights?>(), name: accessPolicyName);
bool updateRule = false;
foreach (var c in parameters.Permissions)
{
switch (c)
{
case 's':
rule.Rights.Add(AccessRights.Send);
break;
case 'l':
rule.Rights.Add(AccessRights.Listen);
break;
case 'm':
rule.Rights.Add(AccessRights.Manage);
break;
default:
throw new ArgumentException($"Invalid permission specification '{c}'");
}
}
try
{
var existingRule = await client.Namespaces.GetAuthorizationRuleAsync(parameters.ResourceGroup, parameters.Namespace, accessPolicyName, cancellationToken);
if (existingRule.Rights.Count != rule.Rights.Count ||
existingRule.Rights.Zip(rule.Rights).Any((p) => p.First != p.Second))
{
updateRule = true;
}
}
catch (ErrorResponseException e) when(e.Response.StatusCode == HttpStatusCode.NotFound)
{
updateRule = true;
}
if (updateRule)
{
await client.Namespaces.CreateOrUpdateAuthorizationRuleAsync(parameters.ResourceGroup, parameters.Namespace,
accessPolicyName, rule, cancellationToken);
}
var currentKey = context.GetValue("currentKey", "primary");
AccessKeys keys;
string result;
switch (currentKey)
{
case "primary":
keys = await client.Namespaces.RegenerateKeysAsync(parameters.ResourceGroup, parameters.Namespace, accessPolicyName,
new RegenerateAccessKeyParameters(KeyType.SecondaryKey), cancellationToken);
result = keys.SecondaryConnectionString;
context.SetValue("currentKey", "secondary");
break;
case "secondary":
keys = await client.Namespaces.RegenerateKeysAsync(parameters.ResourceGroup, parameters.Namespace, accessPolicyName,
new RegenerateAccessKeyParameters(KeyType.PrimaryKey), cancellationToken);
result = keys.PrimaryConnectionString;
context.SetValue("currentKey", "primary");
break;
default:
throw new InvalidOperationException($"Unexpected 'currentKey' value '{currentKey}'.");
}
return(new SecretData(result, DateTimeOffset.MaxValue, _clock.UtcNow.AddMonths(6)));
}
public void NamespaceCreateGetUpdateDeleteAuthorizationRules()
{
using (MockContext context = MockContext.Start(this.GetType()))
{
InitializeClients(context);
var location = this.ResourceManagementClient.GetLocationFromProvider();
var resourceGroup = this.ResourceManagementClient.TryGetResourceGroup(location);
if (string.IsNullOrWhiteSpace(resourceGroup))
{
resourceGroup = TestUtilities.GenerateName(ServiceBusManagementHelper.ResourceGroupPrefix);
this.ResourceManagementClient.TryRegisterResourceGroup(location, resourceGroup);
}
// Create a namespace
var namespaceName = TestUtilities.GenerateName(ServiceBusManagementHelper.NamespacePrefix);
var createNamespaceResponse = ServiceBusManagementClient.Namespaces.CreateOrUpdate(resourceGroup, namespaceName,
new SBNamespace()
{
Location = location,
Tags = new Dictionary <string, string>()
{
{ "tag1", "value1" },
{ "tag2", "value2" }
}
});
Assert.NotNull(createNamespaceResponse);
Assert.Equal(createNamespaceResponse.Name, namespaceName);
TestUtilities.Wait(TimeSpan.FromSeconds(5));
// Get the created namespace
var getNamespaceResponse = ServiceBusManagementClient.Namespaces.Get(resourceGroup, namespaceName);
if (string.Compare(getNamespaceResponse.ProvisioningState, "Succeeded", true) != 0)
{
TestUtilities.Wait(TimeSpan.FromSeconds(5));
}
getNamespaceResponse = ServiceBusManagementClient.Namespaces.Get(resourceGroup, namespaceName);
Assert.NotNull(getNamespaceResponse);
Assert.Equal("Succeeded", getNamespaceResponse.ProvisioningState, StringComparer.CurrentCultureIgnoreCase);
Assert.Equal(location, getNamespaceResponse.Location, StringComparer.CurrentCultureIgnoreCase);
// Create a namespace AuthorizationRule
var authorizationRuleName = TestUtilities.GenerateName(ServiceBusManagementHelper.AuthorizationRulesPrefix);
string createPrimaryKey = HttpMockServer.GetVariable("CreatePrimaryKey", ServiceBusManagementHelper.GenerateRandomKey());
var createAutorizationRuleParameter = new SBAuthorizationRule()
{
Rights = new List <AccessRights?>()
{
AccessRights.Listen, AccessRights.Send
}
};
var jsonStr = ServiceBusManagementHelper.ConvertObjectToJSon(createAutorizationRuleParameter);
var createNamespaceAuthorizationRuleResponse = ServiceBusManagementClient.Namespaces.CreateOrUpdateAuthorizationRule(resourceGroup, namespaceName,
authorizationRuleName, createAutorizationRuleParameter);
Assert.NotNull(createNamespaceAuthorizationRuleResponse);
Assert.True(createNamespaceAuthorizationRuleResponse.Rights.Count == createAutorizationRuleParameter.Rights.Count);
foreach (var right in createAutorizationRuleParameter.Rights)
{
Assert.Contains(createNamespaceAuthorizationRuleResponse.Rights, r => r == right);
}
// Get default namespace AuthorizationRules
var getNamespaceAuthorizationRulesResponse = ServiceBusManagementClient.Namespaces.GetAuthorizationRule(resourceGroup, namespaceName, ServiceBusManagementHelper.DefaultNamespaceAuthorizationRule);
Assert.NotNull(getNamespaceAuthorizationRulesResponse);
Assert.Equal(getNamespaceAuthorizationRulesResponse.Name, ServiceBusManagementHelper.DefaultNamespaceAuthorizationRule);
Assert.Contains(getNamespaceAuthorizationRulesResponse.Rights, r => r == AccessRights.Listen);
Assert.Contains(getNamespaceAuthorizationRulesResponse.Rights, r => r == AccessRights.Send);
Assert.Contains(getNamespaceAuthorizationRulesResponse.Rights, r => r == AccessRights.Manage);
// Get created namespace AuthorizationRules
getNamespaceAuthorizationRulesResponse = ServiceBusManagementClient.Namespaces.GetAuthorizationRule(resourceGroup, namespaceName, authorizationRuleName);
Assert.NotNull(getNamespaceAuthorizationRulesResponse);
Assert.True(getNamespaceAuthorizationRulesResponse.Rights.Count == createAutorizationRuleParameter.Rights.Count);
foreach (var right in createAutorizationRuleParameter.Rights)
{
Assert.Contains(getNamespaceAuthorizationRulesResponse.Rights, r => r == right);
}
// Get all namespaces AuthorizationRules
var getAllNamespaceAuthorizationRulesResponse = ServiceBusManagementClient.Namespaces.ListAuthorizationRules(resourceGroup, namespaceName);
Assert.NotNull(getAllNamespaceAuthorizationRulesResponse);
Assert.True(getAllNamespaceAuthorizationRulesResponse.Count() > 1);
Assert.Contains(getAllNamespaceAuthorizationRulesResponse, ns => ns.Name == authorizationRuleName);
Assert.Contains(getAllNamespaceAuthorizationRulesResponse, auth => auth.Name == ServiceBusManagementHelper.DefaultNamespaceAuthorizationRule);
// Update namespace authorizationRule
string updatePrimaryKey = HttpMockServer.GetVariable("UpdatePrimaryKey", ServiceBusManagementHelper.GenerateRandomKey());
SBAuthorizationRule updateNamespaceAuthorizationRuleParameter = new SBAuthorizationRule();
updateNamespaceAuthorizationRuleParameter.Rights = new List <AccessRights?>()
{
AccessRights.Listen
};
var updateNamespaceAuthorizationRuleResponse = ServiceBusManagementClient.Namespaces.CreateOrUpdateAuthorizationRule(resourceGroup,
namespaceName, authorizationRuleName, updateNamespaceAuthorizationRuleParameter);
Assert.NotNull(updateNamespaceAuthorizationRuleResponse);
Assert.Equal(authorizationRuleName, updateNamespaceAuthorizationRuleResponse.Name);
Assert.True(updateNamespaceAuthorizationRuleResponse.Rights.Count == updateNamespaceAuthorizationRuleParameter.Rights.Count);
foreach (var right in updateNamespaceAuthorizationRuleParameter.Rights)
{
Assert.Contains(updateNamespaceAuthorizationRuleResponse.Rights, r => r.Equals(right));
}
// Get the updated namespace AuthorizationRule
var getNamespaceAuthorizationRuleResponse = ServiceBusManagementClient.Namespaces.GetAuthorizationRule(resourceGroup, namespaceName, authorizationRuleName);
Assert.NotNull(getNamespaceAuthorizationRuleResponse);
Assert.Equal(authorizationRuleName, getNamespaceAuthorizationRuleResponse.Name);
Assert.True(getNamespaceAuthorizationRuleResponse.Rights.Count == updateNamespaceAuthorizationRuleParameter.Rights.Count);
foreach (var right in updateNamespaceAuthorizationRuleParameter.Rights)
{
Assert.Contains(getNamespaceAuthorizationRuleResponse.Rights, r => r.Equals(right));
}
// Get the connectionString to the namespace for a Authorization rule created
var listKeysResponse = ServiceBusManagementClient.Namespaces.ListKeys(resourceGroup, namespaceName, authorizationRuleName);
Assert.NotNull(listKeysResponse);
Assert.NotNull(listKeysResponse.PrimaryConnectionString);
Assert.NotNull(listKeysResponse.SecondaryConnectionString);
// Regenerate AuthorizationRules
//Primary
var regenerateKeysParameters = new RegenerateAccessKeyParameters();
regenerateKeysParameters.KeyType = KeyType.PrimaryKey;
var regenerateKeysResponse = ServiceBusManagementClient.Namespaces.RegenerateKeys(resourceGroup, namespaceName, authorizationRuleName, regenerateKeysParameters);
Assert.NotNull(regenerateKeysResponse);
Assert.NotEqual(regenerateKeysResponse.PrimaryKey, listKeysResponse.PrimaryKey);
Assert.Equal(regenerateKeysResponse.SecondaryKey, listKeysResponse.SecondaryKey);
//Secondary
regenerateKeysParameters.KeyType = KeyType.SecondaryKey;
var regenerateSecondaryKeyResponse = ServiceBusManagementClient.Namespaces.RegenerateKeys(resourceGroup, namespaceName, authorizationRuleName, regenerateKeysParameters);
Assert.NotNull(regenerateSecondaryKeyResponse);
Assert.NotEqual(regenerateSecondaryKeyResponse.SecondaryKey, listKeysResponse.SecondaryKey);
Assert.Equal(regenerateSecondaryKeyResponse.PrimaryKey, regenerateKeysResponse.PrimaryKey);
// Delete namespace authorizationRule
ServiceBusManagementClient.Namespaces.DeleteAuthorizationRule(resourceGroup, namespaceName, authorizationRuleName);
TestUtilities.Wait(TimeSpan.FromSeconds(5));
// Delete namespace
ServiceBusManagementClient.Namespaces.Delete(resourceGroup, namespaceName);
}
}
