Debian Codegraph @

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

raw
1 # (c) 2018-2026, 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 FlexCache Ansible module '''
5
6 from __future__ import (absolute_import, division, print_function)
7 __metaclass__ = type
8 import pytest
9
10 from ansible_collections.netapp.ontap.tests.unit.compat.mock import patch
11 import ansible_collections.netapp.ontap.plugins.module_utils.netapp as netapp_utils
12 # pylint: disable=unused-import
13 from ansible_collections.netapp.ontap.tests.unit.framework.mock_rest_and_zapi_requests import\
14 patch_request_and_invoke, register_responses
15 from ansible_collections.netapp.ontap.tests.unit.framework.rest_factory import rest_error_message, rest_responses
16 from ansible_collections.netapp.ontap.tests.unit.framework.zapi_factory import build_zapi_response, build_zapi_error, zapi_error_message, zapi_responses
17 from ansible_collections.netapp.ontap.tests.unit.plugins.module_utils.ansible_mocks import\
18 assert_warning_was_raised, call_main, create_module, expect_and_capture_ansible_exception, patch_ansible, print_warnings
19
20 from ansible_collections.netapp.ontap.plugins.modules.na_ontap_flexcache import NetAppONTAPFlexCache as my_module, main as my_main # module under test
21
22 # if not netapp_utils.has_netapp_lib():
23 # pytestmark = pytest.mark.skip('skipping as missing required netapp_lib')
24
25
26 flexcache_info = {
27 'vserver': 'vserver',
28 'origin-vserver': 'ovserver',
29 'origin-volume': 'ovolume',
30 'origin-cluster': 'ocluster',
31 'volume': 'flexcache_volume',
32 }
33
34 flexcache_get_info = {
35 'attributes-list': [{
36 'flexcache-info': flexcache_info
37 }]
38 }
39
40 flexcache_get_info_double = {
41 'attributes-list': [
42 {
43 'flexcache-info': flexcache_info
44 },
45 {
46 'flexcache-info': flexcache_info
47 }
48 ]
49 }
50
51
52 def results_info(status):
53 return {
54 'result-status': status,
55 'result-jobid': 'job12345',
56 }
57
58
59 def job_info(state, error):
60 return {
61 'num-records': 1,
62 'attributes': {
63 'job-info': {
64 'job-state': state,
65 'job-progress': 'progress',
66 'job-completion': error,
67 }
68 }
69 }
70
71
72 ZRR = zapi_responses({
73 'flexcache_get_info': build_zapi_response(flexcache_get_info, 1),
74 'flexcache_get_info_double': build_zapi_response(flexcache_get_info_double, 2),
75 'job_running': build_zapi_response(job_info('running', None)),
76 'job_success': build_zapi_response(job_info('success', None)),
77 'job_error': build_zapi_response(job_info('failure', 'failure')),
78 'job_error_no_completion': build_zapi_response(job_info('failure', None)),
79 'job_other': build_zapi_response(job_info('other', 'other')),
80 'result_async': build_zapi_response(results_info('in_progress')),
81 'result_error': build_zapi_response(results_info('whatever')),
82 'error_160': build_zapi_error(160, 'Volume volume on Vserver ansibleSVM must be unmounted before being taken offline or restricted'),
83 'error_13001': build_zapi_error(13001, 'Volume volume in Vserver ansibleSVM must be offline to be deleted'),
84 'error_15661': build_zapi_error(15661, 'Job not found'),
85 'error_size': build_zapi_error('size', 'Size "50MB" ("52428800B") is too small. Minimum size is "80MB" ("83886080B")'),
86 })
87
88
89 DEFAULT_ARGS = {
90 'hostname': 'hostname',
91 'username': 'username',
92 'password': 'password',
93 'volume': 'flexcache_volume',
94 'vserver': 'vserver',
95 }
96
97
98 def test_module_fail_when_required_args_missing():
99 ''' required arguments are reported as errors '''
100 register_responses([
101 ])
102 module_args = {
103 'use_rest': 'never'
104 }
105 error = 'missing required arguments:'
106 assert error in call_main(my_main, {}, module_args, fail=True)['msg']
107
108
109 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
110 def test_missing_parameters():
111 ''' fail if origin volume and origin verser are missing '''
112 register_responses([
113 ('ZAPI', 'flexcache-get-iter', ZRR['no_records']),
114 ])
115 module_args = {
116 'use_rest': 'never',
117 }
118 error = 'Missing parameters:'
119 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
120
121
122 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
123 def test_missing_parameter():
124 ''' fail if origin verser parameter is missing '''
125 register_responses([
126 ('ZAPI', 'flexcache-get-iter', ZRR['no_records']),
127 ])
128 module_args = {
129 'use_rest': 'never',
130 'origin_volume': 'origin_volume',
131 }
132 error = 'Missing parameter: origin_vserver'
133 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
134
135
136 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
137 def test_get_flexcache():
138 ''' get flexcache info '''
139 register_responses([
140 ('ZAPI', 'flexcache-get-iter', ZRR['flexcache_get_info']),
141 ])
142 module_args = {
143 'use_rest': 'never',
144 'origin_volume': 'origin_volume',
145 'origin_cluster': 'origin_cluster',
146 }
147 my_obj = create_module(my_module, DEFAULT_ARGS, module_args)
148 info = my_obj.flexcache_get()
149 assert info
150 assert 'origin_cluster' in info
151
152
153 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
154 def test_get_flexcache_double():
155 ''' get flexcache info returns 2 entries! '''
156 register_responses([
157 ('ZAPI', 'flexcache-get-iter', ZRR['flexcache_get_info_double']),
158 ])
159 module_args = {
160 'use_rest': 'never',
161 'origin_volume': 'origin_volume',
162
163 }
164 my_obj = create_module(my_module, DEFAULT_ARGS, module_args)
165 error = 'Error fetching FlexCache info: Multiple records found for %s:' % DEFAULT_ARGS['volume']
166 assert error in expect_and_capture_ansible_exception(my_obj.flexcache_get, 'fail')['msg']
167
168
169 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
170 def test_create_flexcache():
171 ''' create flexcache '''
172 register_responses([
173 ('ZAPI', 'flexcache-get-iter', ZRR['no_records']),
174 ('ZAPI', 'flexcache-create-async', ZRR['result_async']),
175 ('ZAPI', 'job-get', ZRR['job_success']),
176 ])
177 module_args = {
178 'use_rest': 'never',
179 'size': '90', # 80MB minimum
180 'size_unit': 'mb', # 80MB minimum
181 'aggr_list': 'aggr1',
182 'origin_volume': 'fc_vol_origin',
183 'origin_vserver': 'ansibleSVM',
184 }
185 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
186
187
188 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
189 def test_create_flexcach_no_wait():
190 ''' create flexcache '''
191 register_responses([
192 ('ZAPI', 'flexcache-get-iter', ZRR['no_records']),
193 ('ZAPI', 'flexcache-create-async', ZRR['result_async']),
194 ])
195 module_args = {
196 'use_rest': 'never',
197 'size': '90', # 80MB minimum
198 'size_unit': 'mb', # 80MB minimum
199 'aggr_list': 'aggr1',
200 'origin_volume': 'fc_vol_origin',
201 'origin_vserver': 'ansibleSVM',
202 'time_out': 0
203 }
204 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
205
206
207 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
208 def test_error_create_flexcache():
209 ''' create flexcache '''
210 register_responses([
211 ('ZAPI', 'flexcache-get-iter', ZRR['no_records']),
212 ('ZAPI', 'flexcache-create-async', ZRR['result_error']),
213 # 2nd run
214 ('ZAPI', 'flexcache-get-iter', ZRR['no_records']),
215 ('ZAPI', 'flexcache-create-async', ZRR['result_async']),
216 ('ZAPI', 'job-get', ZRR['error']),
217 # 3rd run
218 ('ZAPI', 'flexcache-get-iter', ZRR['no_records']),
219 ('ZAPI', 'flexcache-create-async', ZRR['result_async']),
220 ('ZAPI', 'job-get', ZRR['job_error']),
221 ])
222 module_args = {
223 'use_rest': 'never',
224 'size': '90', # 80MB minimum
225 'size_unit': 'mb', # 80MB minimum
226 'aggr_list': 'aggr1',
227 'origin_volume': 'fc_vol_origin',
228 'origin_vserver': 'ansibleSVM',
229 }
230 error = 'Unexpected error when creating flexcache: results is:'
231 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
232 error = zapi_error_message('Error fetching job info')
233 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
234 error = 'Error when creating flexcache'
235 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
236
237
238 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
239 def test_create_flexcache_idempotent():
240 ''' create flexcache - already exists '''
241 register_responses([
242 ('ZAPI', 'flexcache-get-iter', ZRR['flexcache_get_info']),
243 ])
244 module_args = {
245 'use_rest': 'never',
246 'aggr_list': 'aggr1',
247 'origin_volume': 'ovolume',
248 'origin_vserver': 'ovserver',
249 }
250 assert not call_main(my_main, DEFAULT_ARGS, module_args)['changed']
251
252
253 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
254 def test_create_flexcache_autoprovision():
255 ''' create flexcache with autoprovision'''
256 register_responses([
257 ('ZAPI', 'flexcache-get-iter', ZRR['no_records']),
258 ('ZAPI', 'flexcache-create-async', ZRR['result_async']),
259 ('ZAPI', 'job-get', ZRR['job_success']),
260 ])
261 module_args = {
262 'use_rest': 'never',
263 'size': '90', # 80MB minimum
264 'size_unit': 'mb', # 80MB minimum
265 'auto_provision_as': 'flexgroup',
266 'origin_volume': 'fc_vol_origin',
267 'origin_vserver': 'ansibleSVM',
268 }
269 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
270
271
272 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
273 def test_create_flexcache_autoprovision_idempotent():
274 ''' create flexcache with autoprovision - already exists '''
275 register_responses([
276 ('ZAPI', 'flexcache-get-iter', ZRR['flexcache_get_info']),
277 ])
278 module_args = {
279 'use_rest': 'never',
280 'origin_volume': 'ovolume',
281 'origin_vserver': 'ovserver',
282 'auto_provision_as': 'flexgroup',
283 }
284 assert not call_main(my_main, DEFAULT_ARGS, module_args)['changed']
285
286
287 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
288 def test_create_flexcache_multiplier():
289 ''' create flexcache with aggregate multiplier'''
290 register_responses([
291 ('ZAPI', 'flexcache-get-iter', ZRR['no_records']),
292 ('ZAPI', 'flexcache-create-async', ZRR['result_async']),
293 ('ZAPI', 'job-get', ZRR['job_success']),
294 ])
295 module_args = {
296 'use_rest': 'never',
297 'size': '90', # 80MB minimum
298 'size_unit': 'mb', # 80MB minimum
299 'aggr_list': 'aggr1',
300 'origin_volume': 'fc_vol_origin',
301 'origin_vserver': 'ansibleSVM',
302 'aggr_list_multiplier': 2,
303 }
304 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
305
306
307 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
308 def test_create_flexcache_multiplier_idempotent():
309 ''' create flexcache with aggregate multiplier - already exists '''
310 register_responses([
311 ('ZAPI', 'flexcache-get-iter', ZRR['flexcache_get_info']),
312 ])
313 module_args = {
314 'use_rest': 'never',
315 'aggr_list': 'aggr1',
316 'origin_volume': 'ovolume',
317 'origin_vserver': 'ovserver',
318 'aggr_list_multiplier': 2,
319 }
320 assert not call_main(my_main, DEFAULT_ARGS, module_args)['changed']
321
322
323 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
324 def test_delete_flexcache_exists_no_force():
325 ''' delete flexcache '''
326 register_responses([
327 ('ZAPI', 'flexcache-get-iter', ZRR['flexcache_get_info']),
328 ('ZAPI', 'flexcache-destroy-async', ZRR['error_13001']),
329 ])
330 module_args = {
331 'use_rest': 'never',
332 'state': 'absent'
333 }
334 error = zapi_error_message('Error deleting FlexCache', 13001, 'Volume volume in Vserver ansibleSVM must be offline to be deleted')
335 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
336
337
338 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
339 def test_delete_flexcache_exists_with_force():
340 ''' delete flexcache '''
341 register_responses([
342 ('ZAPI', 'flexcache-get-iter', ZRR['flexcache_get_info']),
343 ('ZAPI', 'volume-offline', ZRR['success']),
344 ('ZAPI', 'flexcache-destroy-async', ZRR['result_async']),
345 ('ZAPI', 'job-get', ZRR['job_success']),
346 ])
347 module_args = {
348 'use_rest': 'never',
349 'force_offline': 'true',
350 'state': 'absent'
351 }
352 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
353
354
355 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
356 def test_delete_flexcache_exists_with_force_no_wait():
357 ''' delete flexcache '''
358 register_responses([
359 ('ZAPI', 'flexcache-get-iter', ZRR['flexcache_get_info']),
360 ('ZAPI', 'volume-offline', ZRR['success']),
361 ('ZAPI', 'flexcache-destroy-async', ZRR['result_async']),
362 ])
363 module_args = {
364 'use_rest': 'never',
365 'force_offline': 'true',
366 'time_out': 0,
367 'state': 'absent'
368 }
369 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
370
371
372 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
373 def test_delete_flexcache_exists_junctionpath_no_force():
374 ''' delete flexcache '''
375 register_responses([
376 ('ZAPI', 'flexcache-get-iter', ZRR['flexcache_get_info']),
377 ('ZAPI', 'volume-offline', ZRR['success']),
378 ('ZAPI', 'flexcache-destroy-async', ZRR['error_160']),
379 ])
380 module_args = {
381 'use_rest': 'never',
382 'force_offline': 'true',
383 'junction_path': 'jpath',
384 'state': 'absent'
385 }
386 error = zapi_error_message('Error deleting FlexCache', 160,
387 'Volume volume on Vserver ansibleSVM must be unmounted before being taken offline or restricted')
388 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
389
390
391 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
392 def test_delete_flexcache_exists_junctionpath_with_force():
393 ''' delete flexcache '''
394 register_responses([
395 ('ZAPI', 'flexcache-get-iter', ZRR['flexcache_get_info']),
396 ('ZAPI', 'volume-unmount', ZRR['success']),
397 ('ZAPI', 'volume-offline', ZRR['success']),
398 ('ZAPI', 'flexcache-destroy-async', ZRR['result_async']),
399 ('ZAPI', 'job-get', ZRR['job_success']),
400 ])
401 module_args = {
402 'use_rest': 'never',
403 'force_offline': 'true',
404 'junction_path': 'jpath',
405 'force_unmount': 'true',
406 'state': 'absent'
407 }
408 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
409
410
411 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
412 def test_delete_flexcache_not_exist():
413 ''' delete flexcache '''
414 register_responses([
415 ('ZAPI', 'flexcache-get-iter', ZRR['no_records']),
416 ])
417 module_args = {
418 'use_rest': 'never',
419 'state': 'absent'
420 }
421 assert not call_main(my_main, DEFAULT_ARGS, module_args)['changed']
422
423
424 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
425 def test_error_delete_flexcache_exists_with_force():
426 ''' delete flexcache '''
427 register_responses([
428 ('ZAPI', 'flexcache-get-iter', ZRR['flexcache_get_info']),
429 ('ZAPI', 'volume-offline', ZRR['success']),
430 ('ZAPI', 'flexcache-destroy-async', ZRR['result_error']),
431 # 2nd run
432 ('ZAPI', 'flexcache-get-iter', ZRR['flexcache_get_info']),
433 ('ZAPI', 'volume-offline', ZRR['success']),
434 ('ZAPI', 'flexcache-destroy-async', ZRR['result_async']),
435 ('ZAPI', 'job-get', ZRR['error']),
436 # 3rd run
437 ('ZAPI', 'flexcache-get-iter', ZRR['flexcache_get_info']),
438 ('ZAPI', 'volume-offline', ZRR['success']),
439 ('ZAPI', 'flexcache-destroy-async', ZRR['result_async']),
440 ('ZAPI', 'job-get', ZRR['job_error']),
441 ])
442 module_args = {
443 'use_rest': 'never',
444 'force_offline': 'true',
445 'state': 'absent'
446 }
447 error = 'Unexpected error when deleting flexcache: results is:'
448 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
449 error = zapi_error_message('Error fetching job info')
450 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
451 error = 'Error when deleting flexcache'
452 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
453
454
455 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
456 def test_create_flexcache_size_error():
457 ''' create flexcache '''
458 register_responses([
459 ('ZAPI', 'flexcache-get-iter', ZRR['no_records']),
460 ('ZAPI', 'flexcache-create-async', ZRR['error_size']),
461 ])
462 module_args = {
463 'use_rest': 'never',
464 'size': '50', # 80MB minimum
465 'size_unit': 'mb', # 80MB minimum
466 'aggr_list': 'aggr1',
467 'origin_volume': 'fc_vol_origin',
468 'origin_vserver': 'ansibleSVM',
469 }
470 error = zapi_error_message('Error creating FlexCache', 'size', 'Size "50MB" ("52428800B") is too small. Minimum size is "80MB" ("83886080B")')
471 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
472
473
474 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
475 @patch('time.sleep')
476 def test_create_flexcache_time_out(dont_sleep):
477 ''' create flexcache '''
478 register_responses([
479 ('ZAPI', 'flexcache-get-iter', ZRR['no_records']),
480 ('ZAPI', 'flexcache-create-async', ZRR['result_async']),
481 ('ZAPI', 'job-get', ZRR['job_running']),
482 ])
483 module_args = {
484 'use_rest': 'never',
485 'size': '50', # 80MB minimum
486 'size_unit': 'mb', # 80MB minimum
487 'aggr_list': 'aggr1',
488 'origin_volume': 'fc_vol_origin',
489 'origin_vserver': 'ansibleSVM',
490 'time_out': '2',
491 }
492 my_obj = create_module(my_module, DEFAULT_ARGS, module_args)
493 error = 'Error when creating flexcache: job completion exceeded expected timer of: 2 seconds'
494 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
495
496
497 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
498 def test_error_zapi():
499 ''' error in ZAPI calls '''
500 register_responses([
501 ('ZAPI', 'flexcache-get-iter', ZRR['error']),
502 ('ZAPI', 'volume-offline', ZRR['error']),
503 ('ZAPI', 'volume-unmount', ZRR['error']),
504 ])
505 module_args = {
506 'use_rest': 'never',
507 }
508 my_obj = create_module(my_module, DEFAULT_ARGS, module_args)
509 error = zapi_error_message('Error fetching FlexCache info')
510 assert error in expect_and_capture_ansible_exception(my_obj.flexcache_get, 'fail')['msg']
511 error = zapi_error_message('Error offlining FlexCache volume')
512 assert error in expect_and_capture_ansible_exception(my_obj.volume_offline, 'fail', None)['msg']
513 error = zapi_error_message('Error unmounting FlexCache volume')
514 assert error in expect_and_capture_ansible_exception(my_obj.volume_unmount, 'fail', None)['msg']
515
516
517 @pytest.mark.skipif(not netapp_utils.has_netapp_lib(), reason="skipping as missing required netapp_lib")
518 def test_check_job_status():
519 ''' check_job_status '''
520 register_responses([
521 # job not found
522 ('ZAPI', 'job-get', ZRR['error_15661']),
523 ('ZAPI', 'vserver-get-iter', ZRR['no_records']),
524 ('ZAPI', 'job-get', ZRR['error_15661']),
525 # cserver job not found
526 ('ZAPI', 'job-get', ZRR['error_15661']),
527 ('ZAPI', 'vserver-get-iter', ZRR['cserver']),
528 ('ZAPI', 'job-get', ZRR['error_15661']),
529 # missing job-completion
530 ('ZAPI', 'job-get', ZRR['job_error_no_completion']),
531 # bad status
532 ('ZAPI', 'job-get', ZRR['job_other']),
533 ])
534 module_args = {
535 'use_rest': 'never',
536 }
537 my_obj = create_module(my_module, DEFAULT_ARGS, module_args)
538 # error = zapi_error_message('Error fetching FlexCache info')
539 error = 'cannot locate job with id: 1'
540 assert error in my_obj.check_job_status('1')
541 assert error in my_obj.check_job_status('1')
542 assert 'progress' in my_obj.check_job_status('1')
543 error = 'Unexpected job status in:'
544 assert error in expect_and_capture_ansible_exception(my_obj.check_job_status, 'fail', '1')['msg']
545
546
547 # REST API canned responses when mocking send_request
548 SRR = rest_responses({
549 # common responses
550 'is_rest': (200, dict(version=dict(generation=9, major=9, minor=0, full='dummy')), None),
551 'is_rest_9_8': (200, dict(version=dict(generation=9, major=8, minor=0, full='dummy')), None),
552 'is_rest_9_12': (200, dict(version=dict(generation=9, major=12, minor=0, full='dummy')), None),
553 'is_rest_9_15_1': (200, dict(version=dict(generation=9, major=15, minor=1, full='dummy')), None),
554 'is_zapi': (400, {}, "Unreachable"),
555 'empty_good': (200, {}, None),
556 'zero_record': (200, dict(records=[], num_records=0), None),
557 'one_record_uuid': (200, dict(records=[dict(uuid='a1b2c3')], num_records=1), None),
558 'end_of_sequence': (500, None, "Unexpected call to send_request"),
559 'generic_error': (400, None, "Expected error"),
560 'one_flexcache_record': (200, dict(records=[
561 dict(uuid='a1b2c3',
562 name='flexcache_volume',
563 svm=dict(name='vserver'),
564 writeback=dict(enabled=True),
565 cifs_change_notify_enabled=False
566 )
567 ], num_records=1), None),
568 'one_flexcache_record_with_path': (200, dict(records=[
569 dict(uuid='a1b2c3',
570 name='flexcache_volume',
571 svm=dict(name='vserver'),
572 path='path',
573 writeback=dict(enabled=True)
574 )
575 ], num_records=1), None),
576 })
577
578
579 @patch('ansible_collections.netapp.ontap.plugins.module_utils.netapp.has_netapp_lib')
580 def test_fail_netapp_lib_error(mock_has_netapp_lib):
581 mock_has_netapp_lib.return_value = False
582 module_args = {
583 "use_rest": "never"
584 }
585 assert 'Error: the python NetApp-Lib module is required. Import error:' in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
586
587
588 def test_rest_missing_arguments():
589 ''' create flexcache '''
590 register_responses([
591
592 ])
593 args = dict(DEFAULT_ARGS)
594 del args['hostname']
595 module_args = {
596 'use_rest': 'always',
597 }
598 error = 'missing required arguments: hostname'
599 assert error in call_main(my_main, args, module_args, fail=True)['msg']
600
601
602 def test_rest_create():
603 ''' create flexcache '''
604 register_responses([
605 ('GET', 'cluster', SRR['is_rest']),
606 ('GET', 'storage/flexcache/flexcaches', SRR['zero_record']),
607 ('POST', 'storage/flexcache/flexcaches', SRR['success']),
608 ])
609 module_args = {
610 'use_rest': 'always',
611 'size': '50', # 80MB minimum
612 'size_unit': 'mb', # 80MB minimum
613 'aggr_list': 'aggr1',
614 'origin_volume': 'fc_vol_origin',
615 'origin_vserver': 'ansibleSVM',
616 'origin_cluster': 'ocluster',
617 }
618 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
619
620
621 def test_rest_create_with_writeback():
622 ''' create flexcache '''
623 register_responses([
624 ('GET', 'cluster', SRR['is_rest_9_12']),
625 ('GET', 'storage/flexcache/flexcaches', SRR['zero_record']),
626 ('POST', 'storage/flexcache/flexcaches', SRR['success']),
627 ])
628 module_args = {
629 'use_rest': 'always',
630 'size': '50', # 80MB minimum
631 'size_unit': 'mb', # 80MB minimum
632 'aggr_list': 'aggr1',
633 'origin_volume': 'fc_vol_origin',
634 'origin_vserver': 'ansibleSVM',
635 'origin_cluster': 'ocluster',
636 'writeback': {
637 'enabled': True
638 }
639 }
640 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
641
642
643 def test_rest_create_no_action():
644 ''' create flexcache idempotent '''
645 register_responses([
646 ('GET', 'cluster', SRR['is_rest_9_12']),
647 ('GET', 'storage/flexcache/flexcaches', SRR['one_flexcache_record']),
648 ])
649 module_args = {
650 'use_rest': 'always',
651 'aggr_list': 'aggr1',
652 'origin_volume': 'fc_vol_origin',
653 'origin_vserver': 'ansibleSVM',
654 'writeback': {
655 'enabled': True
656 }
657 }
658 assert not call_main(my_main, DEFAULT_ARGS, module_args)['changed']
659
660
661 def test_rest_delete_no_action():
662 ''' delete flexcache '''
663 register_responses([
664 ('GET', 'cluster', SRR['is_rest']),
665 ('GET', 'storage/flexcache/flexcaches', SRR['zero_record']),
666 ])
667 module_args = {
668 'use_rest': 'always',
669 'state': 'absent'
670 }
671 assert not call_main(my_main, DEFAULT_ARGS, module_args)['changed']
672
673
674 def test_rest_delete():
675 ''' delete flexcache '''
676 register_responses([
677 ('GET', 'cluster', SRR['is_rest']),
678 ('GET', 'storage/flexcache/flexcaches', SRR['one_flexcache_record']),
679 ('DELETE', 'storage/flexcache/flexcaches/a1b2c3', SRR['empty_good']),
680 ])
681 module_args = {
682 'use_rest': 'always',
683 'state': 'absent'
684 }
685 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
686
687
688 def test_rest_delete_with_force():
689 ''' delete flexcache, since there is no path, unmount is not called '''
690 register_responses([
691 ('GET', 'cluster', SRR['is_rest']),
692 ('GET', 'storage/flexcache/flexcaches', SRR['one_flexcache_record']),
693 ('DELETE', 'storage/flexcache/flexcaches/a1b2c3', SRR['empty_good']),
694 ])
695 module_args = {
696 'use_rest': 'always',
697 'force_unmount': True,
698 'state': 'absent'
699 }
700 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
701
702
703 def test_rest_delete_with_force_and_path():
704 ''' delete flexcache with unmount '''
705 register_responses([
706 ('GET', 'cluster', SRR['is_rest']),
707 ('GET', 'storage/flexcache/flexcaches', SRR['one_flexcache_record_with_path']),
708 ('PATCH', 'storage/volumes/a1b2c3', SRR['empty_good']),
709 ('DELETE', 'storage/flexcache/flexcaches/a1b2c3', SRR['empty_good']),
710 ])
711 module_args = {
712 'use_rest': 'always',
713 'force_unmount': True,
714 'state': 'absent'
715 }
716 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
717
718
719 def test_rest_delete_with_force2_and_path():
720 ''' delete flexcache with unmount and offline'''
721 register_responses([
722 ('GET', 'cluster', SRR['is_rest']),
723 ('GET', 'storage/flexcache/flexcaches', SRR['one_flexcache_record_with_path']),
724 ('PATCH', 'storage/volumes/a1b2c3', SRR['empty_good']),
725 ('PATCH', 'storage/volumes/a1b2c3', SRR['empty_good']),
726 ('DELETE', 'storage/flexcache/flexcaches/a1b2c3', SRR['empty_good']),
727 ])
728 module_args = {
729 'use_rest': 'always',
730 'force_offline': True,
731 'force_unmount': True,
732 'state': 'absent'
733 }
734 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
735
736
737 def test_rest_warn_delete_with_writeback_enabled():
738 ''' delete flexcache with writeback enabled '''
739 register_responses([
740 ('GET', 'cluster', SRR['is_rest_9_12']),
741 ('GET', 'storage/flexcache/flexcaches', SRR['one_flexcache_record']),
742 ('DELETE', 'storage/flexcache/flexcaches/a1b2c3', SRR['end_of_sequence']),
743 ])
744 module_args = {
745 'use_rest': 'always',
746 'state': 'absent',
747 'writeback': {
748 'enabled': True
749 }
750 }
751 error = 'Error in flexcache_rest_delete: calling: storage/flexcache/flexcaches/a1b2c3'
752 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
753
754
755 def test_rest_modify_prepopulate_no_action():
756 ''' modify flexcache '''
757 register_responses([
758 ('GET', 'cluster', SRR['is_rest']),
759 ('GET', 'storage/flexcache/flexcaches', SRR['one_flexcache_record']),
760 ])
761 module_args = {
762 'use_rest': 'always',
763 'aggr_list': 'aggr1',
764 'origin_volume': 'fc_vol_origin',
765 'origin_vserver': 'ansibleSVM',
766 'prepopulate': {
767 'dir_paths': ['/'],
768 'force_prepopulate_if_already_created': False
769 }
770 }
771 assert not call_main(my_main, DEFAULT_ARGS, module_args)['changed']
772
773
774 def test_rest_modify_prepopulate():
775 ''' modify flexcache '''
776 register_responses([
777 ('GET', 'cluster', SRR['is_rest']),
778 ('GET', 'storage/flexcache/flexcaches', SRR['one_flexcache_record']),
779 ('PATCH', 'storage/flexcache/flexcaches/a1b2c3', SRR['empty_good']),
780 ])
781 module_args = {
782 'use_rest': 'always',
783 'aggr_list': 'aggr1',
784 'origin_volume': 'fc_vol_origin',
785 'origin_vserver': 'ansibleSVM',
786 'prepopulate': {
787 'dir_paths': ['/'],
788 'force_prepopulate_if_already_created': True
789 }
790 }
791 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
792
793
794 def test_rest_modify_prepopulate_default():
795 ''' modify flexcache '''
796 register_responses([
797 ('GET', 'cluster', SRR['is_rest']),
798 ('GET', 'storage/flexcache/flexcaches', SRR['one_flexcache_record']),
799 ('PATCH', 'storage/flexcache/flexcaches/a1b2c3', SRR['empty_good']),
800 ])
801 module_args = {
802 'use_rest': 'always',
803 'aggr_list': 'aggr1',
804 'origin_volume': 'fc_vol_origin',
805 'origin_vserver': 'ansibleSVM',
806 'prepopulate': {
807 'dir_paths': ['/'],
808 }
809 }
810 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
811
812
813 def test_rest_modify_prepopulate_and_mount():
814 ''' modify flexcache '''
815 register_responses([
816 ('GET', 'cluster', SRR['is_rest']),
817 ('GET', 'storage/flexcache/flexcaches', SRR['one_flexcache_record']),
818 ('PATCH', 'storage/volumes/a1b2c3', SRR['empty_good']),
819 ('PATCH', 'storage/flexcache/flexcaches/a1b2c3', SRR['empty_good']),
820 ])
821 module_args = {
822 'use_rest': 'always',
823 'aggr_list': 'aggr1',
824 'origin_volume': 'fc_vol_origin',
825 'origin_vserver': 'ansibleSVM',
826 'prepopulate': {
827 'dir_paths': ['/'],
828 },
829 'path': '/mount_path'
830 }
831 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
832
833
834 def test_rest_modify_cifs_change_notify_enabled():
835 ''' modify flexcache '''
836 register_responses([
837 ('GET', 'cluster', SRR['is_rest_9_15_1']),
838 ('GET', 'storage/flexcache/flexcaches', SRR['one_flexcache_record']),
839 ('PATCH', 'storage/flexcache/flexcaches/a1b2c3', SRR['empty_good']),
840 ])
841 module_args = {
842 'use_rest': 'always',
843 'aggr_list': 'aggr1',
844 'origin_volume': 'fc_vol_origin',
845 'origin_vserver': 'ansibleSVM',
846 'cifs_change_notify_enabled': True
847 }
848 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
849
850
851 def test_rest_modify_no_action():
852 ''' modify name of the flexcache skipped '''
853 register_responses([
854 ('GET', 'cluster', SRR['is_rest']),
855 ('GET', 'storage/flexcache/flexcaches', SRR['one_flexcache_record']),
856 ])
857 module_args = {
858 'use_rest': 'always',
859 'aggr_list': 'aggr1',
860 'volume': 'flexcache_volume2',
861 'origin_volume': 'fc_vol_origin',
862 'origin_vserver': 'ansibleSVM',
863 }
864 assert not call_main(my_main, DEFAULT_ARGS, module_args)['changed']
865
866
867 def test_rest_warn_prepopulate():
868 ''' create flexcache idempotent '''
869 register_responses([
870 ('GET', 'cluster', SRR['is_rest']),
871 ('GET', 'storage/flexcache/flexcaches', SRR['one_flexcache_record']),
872 ('PATCH', 'storage/volumes/a1b2c3', SRR['success']),
873 ('PATCH', 'storage/flexcache/flexcaches/a1b2c3', SRR['success']),
874 ])
875 module_args = {
876 'use_rest': 'always',
877 'aggr_list': 'aggr1',
878 'volume': 'flexcache_volume',
879 'origin_volume': 'fc_vol_origin',
880 'origin_vserver': 'ansibleSVM',
881 'prepopulate': {
882 'dir_paths': ['/'],
883 'force_prepopulate_if_already_created': True
884 },
885 'junction_path': ''
886 }
887 assert call_main(my_main, DEFAULT_ARGS, module_args)['changed']
888 print_warnings()
889 assert_warning_was_raised('na_ontap_flexcache is not idempotent when prepopulate is present and force_prepopulate_if_already_created=true')
890 assert_warning_was_raised('prepopulate requires the FlexCache volume to be mounted')
891
892
893 def test_prepopulate_option_checks():
894 ''' create flexcache idempotent '''
895 register_responses([
896 ('GET', 'cluster', SRR['is_rest_97']),
897 ('GET', 'cluster', SRR['is_rest_9_8_0']),
898 ])
899 module_args = {
900 'use_rest': 'always',
901 'prepopulate': {
902 'dir_paths': ['/'],
903 'force_prepopulate_if_already_created': True,
904 'exclude_dir_paths': ['/']
905 },
906 }
907 error = 'Minimum version of ONTAP for prepopulate is (9, 8). Current version: (9, 7, 0).'
908 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']
909 error = 'Error: using prepopulate: exclude_dir_paths requires ONTAP 9.9 or later and REST must be enabled - ONTAP version: 9.8.0.'
910 assert error in call_main(my_main, DEFAULT_ARGS, module_args, fail=True)['msg']