def test_create(self, *args):
set_module_args(
dict(name='foo',
description='this is a description',
ports=[1, 2, 3, 4],
port_ranges=['10-20', '30-40', '50-60'],
port_lists=['/Common/foo', 'foo'],
password='******',
server='localhost',
user='******'))
module = AnsibleModule(
argument_spec=self.spec.argument_spec,
supports_check_mode=self.spec.supports_check_mode)
mm = ModuleManager(module=module)
# Override methods to force specific logic in the module to happen
mm.exists = Mock(side_effect=[False, True])
mm.create_on_device = Mock(return_value=True)
results = mm.exec_module()
assert results['changed'] is True
assert 'ports' in results
assert 'port_lists' in results
assert 'port_ranges' in results
assert len(results['ports']) == 4
assert len(results['port_ranges']) == 3
assert len(results['port_lists']) == 2
assert results['description'] == 'this is a description'
def test_no_change_to_module_when_all_identical(self):
self.set_module_state('present')
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_cs_policy
cs_policy_mock = MagicMock()
attrs = {
'diff_object.return_value': {},
}
cs_policy_mock.configure_mock(**attrs)
m = MagicMock(return_value=cs_policy_mock)
policy_exists_mock = Mock(side_effect=[True, True])
policy_identical_mock = Mock(side_effect=[True, True])
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_cs_policy',
ConfigProxy=m,
policy_exists=policy_exists_mock,
policy_identical=policy_identical_mock,
ensure_feature_is_enabled=Mock(),
nitro_exception=self.MockException,
):
self.module = netscaler_cs_policy
result = self.exited()
self.assertFalse(result['changed'],
msg='Erroneous changed status update')
def test_save_config_not_called_on_state_present(self):
set_module_args(dict(
nitro_user='******',
nitro_pass='******',
nsip='192.0.2.1',
state='present',
save_config=False,
))
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_cs_vserver
client_mock = Mock()
m = Mock(return_value=client_mock)
cs_vserver_proxy_mock = Mock()
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_cs_vserver',
get_nitro_client=m,
cs_vserver_exists=Mock(side_effect=[False, True]),
cs_vserver_identical=Mock(side_effect=[True]),
diff_list=Mock(return_value={}),
ensure_feature_is_enabled=Mock(return_value=True),
do_state_change=Mock(return_value=Mock(errorcode=0)),
nitro_exception=self.MockException,
ConfigProxy=Mock(return_value=cs_vserver_proxy_mock),
):
self.module = netscaler_cs_vserver
self.exited()
self.assertNotIn(call.save_config(), client_mock.mock_calls)
def test_no_change_to_module_when_all_identical(self):
self.set_module_state('present')
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_service
service_proxy_mock = MagicMock()
attrs = {
'diff_object.return_value': {},
}
service_proxy_mock.configure_mock(**attrs)
m = MagicMock(return_value=service_proxy_mock)
service_exists_mock = Mock(side_effect=[True, True])
service_identical_mock = Mock(side_effect=[True, True])
monitor_bindings_identical_mock = Mock(side_effect=[True, True])
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_service',
ConfigProxy=m,
service_exists=service_exists_mock,
service_identical=service_identical_mock,
monitor_bindings_identical=monitor_bindings_identical_mock,
do_state_change=Mock(return_value=Mock(errorcode=0)),
):
self.module = netscaler_service
result = self.exited()
self.assertFalse(result['changed'],
msg='Erroneous changed status update')
def test_update_lb_monitor_workflow(self):
set_module_args(dict(
nitro_user='******',
nitro_pass='******',
nsip='192.0.2.1',
state='present',
save_config=False,
))
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_lb_monitor
lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_lb_monitor',
get_nitro_client=Mock(return_value=Mock()),
lbmonitor_exists=Mock(side_effect=[True, True]),
lbmonitor_identical=Mock(side_effect=[False, True]),
ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
ensure_feature_is_enabled=Mock(return_value=True),
get_immutables_intersection=Mock(return_value=[]),
diff_list=Mock(return_value={}),
):
self.module = netscaler_lb_monitor
result = self.exited()
lb_monitor_proxy_mock.assert_has_calls([call.update()])
self.assertTrue(result['changed'])
def test_successful_modify_schedules_add(self, modify_snapshot):
''' adding snapshot policy schedules and testing idempotency '''
data = self.set_default_args()
data['schedule'] = ['hourly', 'daily', 'weekly']
data['count'] = [100, 5, 10]
data['snapmirror_label'] = ['', 'daily', '']
set_module_args(data)
my_obj = my_module()
my_obj.asup_log_for_cserver = Mock(return_value=None)
if not self.onbox:
my_obj.server = MockONTAPConnection('policy')
with pytest.raises(AnsibleExitJson) as exc:
my_obj.apply()
assert exc.value.args[0]['changed']
current = self.set_default_current()
modify_snapshot.assert_called_with(current)
# to reset na_helper from remembering the previous 'changed' value
my_obj = my_module()
my_obj.asup_log_for_cserver = Mock(return_value=None)
if not self.onbox:
my_obj.server = MockONTAPConnection(
'snapshot_policy_info_schedules_added')
with pytest.raises(AnsibleExitJson) as exc:
my_obj.apply()
assert not exc.value.args[0]['changed']
def test_handle_get_return_object(self):
resource = 'lbvserver'
args = copy.deepcopy(module_arguments)
args.update(
dict(
nitro_user='******',
nitro_pass='******',
resource=resource,
))
resource_data = {
'property1': 'value1',
'property2': 'value2',
}
module_mock = Mock(params=args, from_json=json.loads)
with patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_nitro_request.AnsibleModule',
Mock(return_value=module_mock)):
instance = netscaler_nitro_request.NitroAPICaller()
data = {resource: resource_data}
result = {
'nitro_errorcode': 0,
'http_response_body': json.dumps(data),
}
expected_result = {'nitro_object': resource_data}
expected_result.update(result)
instance.handle_get_return_object(result)
self.assertDictEqual(result, expected_result)
def test_save_config_not_called_on_state_absent(self):
set_module_args(
dict(
nitro_user='******',
nitro_pass='******',
nsip='192.0.2.1',
state='absent',
save_config=False,
))
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_ssl_certkey
client_mock = Mock()
m = Mock(return_value=client_mock)
ssl_certkey_proxy_mock = Mock()
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_ssl_certkey',
get_nitro_client=m,
key_exists=Mock(side_effect=[True, False]),
ConfigProxy=Mock(return_value=ssl_certkey_proxy_mock),
):
self.module = netscaler_ssl_certkey
self.exited()
self.assertNotIn(call.save_config(), client_mock.mock_calls)
def test_get_immutables_failure(self):
set_module_args(
dict(
nitro_user='******',
nitro_pass='******',
nsip='192.0.2.1',
state='present',
))
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_lb_vserver
lb_vserver_proxy_mock = Mock()
client_mock = Mock()
m = Mock(return_value=['some'])
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_lb_vserver',
get_nitro_client=Mock(return_value=client_mock),
ConfigProxy=Mock(return_value=lb_vserver_proxy_mock),
ensure_feature_is_enabled=Mock(),
lb_vserver_exists=Mock(side_effect=[True, True]),
lb_vserver_identical=Mock(side_effect=[False]),
do_state_change=Mock(return_value=Mock(errorcode=0)),
get_immutables_intersection=m,
nitro_exception=self.MockException,
):
self.module = netscaler_lb_vserver
result = self.failed()
self.assertTrue(
result['msg'].startswith('Cannot update immutable attributes'),
msg='Did not handle immutables error correctly',
)
def test_edit_response_data_actual_body_data_irrelevant(self):
args = copy.deepcopy(module_arguments)
args.update(
dict(
nitro_user='******',
nitro_pass='******',
nitro_auth_token='##DDASKLFDJ',
))
module_mock = Mock(params=args, from_json=json.loads)
with patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_nitro_request.AnsibleModule',
Mock(return_value=module_mock)):
with tempfile.TemporaryFile() as r:
actual_body = {}
r.write(codecs.encode(json.dumps(actual_body), 'utf-8'))
r.seek(0)
instance = netscaler_nitro_request.NitroAPICaller()
info = {
'status': 200,
}
result = {}
success_status = 200
expected_result = {
'http_response_body': json.dumps(actual_body),
'http_response_data': info,
'nitro_errorcode': 0,
'nitro_message': 'Success',
'nitro_severity': 'NONE',
}
instance.edit_response_data(r, info, result, success_status)
self.assertDictEqual(result, expected_result)
def _get_wapi(self, test_object):
wapi = api.WapiModule(self.module)
wapi.get_object = Mock(name='get_object', return_value=test_object)
wapi.create_object = Mock(name='create_object')
wapi.update_object = Mock(name='update_object')
wapi.delete_object = Mock(name='delete_object')
return wapi
def get_volume_mock_object(self, kind=None, job_error=None):
"""
Helper method to return an na_ontap_volume object
:param kind: passes this param to MockONTAPConnection().
:param job_error: error message when getting job status.
:return: na_ontap_volume object
"""
vol_obj = vol_module()
vol_obj.ems_log_event = Mock(return_value=None)
vol_obj.cluster = Mock()
vol_obj.cluster.invoke_successfully = Mock()
vol_obj.volume_style = None
if kind is None:
vol_obj.server = MockONTAPConnection()
elif kind == 'volume':
vol_obj.server = MockONTAPConnection(kind='volume',
data=self.mock_vol)
elif kind == 'job_info':
vol_obj.server = MockONTAPConnection(kind='job_info',
data=self.mock_vol,
job_error=job_error)
elif kind == 'error_modify':
vol_obj.server = MockONTAPConnection(kind='error_modify',
data=self.mock_vol)
elif kind == 'failure_modify_async':
vol_obj.server = MockONTAPConnection(kind='failure_modify_async',
data=self.mock_vol)
elif kind == 'success_modify_async':
vol_obj.server = MockONTAPConnection(kind='success_modify_async',
data=self.mock_vol)
elif kind == 'zapi_error':
vol_obj.server = MockONTAPConnection(kind='zapi_error',
data=self.mock_vol)
return vol_obj
def test_graceful_nitro_error_on_login(self):
set_module_args(
dict(
nitro_user='******',
nitro_pass='******',
nsip='192.0.2.1',
state='present',
))
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_lb_vserver
class MockException(Exception):
def __init__(self, *args, **kwargs):
self.errorcode = 0
self.message = ''
client_mock = Mock()
client_mock.login = Mock(side_effect=MockException)
m = Mock(return_value=client_mock)
with patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_lb_vserver.get_nitro_client',
m):
with patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_lb_vserver.nitro_exception',
MockException):
self.module = netscaler_lb_vserver
result = self.failed()
self.assertTrue(
result['msg'].startswith('nitro exception'),
msg='nitro exception during login not handled properly')
def test_graceful_nitro_exception_state_absent(self):
set_module_args(
dict(
nitro_user='******',
nitro_pass='******',
nsip='192.0.2.1',
state='absent',
))
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_cs_action
class MockException(Exception):
def __init__(self, *args, **kwargs):
self.errorcode = 0
self.message = ''
m = Mock(side_effect=MockException)
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_cs_action',
action_exists=m,
ensure_feature_is_enabled=Mock(return_value=True),
nitro_exception=MockException):
self.module = netscaler_cs_action
result = self.failed()
self.assertTrue(
result['msg'].startswith('nitro exception'),
msg='Nitro exception not caught on operation absent')
def test_absent_server_noop_flow(self):
set_module_args(
dict(
nitro_user='******',
nitro_pass='******',
nsip='192.0.2.1',
state='absent',
))
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_server
client_mock = Mock()
m = Mock(return_value=client_mock)
server_proxy_attrs = {
'diff_object.return_value': {},
}
server_proxy_mock = Mock()
server_proxy_mock.configure_mock(**server_proxy_attrs)
config_proxy_mock = Mock(return_value=server_proxy_mock)
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_server',
get_nitro_client=m,
diff_list=Mock(return_value={}),
get_immutables_intersection=Mock(return_value=[]),
server_exists=Mock(side_effect=[False, False]),
server_identical=Mock(side_effect=[False, False]),
ConfigProxy=config_proxy_mock,
do_state_change=Mock(return_value=Mock(errorcode=0))):
self.module = netscaler_server
self.exited()
server_proxy_mock.assert_not_called()
def test_absent_server_failed_delete(self):
set_module_args(
dict(
nitro_user='******',
nitro_pass='******',
nsip='192.0.2.1',
state='absent',
))
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_server
client_mock = Mock()
m = Mock(return_value=client_mock)
server_proxy_attrs = {
'diff_object.return_value': {},
}
server_proxy_mock = Mock()
server_proxy_mock.configure_mock(**server_proxy_attrs)
config_proxy_mock = Mock(return_value=server_proxy_mock)
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_server',
nitro_exception=self.MockException,
get_nitro_client=m,
diff_list=Mock(return_value={}),
get_immutables_intersection=Mock(return_value=[]),
server_exists=Mock(side_effect=[True, True]),
server_identical=Mock(side_effect=[False, False]),
ConfigProxy=config_proxy_mock,
do_state_change=Mock(return_value=Mock(errorcode=0))):
self.module = netscaler_server
result = self.failed()
self.assertEqual(result['msg'], 'Server seems to be present')
self.assertTrue(result['failed'])
def test_successful_initialize(self, snapmirror_initialize):
''' initialize snapmirror and testing idempotency '''
data = self.set_default_args()
set_module_args(data)
my_obj = my_module()
my_obj.asup_log_for_cserver = Mock(return_value=None)
if not self.onbox:
my_obj.server = MockONTAPConnection('snapmirror',
status='transferring')
with pytest.raises(AnsibleExitJson) as exc:
my_obj.apply()
assert exc.value.args[0]['changed']
snapmirror_initialize.assert_called_with()
# to reset na_helper from remembering the previous 'changed' value
data = self.set_default_args()
set_module_args(data)
my_obj = my_module()
my_obj.asup_log_for_cserver = Mock(return_value=None)
if not self.onbox:
my_obj.server = MockONTAPConnection('snapmirror',
status='idle',
parm='snapmirrored')
with pytest.raises(AnsibleExitJson) as exc:
my_obj.apply()
assert not exc.value.args[0]['changed']
def test_successful_modify(self, snapmirror_modify):
''' modifying snapmirror and testing idempotency '''
data = self.set_default_args()
data['policy'] = 'ansible2'
data['schedule'] = 'abc2'
data['max_transfer_rate'] = 2000
set_module_args(data)
my_obj = my_module()
my_obj.asup_log_for_cserver = Mock(return_value=None)
if not self.onbox:
my_obj.server = MockONTAPConnection('snapmirror', status='idle')
with pytest.raises(AnsibleExitJson) as exc:
my_obj.apply()
assert exc.value.args[0]['changed']
snapmirror_modify.assert_called_with({
'policy': 'ansible2',
'schedule': 'abc2',
'max_transfer_rate': 2000
})
# to reset na_helper from remembering the previous 'changed' value
data = self.set_default_args()
set_module_args(data)
my_obj = my_module()
my_obj.asup_log_for_cserver = Mock(return_value=None)
if not self.onbox:
my_obj.server = MockONTAPConnection('snapmirror',
status='idle',
parm='snapmirrored')
with pytest.raises(AnsibleExitJson) as exc:
my_obj.apply()
assert not exc.value.args[0]['changed']
def test_successful_create(self, snapmirror_create):
''' creating snapmirror and testing idempotency '''
data = self.set_default_args()
data['schedule'] = 'abc'
data['identity_preserve'] = True
set_module_args(data)
my_obj = my_module()
my_obj.asup_log_for_cserver = Mock(return_value=None)
if not self.onbox:
my_obj.server = self.server
with pytest.raises(AnsibleExitJson) as exc:
my_obj.apply()
assert exc.value.args[0]['changed']
snapmirror_create.assert_called_with()
# to reset na_helper from remembering the previous 'changed' value
set_module_args(self.set_default_args())
my_obj = my_module()
my_obj.asup_log_for_cserver = Mock(return_value=None)
if not self.onbox:
my_obj.server = MockONTAPConnection('snapmirror',
'snapmirrored',
status='idle')
with pytest.raises(AnsibleExitJson) as exc:
my_obj.apply()
assert not exc.value.args[0]['changed']
def _mock_module(self):
mock_module = Mock()
mock_module.params = {'gather_subset': self.gather_subset,
'gather_timeout': 5,
'filter': '*'}
mock_module.get_bin_path = Mock(return_value=None)
return mock_module
def test_lb_monitor_identical_sanity_check(self):
set_module_args(dict(
nitro_user='******',
nitro_pass='******',
nsip='192.0.2.1',
state='present',
))
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_lb_monitor
lb_monitor_proxy_mock = Mock(diff_object=Mock(return_value={}))
client_mock = Mock()
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_lb_monitor',
get_nitro_client=Mock(return_value=client_mock),
lbmonitor_exists=Mock(side_effect=[True, True]),
lbmonitor_identical=Mock(side_effect=[False, False]),
ConfigProxy=Mock(return_value=lb_monitor_proxy_mock),
ensure_feature_is_enabled=Mock(return_value=True),
get_immutables_intersection=(Mock(return_value=[])),
nitro_exception=self.MockException,
diff_list=Mock(return_value={}),
):
self.module = netscaler_lb_monitor
result = self.failed()
self.assertEqual(result['msg'], 'lb monitor is not configured correctly')
def test_graceful_login_error(self):
set_module_args(
dict(
nitro_user='******',
nitro_pass='******',
nsip='192.0.2.1',
state='present',
))
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_lb_vserver
if sys.version_info[:2] == (2, 6):
self.skipTest('requests library not available under python2.6')
client_mock = Mock()
attrs = {'login.side_effect': requests.exceptions.SSLError}
client_mock.configure_mock(**attrs)
m = Mock(return_value=client_mock)
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_lb_vserver',
get_nitro_client=m,
nitro_exception=self.MockException,
do_state_change=Mock(return_value=Mock(errorcode=0)),
):
self.module = netscaler_lb_vserver
result = self.failed()
self.assertTrue(result['msg'].startswith('SSL Error'),
msg='SSL Error was not handled gracefully')
def test_absent_gslb_site_execution_flow(self):
set_module_args(
dict(
nitro_user='******',
nitro_pass='******',
nsip='192.0.2.1',
state='absent',
))
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_gslb_service
client_mock = Mock()
m = Mock(return_value=client_mock)
glsb_service_proxy_attrs = {
'diff_object.return_value': {},
}
gslb_service_proxy_mock = Mock()
gslb_service_proxy_mock.configure_mock(**glsb_service_proxy_attrs)
config_proxy_mock = Mock(return_value=gslb_service_proxy_mock)
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_gslb_service',
get_nitro_client=m,
diff_list=Mock(return_value={}),
get_immutables_intersection=Mock(return_value=[]),
gslb_service_exists=Mock(side_effect=[True, False]),
gslb_service_identical=Mock(side_effect=[False, True]),
ensure_feature_is_enabled=Mock(),
monkey_patch_nitro_api=Mock(),
ConfigProxy=config_proxy_mock,
):
self.module = netscaler_gslb_service
self.exited()
gslb_service_proxy_mock.assert_has_calls([call.delete()])
def test_lsblk_uuid_no_lsblk(self):
module = Mock()
module.get_bin_path = Mock(return_value=None)
lh = linux.LinuxHardware(module=module, load_on_init=False)
lsblk_uuids = lh._lsblk_uuid()
self.assertIsInstance(lsblk_uuids, dict)
self.assertEqual(len(lsblk_uuids), 0)
def _mock_module(self):
mock_module = Mock()
mock_module.params = {'gather_subset': self.gather_subset,
'gather_timeout': 10,
'filter': '*'}
mock_module.get_bin_path = Mock(return_value='/not/actually/facter')
mock_module.run_command = Mock(return_value=(0, facter_json_output, ''))
return mock_module
def test_find_bind_mounts_no_findmnts(self):
module = Mock()
module.get_bin_path = Mock(return_value=None)
lh = linux.LinuxHardware(module=module, load_on_init=False)
bind_mounts = lh._find_bind_mounts()
self.assertIsInstance(bind_mounts, set)
self.assertEqual(len(bind_mounts), 0)
def test_udevadm_uuid(self):
module = Mock()
module.run_command = Mock(return_value=(0, UDEVADM_OUTPUT,
'')) # (rc, out, err)
lh = linux.LinuxHardware(module=module, load_on_init=False)
udevadm_uuid = lh._udevadm_uuid('mock_device')
self.assertEqual(udevadm_uuid, '57b1a3e7-9019-4747-9809-7ec52bba9179')
def mock_module():
mock_module = Mock()
mock_module.params = {
'gather_subset': ['all'],
'gather_timeout': 5,
'filter': '*'
}
mock_module.get_bin_path = Mock(return_value=None)
return mock_module
def get_port_mock_object(self):
"""
Helper method to return an na_ontap_port object
"""
port_obj = port_module()
port_obj.asup_log_for_cserver = Mock(return_value=None)
port_obj.server = Mock()
port_obj.server.invoke_successfully = Mock()
return port_obj
def test_present_cs_action_identical_flow(self):
set_module_args(
dict(
nitro_user='******',
nitro_pass='******',
nsip='192.0.2.1',
state='present',
))
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_cs_action
client_mock = Mock()
m = Mock(return_value=client_mock)
server_proxy_attrs = {
'diff_object.return_value': {},
}
cs_action_proxy_mock = Mock()
cs_action_proxy_mock.configure_mock(**server_proxy_attrs)
config_proxy_mock = Mock(return_value=cs_action_proxy_mock)
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_cs_action',
get_nitro_client=m,
diff_list=Mock(return_value={}),
get_immutables_intersection=Mock(return_value=[]),
action_exists=Mock(side_effect=[True, True]),
action_identical=Mock(side_effect=[True, True]),
ensure_feature_is_enabled=Mock(return_value=True),
ConfigProxy=config_proxy_mock,
):
self.module = netscaler_cs_action
self.exited()
cs_action_proxy_mock.assert_not_called()
