def test_sb_queue_curd(self, resource_group, location):
# List all topic types
resource_group_name = resource_group.name
# Create a Namespace
namespace_name = self.get_replayable_random_resource_name(
"testingpythontestcasequeue")
namespaceparameter = SBNamespace(location=location,
tags={
'tag1': 'value1',
'tag2': 'value2'
},
sku=SBSku(name=SkuName.standard))
creatednamespace = self.servicebus_client.namespaces.create_or_update(
resource_group_name, namespace_name, namespaceparameter).result()
self.assertEqual(creatednamespace.name, namespace_name)
while (self.servicebus_client.namespaces.get(
resource_group_name, namespace_name).provisioning_state !=
'Succeeded'):
if self.is_live:
time.sleep(15)
continue
# Create a Queue
queue_name = self.get_replayable_random_resource_name(
"testingpythonsdkqueue")
createqueueresponse = self.servicebus_client.queues.create_or_update(
resource_group_name, namespace_name, queue_name, SBQueue())
self.assertEqual(createqueueresponse.name, queue_name)
# Get the created Queue
getqueueresponse = self.servicebus_client.queues.get(
resource_group_name, namespace_name, queue_name)
self.assertEqual(getqueueresponse.name, queue_name)
# Get all the queues
listbynamespacequeueresponse = list(
self.servicebus_client.queues.list_by_namespace(
resource_group_name, namespace_name))
self.assertEqual(len(listbynamespacequeueresponse), 1)
self.assertEqual(listbynamespacequeueresponse[0].name, queue_name)
# update queue
updatequeueresponse = self.servicebus_client.queues.create_or_update(
resource_group_name, namespace_name, queue_name,
SBQueue(enable_express=True,
max_delivery_count=5,
max_size_in_megabytes=1024))
self.assertEqual(updatequeueresponse.name, queue_name)
self.assertEqual(updatequeueresponse.max_delivery_count, 5)
self.assertEqual(updatequeueresponse.max_size_in_megabytes, 1024)
self.assertEqual(updatequeueresponse.enable_express, True)
# Create a new authorizationrule
authoRule_name = self.get_replayable_random_resource_name(
"testingauthrulepy")
createqueueauthorule = self.servicebus_client.queues.create_or_update_authorization_rule(
resource_group_name, namespace_name, queue_name, authoRule_name,
[AccessRights('Send'),
AccessRights('Listen')])
self.assertEqual(
createqueueauthorule.name, authoRule_name,
"Authorization rule name not as created - create_or_update_authorization_rule "
)
self.assertEqual(len(createqueueauthorule.rights), 2)
# Get the created authorizationrule
getqueueauthorule = self.servicebus_client.queues.get_authorization_rule(
resource_group_name, namespace_name, queue_name, authoRule_name)
self.assertEqual(
getqueueauthorule.name, authoRule_name,
"Authorization rule name not as passed as parameter - get_authorization_rule"
)
self.assertEqual(
len(getqueueauthorule.rights), 2,
"Access rights mis match as created - get_authorization_rule ")
# update the rights of the authorizatiorule
getqueueauthorule.rights.append('Manage')
updatequeueauthorule = self.servicebus_client.queues.create_or_update_authorization_rule(
resource_group_name, namespace_name, queue_name, authoRule_name,
getqueueauthorule.rights)
self.assertEqual(
updatequeueauthorule.name, authoRule_name,
"Authorization rule name not as passed as parameter for update call - create_or_update_authorization_rule "
)
self.assertEqual(
len(updatequeueauthorule.rights), 3,
"Access rights mis match as updated - create_or_update_authorization_rule "
)
# list all the authorization ruels for the given Queue
listqueueauthorule = list(
self.servicebus_client.queues.list_authorization_rules(
resource_group_name, namespace_name, queue_name))
self.assertEqual(
len(listqueueauthorule), 1,
"number of authorization rule mismatch, created = 1 - list_authorization_rules"
)
# List keys for the authorization rule
listkeysauthorizationrule = self.servicebus_client.queues.list_keys(
resource_group_name, namespace_name, queue_name, authoRule_name)
self.assertIsNotNone(listkeysauthorizationrule)
# regenerate Keys for authorizationrule - Primary
regenratePrimarykeyauthorizationrule = self.servicebus_client.queues.regenerate_keys(
resource_group_name, namespace_name, queue_name, authoRule_name,
'PrimaryKey')
self.assertNotEqual(listkeysauthorizationrule.primary_key,
regenratePrimarykeyauthorizationrule.primary_key)
# regenerate Keys for authorizationrule - Primary
regenrateSecondarykeyauthorizationrule = self.servicebus_client.queues.regenerate_keys(
resource_group_name, namespace_name, queue_name, authoRule_name,
'SecondaryKey')
self.assertNotEqual(
listkeysauthorizationrule.secondary_key,
regenrateSecondarykeyauthorizationrule.secondary_key)
# delete the authorizationrule
self.servicebus_client.queues.delete_authorization_rule(
resource_group_name, namespace_name, queue_name, authoRule_name)
# list all the authorization ruels for the given Queue
listqueueauthorule = list(
self.servicebus_client.queues.list_authorization_rules(
resource_group_name, namespace_name, queue_name))
lenTemp = len(listqueueauthorule)
# delete the Queue
self.servicebus_client.queues.delete(resource_group_name,
namespace_name, queue_name)
# Delete the create namespace
deletenamespace = self.servicebus_client.namespaces.delete(
resource_group_name, namespace_name).result()
def test_sb_topic_curd(self, resource_group, location):
# List all topic types
resource_group_name = resource_group.name # "ardsouza-resourcemovetest-group2"
# Create a Namespace
namespace_name = "testingpythontestcasetopic"
namespaceparameter = SBNamespace(location, {
'tag1': 'value1',
'tag2': 'value2'
}, SBSku(SkuName.standard))
creatednamespace = self.servicebus_client.namespaces.create_or_update(
resource_group_name, namespace_name, namespaceparameter, None,
True).output
self.assertEqual(creatednamespace.name, namespace_name)
while (self.servicebus_client.namespaces.get(
resource_group_name, namespace_name).provisioning_state !=
'Succeeded'):
if self.is_live:
time.sleep(15)
continue
# Create a Topic
topic_name = "testingpythonsdktopic"
createtopicresponse = self.servicebus_client.topics.create_or_update(
resource_group_name, namespace_name, topic_name, SBTopic())
self.assertEqual(createtopicresponse.name, topic_name)
# Get the created Topic
gettopicresponse = self.servicebus_client.topics.get(
resource_group_name, namespace_name, topic_name)
self.assertEqual(gettopicresponse.name, topic_name)
# Get all the topics
listbynamespacetopicresponse = list(
self.servicebus_client.topics.list_by_namespace(
resource_group_name, namespace_name))
self.assertEqual(len(listbynamespacetopicresponse), 1)
self.assertEqual(listbynamespacetopicresponse[0].name, topic_name)
# update topic
updatetopicresponse = self.servicebus_client.topics.create_or_update(
resource_group_name, namespace_name, topic_name,
SBTopic(enable_express=True,
enable_batched_operations=True,
max_size_in_megabytes=1024))
self.assertEqual(updatetopicresponse.name, topic_name)
self.assertEqual(updatetopicresponse.enable_batched_operations, True)
self.assertEqual(updatetopicresponse.max_size_in_megabytes, 1024)
self.assertEqual(updatetopicresponse.enable_express, True)
# Create a new authorizationrule
authoRule_name = "testingauthrulepy"
createtopicauthorule = self.servicebus_client.topics.create_or_update_authorization_rule(
resource_group_name, namespace_name, topic_name, authoRule_name,
[AccessRights('Send'),
AccessRights('Listen')])
self.assertEqual(
createtopicauthorule.name, authoRule_name,
"Authorization rule name not as created - create_or_update_authorization_rule "
)
self.assertEqual(len(createtopicauthorule.rights), 2)
# Get the created authorizationrule
gettopicauthorule = self.servicebus_client.topics.get_authorization_rule(
resource_group_name, namespace_name, topic_name, authoRule_name)
self.assertEqual(
gettopicauthorule.name, authoRule_name,
"Authorization rule name not as passed as parameter - get_authorization_rule"
)
self.assertEqual(
len(gettopicauthorule.rights), 2,
"Access rights mis match as created - get_authorization_rule ")
# update the rights of the authorizatiorule
gettopicauthorule.rights.append('Manage')
updatetopicauthorule = self.servicebus_client.topics.create_or_update_authorization_rule(
resource_group_name, namespace_name, topic_name, authoRule_name,
gettopicauthorule.rights)
self.assertEqual(
updatetopicauthorule.name, authoRule_name,
"Authorization rule name not as passed as parameter for update call - create_or_update_authorization_rule "
)
self.assertEqual(
len(updatetopicauthorule.rights), 3,
"Access rights mis match as updated - create_or_update_authorization_rule "
)
# list all the authorization ruels for the given Topic
listtopicauthorule = list(
self.servicebus_client.topics.list_authorization_rules(
resource_group_name, namespace_name, topic_name))
self.assertEqual(
len(listtopicauthorule), 1,
"number of authorization rule mismatch, created = 1 - list_authorization_rules"
)
# List keys for the authorization rule
listkeysauthorizationrule = self.servicebus_client.topics.list_keys(
resource_group_name, namespace_name, topic_name, authoRule_name)
self.assertIsNotNone(listkeysauthorizationrule)
# regenerate Keys for authorizationrule - Primary
regenratePrimarykeyauthorizationrule = self.servicebus_client.topics.regenerate_keys(
resource_group_name, namespace_name, topic_name, authoRule_name,
'PrimaryKey')
self.assertNotEqual(listkeysauthorizationrule.primary_key,
regenratePrimarykeyauthorizationrule.primary_key)
# regenerate Keys for authorizationrule - Primary
regenrateSecondarykeyauthorizationrule = self.servicebus_client.topics.regenerate_keys(
resource_group_name, namespace_name, topic_name, authoRule_name,
'SecondaryKey')
self.assertNotEqual(
listkeysauthorizationrule.secondary_key,
regenrateSecondarykeyauthorizationrule.secondary_key)
# delete the authorizationrule
self.servicebus_client.topics.delete_authorization_rule(
resource_group_name, namespace_name, topic_name, authoRule_name)
# list all the authorization ruels for the given Topic
listtopicauthorule = list(
self.servicebus_client.topics.list_authorization_rules(
resource_group_name, namespace_name, topic_name))
lenTemp = len(listtopicauthorule)
# delete the Topic
self.servicebus_client.topics.delete(resource_group_name,
namespace_name, topic_name)
# Delete the create namespace
deletenamespace = self.servicebus_client.namespaces.delete(
resource_group_name, namespace_name, None, True).output
def test_sb_namespace_curd(self, resource_group, location):
# List all topic types
resource_group_name = resource_group.name #"ardsouza-resourcemovetest-group2"
# Create a Namespace
namespace_name = self.get_replayable_random_resource_name(
"testingpythontestcasenamespace")
namespaceparameter = SBNamespace(location=location,
tags={
'tag1': 'value1',
'tag2': 'value2'
},
sku=SBSku(name=SkuName.standard))
creatednamespace = self.servicebus_client.namespaces.create_or_update(
resource_group_name, namespace_name, namespaceparameter).result()
self.assertEqual(creatednamespace.name, namespace_name)
#
# # Get created Namespace
#
getnamespaceresponse = self.servicebus_client.namespaces.get(
resource_group_name, namespace_name)
self.assertEqual(getnamespaceresponse.name, namespace_name)
# Get the List of Namespaces under the resourceGroup - list_by_resource_group
listbyresourcegroupresponse = list(
self.servicebus_client.namespaces.list_by_resource_group(
resource_group_name))
self.assertGreater(len(listbyresourcegroupresponse), 0,
"No Namespace returned, List is empty")
self.assertEqual(listbyresourcegroupresponse[0].name, namespace_name,
"Created namespace not found - ListByResourgroup")
# Get the List of namespace under the subscription - list
listbysubscriptionresponse = list(
self.servicebus_client.namespaces.list())
self.assertGreater(len(listbysubscriptionresponse), 0,
"No Namespace returned, List is empty")
# get the default authorizationrule
defaultauthorule_name = self.get_replayable_random_resource_name(
"RootManageSharedAccessKey")
defaultamespaceauthorule = self.servicebus_client.namespaces.get_authorization_rule(
resource_group_name, namespace_name, defaultauthorule_name)
self.assertEqual(
defaultamespaceauthorule.name, defaultauthorule_name,
"Default Authorization rule not returned - RootManageSharedAccessKey"
)
self.assertEqual(
len(defaultamespaceauthorule.rights), 3,
"rights for deafult not as required - send, listen and manage ")
# Create a new authorizationrule
authoRule_name = self.get_replayable_random_resource_name(
"testingauthrulepy")
createnamespaceauthorule = self.servicebus_client.namespaces.create_or_update_authorization_rule(
resource_group_name, namespace_name, authoRule_name,
[AccessRights('Send'),
AccessRights('Listen')])
self.assertEqual(
createnamespaceauthorule.name, authoRule_name,
"Authorization rule name not as created - create_or_update_authorization_rule "
)
self.assertEqual(len(createnamespaceauthorule.rights), 2)
# Get the created authorizationrule
getnamespaceauthorule = self.servicebus_client.namespaces.get_authorization_rule(
resource_group_name, namespace_name, authoRule_name)
self.assertEqual(
getnamespaceauthorule.name, authoRule_name,
"Authorization rule name not as passed as parameter - get_authorization_rule "
)
self.assertEqual(
len(getnamespaceauthorule.rights), 2,
"Access rights mis match as created - get_authorization_rule ")
# update the rights of the authorizatiorule
getnamespaceauthorule.rights.append('Manage')
updatenamespaceauthorule = self.servicebus_client.namespaces.create_or_update_authorization_rule(
resource_group_name, namespace_name, authoRule_name,
getnamespaceauthorule.rights)
self.assertEqual(
updatenamespaceauthorule.name, authoRule_name,
"Authorization rule name not as passed as parameter for update call - create_or_update_authorization_rule "
)
self.assertEqual(
len(updatenamespaceauthorule.rights), 3,
"Access rights mis match as updated - create_or_update_authorization_rule "
)
#list all the authorization ruels for the given namespace
createnamespaceauthorule = list(
self.servicebus_client.namespaces.list_authorization_rules(
resource_group_name, namespace_name))
self.assertEqual(
len(createnamespaceauthorule), 2,
"number of authorization rule mismatch with the created + default = 2 - list_authorization_rules"
)
#List keys for the authorization rule
listkeysauthorizationrule = self.servicebus_client.namespaces.list_keys(
resource_group_name, namespace_name, authoRule_name)
self.assertIsNotNone(listkeysauthorizationrule)
# regenerate Keys for authorizationrule - Primary
regenratePrimarykeyauthorizationrule = self.servicebus_client.namespaces.regenerate_keys(
resource_group_name, namespace_name, authoRule_name, 'PrimaryKey')
self.assertNotEqual(listkeysauthorizationrule.primary_key,
regenratePrimarykeyauthorizationrule.primary_key)
# regenerate Keys for authorizationrule - Primary
regenrateSecondarykeyauthorizationrule = self.servicebus_client.namespaces.regenerate_keys(
resource_group_name, namespace_name, authoRule_name,
'SecondaryKey')
self.assertNotEqual(
listkeysauthorizationrule.secondary_key,
regenrateSecondarykeyauthorizationrule.secondary_key)
# delete the authorizationrule
self.servicebus_client.namespaces.delete_authorization_rule(
resource_group_name, namespace_name, authoRule_name)
# list all the authorization ruels for the given namespace
createnamespaceauthorule = list(
self.servicebus_client.namespaces.list_authorization_rules(
resource_group_name, namespace_name))
self.assertEqual(len(createnamespaceauthorule), 1)
self.assertEqual(createnamespaceauthorule[0].name,
defaultauthorule_name)
# Delete the create namespace
deletenamespace = self.servicebus_client.namespaces.delete(
resource_group_name, namespace_name).result()