Debian Codegraph @

ansible_collections/netapp/ontap/tests/unit/plugins/modules/test_na_ontap_license.py

raw
1 # (c) 2022-2023, NetApp, Inc
2 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
3
4 ''' unit test for ONTAP license Ansible module '''
5
6 from __future__ import (absolute_import, division, print_function)
7 __metaclass__ = type
8 import sys
9 import pytest
10
11 from ansible_collections.netapp.ontap.tests.unit.compat.mock import patch
12 # pylint: disable=unused-import
13 from ansible_collections.netapp.ontap.tests.unit.plugins.module_utils.ansible_mocks import\
14 assert_no_warnings, call_main, create_module, expect_and_capture_ansible_exception, patch_ansible, print_warnings
15 import ansible_collections.netapp.ontap.plugins.module_utils.netapp as netapp_utils
16 from ansible_collections.netapp.ontap.tests.unit.framework.mock_rest_and_zapi_requests import\
17 patch_request_and_invoke, register_responses
18 from ansible_collections.netapp.ontap.tests.unit.framework.rest_factory import rest_error_message, rest_responses
19 from ansible_collections.netapp.ontap.tests.unit.framework.zapi_factory import build_zapi_response, build_zapi_error, zapi_responses
20
21 from ansible_collections.netapp.ontap.plugins.modules.na_ontap_license import NetAppOntapLicense as my_module, main as my_main, HAS_DEEPDIFF
22
23
24 if not netapp_utils.has_netapp_lib():
25 pytestmark = pytest.mark.skip('skipping as missing required netapp_lib')
26
27
28 if not netapp_utils.HAS_REQUESTS and sys.version_info < (2, 7):
29 pytestmark = pytest.mark.skip('Skipping Unit Tests on 2.6 as requests is not be available')
30
31
32 def license_status(fcp_method):
33 return {
34 'license-v2-status': [
35 {'license-v2-status-info':
36 {
37 'package': 'base',
38 'method': 'site'
39 }},
40 {'license-v2-status-info':
41 {
42 'package': 'capacitypool',
43 'method': 'none'
44 }},
45 {'license-v2-status-info':
46 {
47 'package': 'cifs',
48 'method': 'site'
49 }},
50 {'license-v2-status-info':
51 {
52 'package': 'fcp',
53 'method': fcp_method
54 }},
55 ]
56 }
57
58
59 ZRR = zapi_responses({
60 'license_status_fcp_none': build_zapi_response(license_status('none')),
61 'license_status_fcp_site': build_zapi_response(license_status('site')),
62 'error_object_not_found': build_zapi_error('15661', 'license is not active')
63 })
64
65
66 DEFAULT_ARGS = {
67 'hostname': 'hostname',
68 'username': 'username',
69 'password': 'password',
70 }
71
72
73 @patch('ansible_collections.netapp.ontap.plugins.module_utils.netapp.has_netapp_lib')
74 def test_fail_netapp_lib_error(mock_has_netapp_lib):
75 mock_has_netapp_lib.return_value = False
76 module_args = {
77 "use_rest": "never"
78 }
79 assert 'Error: the python NetApp-Lib module is required. Import error: None' == call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
80
81
82 def test_module_add_license_zapi():
83 ''' Test add license '''
84 register_responses([
85 ('ZAPI', 'license-v2-status-list-info', ZRR['license_status_fcp_none']),
86 ('ZAPI', 'license-v2-add', ZRR['success']),
87 ('ZAPI', 'license-v2-status-list-info', ZRR['license_status_fcp_site']),
88 ])
89 module_args = {
90 'use_rest': 'never',
91 'license_codes': 'LICENSECODE',
92 }
93 print('ZRR', build_zapi_response(license_status('site'))[0].to_string())
94 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
95
96
97 def test_module_add_license_idempotent_zapi():
98 ''' Test add license idempotent '''
99 register_responses([
100 ('ZAPI', 'license-v2-status-list-info', ZRR['license_status_fcp_site']),
101 ('ZAPI', 'license-v2-add', ZRR['success']),
102 ('ZAPI', 'license-v2-status-list-info', ZRR['license_status_fcp_site']),
103 ])
104 module_args = {
105 'use_rest': 'never',
106 'license_codes': 'LICENSECODE',
107 }
108 assert not call_main(my_main, DEFAULT_ARGS, module_args)['changed']
109
110
111 def test_module_remove_license_zapi():
112 ''' Test remove license '''
113 register_responses([
114 ('ZAPI', 'license-v2-status-list-info', ZRR['license_status_fcp_site']),
115 ('ZAPI', 'license-v2-delete', ZRR['success']),
116 ('ZAPI', 'license-v2-delete', ZRR['success']),
117 ])
118 module_args = {
119 'use_rest': 'never',
120 'serial_number': '1-8-000000',
121 'license_names': 'cifs,fcp',
122 'state': 'absent',
123 }
124 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
125
126
127 def test_module_remove_license_idempotent_zapi():
128 ''' Test remove license idempotent '''
129 register_responses([
130 ('ZAPI', 'license-v2-status-list-info', ZRR['license_status_fcp_site']),
131 ('ZAPI', 'license-v2-delete', ZRR['error_object_not_found']),
132 ('ZAPI', 'license-v2-delete', ZRR['error_object_not_found']),
133 ])
134 module_args = {
135 'use_rest': 'never',
136 'serial_number': '1-8-000000',
137 'license_names': 'cifs,fcp',
138 'state': 'absent',
139 }
140 assert not call_main(my_main, DEFAULT_ARGS, module_args)['changed']
141
142
143 def test_module_remove_unused_expired_zapi():
144 ''' Test remove unused expired license '''
145 register_responses([
146 ('ZAPI', 'license-v2-status-list-info', ZRR['license_status_fcp_site']),
147 ('ZAPI', 'license-v2-delete-unused', ZRR['success']),
148 ('ZAPI', 'license-v2-delete-expired', ZRR['success']),
149 ('ZAPI', 'license-v2-status-list-info', ZRR['license_status_fcp_none']),
150 ])
151 module_args = {
152 'use_rest': 'never',
153 'remove_unused': True,
154 'remove_expired': True,
155 }
156 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
157
158
159 def test_module_try_to_remove_non_existent_package_license_zapi():
160 ''' Try to remove non existent license '''
161 register_responses([
162 ('ZAPI', 'license-v2-delete', ZRR['error_object_not_found']),
163 ])
164 module_args = {
165 'use_rest': 'never',
166 'serial_number': '1-8-000000',
167 'license_names': 'cifs',
168 'state': 'absent',
169 }
170 my_obj = create_module(my_module, DEFAULT_ARGS, module_args)
171 license_exist = my_obj.remove_licenses('cifs')
172 assert not license_exist
173
174
175 def test_module_error_add_license_zapi():
176 ''' Test error add license '''
177 register_responses([
178 ('ZAPI', 'license-v2-add', ZRR['error']),
179 ])
180 module_args = {
181 'use_rest': 'never',
182 'license_codes': 'random',
183 }
184 my_obj = create_module(my_module, DEFAULT_ARGS, module_args)
185 assert 'Error adding licenses' in expect_and_capture_ansible_exception(my_obj.add_licenses, 'fail')['msg']
186
187
188 def test_module_error_remove_license_zapi():
189 ''' Test error remove license '''
190 register_responses([
191 ('ZAPI', 'license-v2-delete', ZRR['error']),
192 ])
193 module_args = {
194 'use_rest': 'never',
195 'serial_number': '1-8-000000',
196 'license_names': 'random',
197 'state': 'absent',
198 }
199 my_obj = create_module(my_module, DEFAULT_ARGS, module_args)
200 assert 'Error removing license' in expect_and_capture_ansible_exception(my_obj.remove_licenses, 'fail', 'random')['msg']
201
202
203 def test_module_error_get_and_remove_unused_expired_license_zapi():
204 ''' Test error get and remove unused/expired license '''
205 register_responses([
206 ('ZAPI', 'license-v2-status-list-info', ZRR['error']),
207 ('ZAPI', 'license-v2-delete-unused', ZRR['error']),
208 ('ZAPI', 'license-v2-delete-expired', ZRR['error']),
209 ])
210 module_args = {
211 'use_rest': 'never',
212 }
213 my_obj = create_module(my_module, DEFAULT_ARGS, module_args)
214 assert 'Error checking license status' in expect_and_capture_ansible_exception(my_obj.get_licensing_status, 'fail')['msg']
215 assert 'Error removing unused licenses' in expect_and_capture_ansible_exception(my_obj.remove_unused_licenses, 'fail')['msg']
216 assert 'Error removing expired licenses' in expect_and_capture_ansible_exception(my_obj.remove_expired_licenses, 'fail')['msg']
217
218
219 # REST API canned responses when mocking send_request
220 SRR = rest_responses({
221 'error_entry_does_not_exist': (404, None, "entry doesn't exist"),
222 'license_record': (200, {
223 "num_records": 3,
224 "records": [
225 {
226 "name": "base",
227 "scope": "cluster",
228 "state": "compliant"
229 },
230 {
231 "name": "nfs",
232 "scope": "not_available",
233 "state": "unlicensed"
234 },
235 {
236 "name": "cifs",
237 "scope": "site",
238 "state": "compliant"
239 }]
240 }, None),
241 'license_record_nfs': (200, {
242 "num_records": 3,
243 "records": [
244 {
245 "name": "base",
246 "scope": "cluster",
247 "state": "compliant"
248 },
249 {
250 "name": "nfs",
251 "scope": "site",
252 "state": "compliant"
253 },
254 {
255 "name": "cifs",
256 "scope": "site",
257 "state": "compliant"
258 }]
259 }, None),
260 'license_record_no_nfs': (200, {
261 "num_records": 3,
262 "records": [
263 {
264 "name": "base",
265 "scope": "cluster",
266 "state": "compliant"
267 },
268 {
269 "name": "cifs",
270 "scope": "site",
271 "state": "compliant"
272 }]
273 }, None)
274 }, False)
275
276
277 def test_module_fail_when_unsupported_rest_present():
278 ''' error if unsupported rest properties present '''
279 register_responses([
280 ])
281 module_args = {
282 'remove_unused': True,
283 'remove_expired': True,
284 'use_rest': 'always'
285 }
286 error = 'REST API currently does not support'
287 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
288
289
290 def test_ensure_get_license_status_called_rest():
291 ''' test get'''
292 register_responses([
293 ('GET', 'cluster', SRR['is_rest_9_8_0']),
294 ('GET', 'cluster/licensing/licenses', SRR['license_record']),
295 ])
296 module_args = {
297 'use_rest': 'always'
298 }
299 assert not call_main(my_main, DEFAULT_ARGS, module_args)['changed']
300 assert_no_warnings()
301
302
303 def test_module_error_get_license_rest():
304 ''' test add license'''
305 register_responses([
306 ('GET', 'cluster', SRR['is_rest_9_8_0']),
307 ('GET', 'cluster/licensing/licenses', SRR['generic_error']),
308 ])
309 module_args = {
310 'use_rest': 'always'
311 }
312 error = rest_error_message('', 'cluster/licensing/licenses')
313 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
314 assert_no_warnings()
315
316
317 def test_module_add_license_rest():
318 ''' test add license'''
319 register_responses([
320 ('GET', 'cluster', SRR['is_rest_9_8_0']),
321 ('GET', 'cluster/licensing/licenses', SRR['license_record']), # get license information
322 ('POST', 'cluster/licensing/licenses', SRR['empty_good']), # Apply license
323 ('GET', 'cluster/licensing/licenses', SRR['license_record_nfs']), # get updated license information
324 ])
325 module_args = {
326 'license_codes': 'LICENCECODE',
327 'use_rest': 'always'
328 }
329 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed'] is True
330 if HAS_DEEPDIFF:
331 assert_no_warnings()
332
333
334 def test_module_error_add_license_rest():
335 ''' test add license'''
336 register_responses([
337 ('GET', 'cluster', SRR['is_rest_9_8_0']),
338 ('GET', 'cluster/licensing/licenses', SRR['license_record']), # get license information
339 ('POST', 'cluster/licensing/licenses', SRR['generic_error']), # Error in adding license
340 ])
341 module_args = {
342 'license_codes': 'INVALIDLICENCECODE',
343 'use_rest': 'always'
344 }
345 error = 'calling: cluster/licensing/licenses: got Expected error.'
346 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
347 assert_no_warnings()
348
349
350 def test_module_remove_license():
351 ''' test remove license'''
352 register_responses([
353 ('GET', 'cluster', SRR['is_rest_9_8_0']),
354 ('GET', 'cluster/licensing/licenses', SRR['license_record_nfs']),
355 ('DELETE', 'cluster/licensing/licenses/nfs', SRR['empty_good']), # remove license
356 ])
357 module_args = {
358 'license_names': 'nfs',
359 'serial_number': '1-23-45678',
360 'state': 'absent',
361 'use_rest': 'always'
362 }
363 print_warnings()
364 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed'] is True
365 assert_no_warnings()
366
367
368 def test_module_error_remove_license_rest():
369 ''' test remove license error'''
370 register_responses([
371 ('GET', 'cluster', SRR['is_rest_9_8_0']),
372 ('GET', 'cluster/licensing/licenses', SRR['license_record_nfs']), # get license information
373 ('DELETE', 'cluster/licensing/licenses/nfs', SRR['generic_error']), # Error in removing license
374 ])
375 module_args = {
376 'license_names': 'nfs',
377 'serial_number': '1-23-45678',
378 'state': 'absent',
379 'use_rest': 'always'
380 }
381 error = rest_error_message('Error removing license for serial number 1-23-45678 and nfs', 'cluster/licensing/licenses/nfs')
382 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
383 assert_no_warnings()
384
385
386 def test_module_try_to_remove_license_not_present_rest():
387 ''' test remove license'''
388 register_responses([
389 ('GET', 'cluster', SRR['is_rest_9_8_0']),
390 ('GET', 'cluster/licensing/licenses', SRR['license_record']),
391 ('DELETE', 'cluster/licensing/licenses/nfs', SRR['error_entry_does_not_exist']), # license not active.
392
393 ])
394 module_args = {
395 'license_names': 'nfs',
396 'serial_number': '1-23-45678',
397 'state': 'absent',
398 'use_rest': 'always'
399 }
400 assert not call_main(my_main, DEFAULT_ARGS, module_args)['changed']
401 assert_no_warnings()
402
403
404 @patch('time.sleep')
405 def test_error_mismatch_in_package_list_rest(dont_sleep):
406 ''' test remove license'''
407 register_responses([
408 ('GET', 'cluster', SRR['is_rest_9_8_0']),
409 ('GET', 'cluster/licensing/licenses', SRR['license_record']),
410 # 2nd test
411 ('GET', 'cluster/licensing/licenses', SRR['license_record_no_nfs']),
412 ('GET', 'cluster/licensing/licenses', SRR['license_record_no_nfs']),
413 ('GET', 'cluster/licensing/licenses', SRR['license_record']),
414 # 3rd test
415 ('GET', 'cluster/licensing/licenses', SRR['license_record_no_nfs']),
416 ('GET', 'cluster/licensing/licenses', SRR['license_record_no_nfs']),
417 ('GET', 'cluster/licensing/licenses', SRR['license_record_no_nfs']),
418 ('GET', 'cluster/licensing/licenses', SRR['license_record_no_nfs']),
419 ('GET', 'cluster/licensing/licenses', SRR['license_record_no_nfs']),
420 ])
421 module_args = {
422 'license_names': 'non-existent-package',
423 'serial_number': '1-23-45678',
424 'use_rest': 'always'
425 }
426 my_obj = create_module(my_module, DEFAULT_ARGS, module_args)
427 previous_license_status = {'base': 'compliant', 'nfs': 'unlicensed', 'cifs': 'compliant'}
428 assert my_obj.compare_license_status(previous_license_status) == []
429 previous_license_status = {'base': 'compliant', 'nfs': 'unlicensed', 'cifs': 'unlicensed'}
430 assert my_obj.compare_license_status(previous_license_status) == ['cifs']
431 error = "Error: mismatch in license package names: 'nfs'. Expected:"
432 assert error in expect_and_capture_ansible_exception(my_obj.compare_license_status, 'fail', previous_license_status)['msg']