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