1# coding: utf-8 2 3#------------------------------------------------------------------------- 4# Copyright (c) Microsoft Corporation. All rights reserved. 5# Licensed under the MIT License. See License.txt in the project root for 6# license information. 7#-------------------------------------------------------------------------- 8 9# coverd ops: 10# management_locks: 16/16 11# authorization_operations: 1/1 12 13import unittest 14 15import azure.mgmt.resource 16from devtools_testutils import AzureMgmtTestCase, RandomNameResourceGroupPreparer 17 18class MgmtResourceLocksTest(AzureMgmtTestCase): 19 20 def setUp(self): 21 super(MgmtResourceLocksTest, self).setUp() 22 self.locks_client = self.create_mgmt_client( 23 azure.mgmt.resource.ManagementLockClient 24 ) 25 26 self.resource_client = self.create_mgmt_client( 27 azure.mgmt.resource.ResourceManagementClient 28 ) 29 30 def test_locks_at_subscription_level(self): 31 lock_name = 'pylockrg' 32 33 lock = self.locks_client.management_locks.create_or_update_at_subscription_level( 34 lock_name, 35 { 36 'level': 'CanNotDelete' 37 } 38 ) 39 self.assertIsNotNone(lock) 40 41 self.locks_client.management_locks.get_at_subscription_level( 42 lock_name 43 ) 44 45 locks = list(self.locks_client.management_locks.list_at_subscription_level()) 46 47 lock = self.locks_client.management_locks.delete_at_subscription_level( 48 lock_name 49 ) 50 51 @RandomNameResourceGroupPreparer() 52 def test_locks_by_scope(self, resource_group): 53 lock_name = "pylockrg" 54 SUBSCRIPTION_ID = self.settings.SUBSCRIPTION_ID 55 resource_name = self.get_resource_name("pytestavset") 56 57 resource_id = "/subscriptions/{guid}/resourceGroups/{resourcegroupname}/providers/{resourceprovidernamespace}/{resourcetype}/{resourcename}".format( 58 guid=SUBSCRIPTION_ID, 59 resourcegroupname=resource_group.name, 60 resourceprovidernamespace="Microsoft.Compute", 61 resourcetype="availabilitySets", 62 resourcename=resource_name 63 ) 64 65 create_result = self.resource_client.resources.begin_create_or_update_by_id( 66 resource_id, 67 parameters={'location': self.region}, 68 api_version="2019-07-01" 69 ) 70 71 lock = self.locks_client.management_locks.create_or_update_by_scope( 72 resource_id, 73 lock_name, 74 { 75 'level': 'CanNotDelete' 76 } 77 ) 78 79 self.locks_client.management_locks.get_by_scope( 80 resource_id, 81 lock_name 82 ) 83 84 self.locks_client.management_locks.list_by_scope( 85 resource_id 86 ) 87 88 self.locks_client.management_locks.delete_by_scope( 89 resource_id, 90 lock_name 91 ) 92 93 result = self.resource_client.resources.begin_delete_by_id( 94 resource_id, 95 api_version="2019-07-01" 96 ) 97 result = result.result() 98 99 @RandomNameResourceGroupPreparer() 100 def test_locks_at_resource_level(self, resource_group, location): 101 lock_name = 'pylockrg' 102 resource_name = self.get_resource_name("pytestavset") 103 104 # create resource 105 create_result = self.resource_client.resources.begin_create_or_update( 106 resource_group_name=resource_group.name, 107 resource_provider_namespace="Microsoft.Compute", 108 parent_resource_path="", 109 resource_type="availabilitySets", 110 resource_name=resource_name, 111 parameters={'location': self.region}, 112 api_version="2019-07-01" 113 ) 114 115 lock = self.locks_client.management_locks.create_or_update_at_resource_level( 116 resource_group_name=resource_group.name, 117 resource_provider_namespace="Microsoft.Compute", 118 parent_resource_path="", 119 resource_type="availabilitySets", 120 resource_name=resource_name, 121 lock_name=lock_name, 122 parameters={ 123 'level': 'CanNotDelete' 124 } 125 ) 126 self.assertIsNotNone(lock) 127 128 self.locks_client.management_locks.get_at_resource_level( 129 resource_group_name=resource_group.name, 130 resource_provider_namespace="Microsoft.Compute", 131 parent_resource_path="", 132 resource_type="availabilitySets", 133 resource_name=resource_name, 134 lock_name=lock_name, 135 ) 136 137 locks = list(self.locks_client.management_locks.list_at_resource_level( 138 resource_group_name=resource_group.name, 139 resource_provider_namespace="Microsoft.Compute", 140 parent_resource_path="", 141 resource_type="availabilitySets", 142 resource_name=resource_name, 143 )) 144 self.assertEqual(len(locks), 1) 145 146 lock = self.locks_client.management_locks.delete_at_resource_level( 147 resource_group_name=resource_group.name, 148 resource_provider_namespace="Microsoft.Compute", 149 parent_resource_path="", 150 resource_type="availabilitySets", 151 resource_name=resource_name, 152 lock_name=lock_name, 153 ) 154 155 # delete resource 156 delete_result = self.resource_client.resources.begin_delete( 157 resource_group_name=resource_group.name, 158 resource_provider_namespace="Microsoft.Compute", 159 parent_resource_path="", 160 resource_type="availabilitySets", 161 resource_name=resource_name, 162 api_version="2019-07-01" 163 ) 164 delete_result.wait() 165 166 @RandomNameResourceGroupPreparer() 167 def test_locks_at_resource_group_level(self, resource_group, location): 168 lock_name = 'pylockrg' 169 170 lock = self.locks_client.management_locks.create_or_update_at_resource_group_level( 171 resource_group.name, 172 lock_name, 173 { 174 'level': 'CanNotDelete' 175 } 176 ) 177 self.assertIsNotNone(lock) 178 179 self.locks_client.management_locks.get_at_resource_group_level( 180 resource_group.name, 181 lock_name 182 ) 183 184 locks = list(self.locks_client.management_locks.list_at_resource_group_level( 185 resource_group.name 186 )) 187 self.assertEqual(len(locks), 1) 188 189 lock = self.locks_client.management_locks.delete_at_resource_group_level( 190 resource_group.name, 191 lock_name 192 ) 193 194 def test_operations(self): 195 self.locks_client.authorization_operations.list() 196 197 198#------------------------------------------------------------------------------ 199if __name__ == '__main__': 200 unittest.main() 201