Debian Codegraph @

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

raw
1 # (c) 2018-2022, NetApp, Inc
2 # GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
3
4 """ unit tests for Ansible module: na_ontap_aggregate """
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, Mock
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.plugins.module_utils.ansible_mocks import \
14 patch_ansible, create_and_apply, create_module, expect_and_capture_ansible_exception
15 from ansible_collections.netapp.ontap.tests.unit.framework.mock_rest_and_zapi_requests import patch_request_and_invoke, register_responses, get_mock_record
16 from ansible_collections.netapp.ontap.tests.unit.framework.zapi_factory import build_zapi_response, zapi_responses, build_zapi_error
17
18 from ansible_collections.netapp.ontap.plugins.modules.na_ontap_aggregate \
19 import NetAppOntapAggregate as my_module # module under test
20
21 if not netapp_utils.has_netapp_lib():
22 pytestmark = pytest.mark.skip('skipping as missing required netapp_lib')
23
24
25 AGGR_NAME = 'aggr_name'
26 OS_NAME = 'abc'
27
28 aggr_info = {'num-records': 3,
29 'attributes-list':
30 {'aggr-attributes':
31 {'aggregate-name': AGGR_NAME,
32 'aggr-raid-attributes': {
33 'state': 'online',
34 'disk-count': '4',
35 'encrypt-with-aggr-key': 'true'},
36 'aggr-snaplock-attributes': {'snaplock-type': 'snap_t'}}
37 },
38 }
39
40 object_store_info = {'num-records': 1,
41 'attributes-list':
42 {'object-store-information': {'object-store-name': OS_NAME}}
43 }
44
45 disk_info = {'num-records': 1,
46 'attributes-list': [
47 {'disk-info':
48 {'disk-name': '1',
49 'disk-raid-info':
50 {'disk-aggregate-info':
51 {'plex-name': 'plex0'}
52 }}},
53 {'disk-info':
54 {'disk-name': '2',
55 'disk-raid-info':
56 {'disk-aggregate-info':
57 {'plex-name': 'plex0'}
58 }}},
59 {'disk-info':
60 {'disk-name': '3',
61 'disk-raid-info':
62 {'disk-aggregate-info':
63 {'plex-name': 'plexM'}
64 }}},
65 {'disk-info':
66 {'disk-name': '4',
67 'disk-raid-info':
68 {'disk-aggregate-info':
69 {'plex-name': 'plexM'}
70 }}},
71 ]}
72
73 ZRR = zapi_responses({
74 'aggr_info': build_zapi_response(aggr_info),
75 'object_store_info': build_zapi_response(object_store_info),
76 'disk_info': build_zapi_response(disk_info),
77 'error_disk_add': build_zapi_error(13003, 'disk add operation is in progress'),
78 })
79
80
81 DEFAULT_ARGS = {
82 'hostname': 'hostname',
83 'username': 'username',
84 'password': 'password',
85 'name': AGGR_NAME,
86 'use_rest': 'never',
87 'feature_flags': {'no_cserver_ems': True}
88 }
89
90
91 def test_module_fail_when_required_args_missing():
92 ''' required arguments are reported as errors '''
93 error = create_module(my_module, fail=True)['msg']
94 print('Info: %s' % error)
95 assert 'missing required arguments:' in error
96 assert 'name' in error
97
98
99 def test_create():
100 register_responses([
101 ('aggr-get-iter', ZRR['empty']),
102 ('aggr-create', ZRR['empty']),
103 ('aggr-get-iter', ZRR['empty']),
104 ])
105 module_args = {
106 'disk_type': 'ATA',
107 'raid_type': 'raid_dp',
108 'snaplock_type': 'non_snaplock',
109 # 'spare_pool': 'Pool0',
110 'disk_count': 4,
111 'raid_size': 5,
112 'disk_size': 10,
113 # 'disk_size_with_unit': 'dsize_unit',
114 'is_mirrored': True,
115 'ignore_pool_checks': True,
116 'encryption': True,
117 'nodes': ['node1', 'node2']
118 }
119 assert create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
120
121
122 def test_delete():
123 register_responses([
124 ('aggr-get-iter', ZRR['aggr_info']),
125 ('aggr-destroy', ZRR['empty'])
126 ])
127 module_args = {
128 'state': 'absent',
129 'disk_count': 3
130 }
131 assert create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
132
133
134 def test_create_with_spare_pool():
135 register_responses([
136 ('aggr-get-iter', ZRR['empty']),
137 ('aggr-create', ZRR['empty']),
138 ('aggr-get-iter', ZRR['empty']),
139 ])
140 module_args = {
141 'disk_type': 'ATA',
142 'raid_type': 'raid_dp',
143 'snaplock_type': 'non_snaplock',
144 'spare_pool': 'Pool0',
145 'disk_count': 2,
146 'raid_size': 5,
147 'disk_size_with_unit': '10m',
148 # 'disk_size_with_unit': 'dsize_unit',
149 'ignore_pool_checks': True,
150 'encryption': True,
151 'nodes': ['node1', 'node2']
152 }
153 assert create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
154
155
156 def test_create_with_disks():
157 register_responses([
158 ('aggr-get-iter', ZRR['empty']),
159 ('aggr-create', ZRR['empty']),
160 ('aggr-get-iter', ZRR['empty']),
161 ])
162 module_args = {
163 'disk_type': 'ATA',
164 'raid_type': 'raid_dp',
165 'snaplock_type': 'non_snaplock',
166 'disks': [1, 2],
167 'mirror_disks': [11, 12],
168 'raid_size': 5,
169 'disk_size_with_unit': '10m',
170 'ignore_pool_checks': True,
171 'encryption': True,
172 'nodes': ['node1', 'node2']
173 }
174 assert create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
175
176
177 @patch('time.sleep')
178 def test_create_wait_for_completion(mock_time):
179 register_responses([
180 ('aggr-get-iter', ZRR['empty']),
181 ('aggr-create', ZRR['empty']),
182 ('aggr-get-iter', ZRR['empty']),
183 ('aggr-get-iter', ZRR['empty']),
184 ('aggr-get-iter', ZRR['aggr_info']),
185 ])
186 module_args = {
187 'disk_count': '2',
188 'is_mirrored': 'true',
189 'wait_for_online': 'true'
190 }
191 assert create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
192
193
194 def test_create_with_object_store():
195 register_responses([
196 ('aggr-get-iter', ZRR['empty']),
197 ('aggr-create', ZRR['empty']),
198 ('aggr-get-iter', ZRR['empty']),
199 ('aggr-object-store-attach', ZRR['empty']),
200 ])
201 module_args = {
202 'disk_class': 'capacity',
203 'disk_count': '2',
204 'is_mirrored': 'true',
205 'object_store_name': 'abc',
206 'allow_flexgroups': True
207 }
208 assert create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
209
210
211 def test_is_mirrored():
212 register_responses([
213 ('aggr-get-iter', ZRR['aggr_info']),
214 ])
215 module_args = {
216 'disk_count': '4',
217 'is_mirrored': 'true',
218 }
219 assert not create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
220
221
222 def test_disks_list():
223 register_responses([
224 ('aggr-get-iter', ZRR['aggr_info']),
225 ('storage-disk-get-iter', ZRR['disk_info']),
226 ])
227 module_args = {
228 'disks': ['1', '2'],
229 }
230 assert not create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
231
232
233 def test_mirror_disks():
234 register_responses([
235 ('aggr-get-iter', ZRR['aggr_info']),
236 ('storage-disk-get-iter', ZRR['disk_info']),
237 ])
238 module_args = {
239 'disks': ['1', '2'],
240 'mirror_disks': ['3', '4']
241 }
242 assert not create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
243
244
245 def test_spare_pool():
246 register_responses([
247 ('aggr-get-iter', ZRR['aggr_info']),
248 ])
249 module_args = {
250 'disk_count': '4',
251 'spare_pool': 'Pool1'
252 }
253 assert not create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
254
255
256 def test_negative_modify_encryption():
257 register_responses([
258 ('aggr-get-iter', ZRR['aggr_info']),
259 ])
260 module_args = {
261 'encryption': False
262 }
263 exc = create_and_apply(my_module, DEFAULT_ARGS, module_args, fail=True)
264 msg = 'Error: modifying encryption is not supported with ZAPI.'
265 assert msg in exc['msg']
266
267
268 def test_rename():
269 register_responses([
270 ('aggr-get-iter', ZRR['empty']), # target does not exist
271 ('aggr-get-iter', ZRR['aggr_info']), # from exists
272 ('aggr-rename', ZRR['empty']),
273 ])
274 module_args = {
275 'from_name': 'test_name2'
276 }
277 assert create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
278
279
280 def test_rename_error_no_from():
281 register_responses([
282 ('aggr-get-iter', ZRR['empty']), # target does not exist
283 ('aggr-get-iter', ZRR['empty']), # from does not exist
284 ])
285 module_args = {
286 'from_name': 'test_name2'
287 }
288 exception = create_and_apply(my_module, DEFAULT_ARGS, module_args, fail=True)
289 msg = 'Error renaming aggregate %s: no aggregate with from_name %s.' % (AGGR_NAME, module_args['from_name'])
290 assert msg in exception['msg']
291
292
293 def test_rename_with_add_object_store(): # TODO:
294 register_responses([
295 ('aggr-get-iter', ZRR['empty']), # target does not exist
296 ('aggr-get-iter', ZRR['aggr_info']), # from exists
297 ('aggr-object-store-get-iter', ZRR['empty']), # from does not have an OS
298 ('aggr-rename', ZRR['empty']),
299 ('aggr-object-store-attach', ZRR['empty']),
300 ])
301 module_args = {
302 'from_name': 'test_name2',
303 'object_store_name': 'abc',
304 'allow_flexgroups': False
305 }
306 assert create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
307
308
309 def test_object_store_present():
310 register_responses([
311 ('aggr-get-iter', ZRR['aggr_info']),
312 ('aggr-object-store-get-iter', ZRR['object_store_info']),
313 ])
314 module_args = {
315 'object_store_name': 'abc'
316 }
317 assert not create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
318
319
320 def test_object_store_create():
321 register_responses([
322 ('aggr-get-iter', ZRR['aggr_info']),
323 ('aggr-object-store-get-iter', ZRR['empty']), # object_store is not attached
324 ('aggr-object-store-attach', ZRR['empty']),
325 ])
326 module_args = {
327 'object_store_name': 'abc',
328 'allow_flexgroups': True
329 }
330 assert create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
331
332
333 def test_object_store_modify():
334 ''' not supported '''
335 register_responses([
336 ('aggr-get-iter', ZRR['aggr_info']),
337 ('aggr-object-store-get-iter', ZRR['object_store_info']),
338 ])
339 module_args = {
340 'object_store_name': 'def'
341 }
342 exception = create_and_apply(my_module, DEFAULT_ARGS, module_args, fail=True)
343 msg = 'Error: object store %s is already associated with aggregate %s.' % (OS_NAME, AGGR_NAME)
344 assert msg in exception['msg']
345
346
347 def test_if_all_methods_catch_exception():
348 register_responses([
349 ('aggr-get-iter', ZRR['error']),
350 ('aggr-online', ZRR['error']),
351 ('aggr-offline', ZRR['error']),
352 ('aggr-create', ZRR['error']),
353 ('aggr-destroy', ZRR['error']),
354 ('aggr-rename', ZRR['error']),
355 ('aggr-get-iter', ZRR['error']),
356 ])
357 module_args = {
358 'service_state': 'online',
359 'unmount_volumes': 'True',
360 'from_name': 'test_name2',
361 }
362
363 my_obj = create_module(my_module, DEFAULT_ARGS, module_args)
364
365 error = expect_and_capture_ansible_exception(my_obj.aggr_get_iter, 'fail', module_args.get('name'))['msg']
366 assert 'Error getting aggregate: NetApp API failed. Reason - 12345:synthetic error for UT purpose' in error
367
368 error = expect_and_capture_ansible_exception(my_obj.aggregate_online, 'fail')['msg']
369 assert 'Error changing the state of aggregate' in error
370
371 error = expect_and_capture_ansible_exception(my_obj.aggregate_offline, 'fail')['msg']
372 assert 'Error changing the state of aggregate' in error
373
374 error = expect_and_capture_ansible_exception(my_obj.create_aggr, 'fail')['msg']
375 assert 'Error provisioning aggregate' in error
376
377 error = expect_and_capture_ansible_exception(my_obj.delete_aggr, 'fail')['msg']
378 assert 'Error removing aggregate' in error
379
380 error = expect_and_capture_ansible_exception(my_obj.rename_aggregate, 'fail')['msg']
381 assert 'Error renaming aggregate' in error
382
383 my_obj.asup_log_for_cserver = Mock(return_value=None)
384 error = expect_and_capture_ansible_exception(my_obj.apply, 'fail')['msg']
385 assert '12345:synthetic error for UT purpose' in error
386
387
388 def test_disks_bad_mapping():
389 register_responses([
390 ('aggr-get-iter', ZRR['aggr_info']),
391 ('storage-disk-get-iter', ZRR['disk_info']),
392 ])
393 module_args = {
394 'disks': ['0'],
395 }
396 exception = create_and_apply(my_module, DEFAULT_ARGS, module_args, fail=True)
397 msg = "Error mapping disks for aggregate %s: cannot match disks with current aggregate disks." % AGGR_NAME
398 assert exception['msg'].startswith(msg)
399
400
401 def test_disks_overlapping_mirror():
402 register_responses([
403 ('aggr-get-iter', ZRR['aggr_info']),
404 ('storage-disk-get-iter', ZRR['disk_info']),
405 ])
406 module_args = {
407 'disks': ['1', '2', '3'],
408 }
409 exception = create_and_apply(my_module, DEFAULT_ARGS, module_args, fail=True)
410 msg = "Error mapping disks for aggregate %s: found overlapping plexes:" % AGGR_NAME
411 assert exception['msg'].startswith(msg)
412
413
414 def test_disks_removing_disk():
415 register_responses([
416 ('aggr-get-iter', ZRR['aggr_info']),
417 ('storage-disk-get-iter', ZRR['disk_info']),
418 ])
419 module_args = {
420 'disks': ['1'],
421 }
422 exception = create_and_apply(my_module, DEFAULT_ARGS, module_args, fail=True)
423 msg = "Error removing disks is not supported. Aggregate %s: these disks cannot be removed: ['2']." % AGGR_NAME
424 assert exception['msg'].startswith(msg)
425
426
427 def test_disks_removing_mirror_disk():
428 register_responses([
429 ('aggr-get-iter', ZRR['aggr_info']),
430 ('storage-disk-get-iter', ZRR['disk_info']),
431 ])
432 module_args = {
433 'disks': ['1', '2'],
434 'mirror_disks': ['4', '6']
435 }
436 exception = create_and_apply(my_module, DEFAULT_ARGS, module_args, fail=True)
437 msg = "Error removing disks is not supported. Aggregate %s: these disks cannot be removed: ['3']." % AGGR_NAME
438 assert exception['msg'].startswith(msg)
439
440
441 def test_disks_add():
442 register_responses([
443 ('aggr-get-iter', ZRR['aggr_info']),
444 ('storage-disk-get-iter', ZRR['disk_info']),
445 ])
446 register_responses([
447 ('aggr-get-iter', ZRR['aggr_info']),
448 ('storage-disk-get-iter', ZRR['disk_info']),
449 ('aggr-add', ZRR['empty']),
450 ])
451 module_args = {
452 'disks': ['1', '2', '5'],
453 }
454 assert create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
455
456
457 def test_disks_add_and_offline():
458 register_responses([
459 ('aggr-get-iter', ZRR['aggr_info']),
460 ('storage-disk-get-iter', ZRR['disk_info']),
461 ('aggr-add', ZRR['empty']),
462 ('aggr-offline', ZRR['error_disk_add']),
463 ('aggr-offline', ZRR['error_disk_add']),
464 ('aggr-offline', ZRR['error_disk_add']),
465 ('aggr-offline', ZRR['success']),
466 # error if max tries attempted.
467 ('aggr-get-iter', ZRR['aggr_info']),
468 ('storage-disk-get-iter', ZRR['disk_info']),
469 ('aggr-add', ZRR['empty']),
470 ('aggr-offline', ZRR['error_disk_add']),
471 ('aggr-offline', ZRR['error_disk_add']),
472 ('aggr-offline', ZRR['error_disk_add']),
473 ('aggr-offline', ZRR['error_disk_add']),
474 ('aggr-offline', ZRR['error_disk_add']),
475 ('aggr-offline', ZRR['error_disk_add']),
476 ('aggr-offline', ZRR['error_disk_add']),
477 ('aggr-offline', ZRR['error_disk_add']),
478 ('aggr-offline', ZRR['error_disk_add']),
479 ('aggr-offline', ZRR['error_disk_add'])
480 ])
481 module_args = {
482 'disks': ['1', '2', '5'], 'service_state': 'offline'
483 }
484 assert create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
485 assert 'disk add operation is in progres' in create_and_apply(my_module, DEFAULT_ARGS, module_args, fail=True)['msg']
486
487
488 def test_mirror_disks_add():
489 register_responses([
490 ('aggr-get-iter', ZRR['aggr_info']),
491 ('storage-disk-get-iter', ZRR['disk_info']),
492 ('aggr-add', ZRR['empty']),
493 ])
494 module_args = {
495 'disks': ['1', '2', '5'],
496 'mirror_disks': ['3', '4', '6']
497 }
498 assert create_and_apply(my_module, DEFAULT_ARGS, module_args)['changed']
499
500
501 def test_mirror_disks_add_unbalanced():
502 register_responses([
503 ('aggr-get-iter', ZRR['aggr_info']),
504 ('storage-disk-get-iter', ZRR['disk_info']),
505 ])
506 module_args = {
507 'disks': ['1', '2'],
508 'mirror_disks': ['3', '4', '6']
509 }
510 exception = create_and_apply(my_module, DEFAULT_ARGS, module_args, fail=True)
511 msg = "Error cannot add mirror disks ['6'] without adding disks for aggregate %s." % AGGR_NAME
512 assert exception['msg'].startswith(msg)
513
514
515 def test_map_plex_to_primary_and_mirror_error_overlap():
516 my_obj = create_module(my_module, DEFAULT_ARGS)
517 kwargs = {
518 'plex_disks': {'plex1': [1, 2, 3], 'plex2': [4, 5, 6]},
519 'disks': [1, 4, 5],
520 'mirror_disks': []
521 }
522 error = expect_and_capture_ansible_exception(my_obj.map_plex_to_primary_and_mirror, 'fail', **kwargs)['msg']
523 msg = "Error mapping disks for aggregate aggr_name: found overlapping plexes:"
524 assert error.startswith(msg)
525
526
527 def test_map_plex_to_primary_and_mirror_error_overlap_mirror():
528 my_obj = create_module(my_module, DEFAULT_ARGS)
529 kwargs = {
530 'plex_disks': {'plex1': [1, 2, 3], 'plex2': [4, 5, 6]},
531 'disks': [1, 4, 5],
532 'mirror_disks': [1, 4, 5]
533 }
534 error = expect_and_capture_ansible_exception(my_obj.map_plex_to_primary_and_mirror, 'fail', **kwargs)['msg']
535 msg = "Error mapping disks for aggregate aggr_name: found overlapping mirror plexes:"
536 error.startswith(msg)
537
538
539 def test_map_plex_to_primary_and_mirror_error_no_match():
540 my_obj = create_module(my_module, DEFAULT_ARGS)
541 kwargs = {
542 'plex_disks': {'plex1': [1, 2, 3], 'plex2': [4, 5, 6]},
543 'disks': [7, 8, 9],
544 'mirror_disks': [10, 11, 12]
545 }
546 error = expect_and_capture_ansible_exception(my_obj.map_plex_to_primary_and_mirror, 'fail', **kwargs)['msg']
547 msg = ("Error mapping disks for aggregate aggr_name: cannot match disks with current aggregate disks, "
548 "and cannot match mirror_disks with current aggregate disks.")
549 assert error.startswith(msg)
550
551
552 @patch('ansible_collections.netapp.ontap.plugins.module_utils.netapp.has_netapp_lib')
553 def test_missing_netapp_lib(mock_has_netapp_lib):
554 mock_has_netapp_lib.return_value = False
555 msg = 'Error: the python NetApp-Lib module is required. Import error: None'
556 assert msg == create_module(my_module, DEFAULT_ARGS, fail=True)['msg']
557
558
559 def test_disk_get_iter_error():
560 register_responses([
561 ('storage-disk-get-iter', ZRR['error']),
562 ])
563 msg = 'Error getting disks: NetApp API failed. Reason - 12345:synthetic error for UT purpose'
564 assert msg == expect_and_capture_ansible_exception(create_module(my_module, DEFAULT_ARGS).disk_get_iter, 'fail', 'name')['msg']
565
566
567 def test_object_store_get_iter_error():
568 register_responses([
569 ('aggr-object-store-get-iter', ZRR['error']),
570 ])
571 msg = 'Error getting object store: NetApp API failed. Reason - 12345:synthetic error for UT purpose'
572 assert msg == expect_and_capture_ansible_exception(create_module(my_module, DEFAULT_ARGS).object_store_get_iter, 'fail', 'name')['msg']
573
574
575 def test_attach_object_store_to_aggr_error():
576 register_responses([
577 ('aggr-object-store-attach', ZRR['error']),
578 ])
579 module_args = {
580 'object_store_name': 'os12',
581 }
582 msg = 'Error attaching object store os12 to aggregate aggr_name: NetApp API failed. Reason - 12345:synthetic error for UT purpose'
583 assert msg == expect_and_capture_ansible_exception(create_module(my_module, DEFAULT_ARGS, module_args).attach_object_store_to_aggr, 'fail')['msg']
584
585
586 def test_add_disks_all_options_class():
587 register_responses([
588 ('aggr-add', ZRR['empty']),
589 ])
590 my_obj = create_module(my_module, DEFAULT_ARGS)
591 my_obj.parameters['ignore_pool_checks'] = True
592 my_obj.parameters['disk_class'] = 'performance'
593 assert my_obj.add_disks(count=2, disks=['1', '2'], disk_size=1, disk_size_with_unit='12GB') is None
594
595
596 def test_add_disks_all_options_type():
597 register_responses([
598 ('aggr-add', ZRR['empty']),
599 ])
600 my_obj = create_module(my_module, DEFAULT_ARGS)
601 my_obj.parameters['ignore_pool_checks'] = True
602 my_obj.parameters['disk_type'] = 'SSD'
603 assert my_obj.add_disks(count=2, disks=['1', '2'], disk_size=1, disk_size_with_unit='12GB') is None
604
605
606 def test_add_disks_error():
607 register_responses([
608 ('aggr-add', ZRR['error']),
609 ])
610 msg = 'Error adding additional disks to aggregate aggr_name: NetApp API failed. Reason - 12345:synthetic error for UT purpose'
611 assert msg == expect_and_capture_ansible_exception(create_module(my_module, DEFAULT_ARGS).add_disks, 'fail')['msg']
612
613
614 def test_modify_aggr_offline():
615 register_responses([
616 ('aggr-offline', ZRR['empty']),
617 ])
618 my_obj = create_module(my_module, DEFAULT_ARGS)
619 assert my_obj.modify_aggr({'service_state': 'offline'}) is None
620
621
622 def test_modify_aggr_online():
623 register_responses([
624 ('aggr-online', ZRR['empty']),
625 ])
626 my_obj = create_module(my_module, DEFAULT_ARGS)
627 assert my_obj.modify_aggr({'service_state': 'online'}) is None