def __init__(self):
self.files_watched = 0
self.register = MagicMock(side_effect=self._register)
self.unregister = MagicMock(side_effect=self._unregister)
self.close = MagicMock()
self.get_map = MagicMock(side_effect=self._get_map)
self.select = MagicMock()
def setUp(self):
super(TestNxosConfigModule, self).setUp()
self.mock_get_config = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.nxos_config.get_config'
)
self.get_config = self.mock_get_config.start()
self.mock_load_config = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.nxos_config.load_config'
)
self.load_config = self.mock_load_config.start()
self.mock_save_config = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.nxos_config.save_config'
)
self.save_config = self.mock_save_config.start()
self.mock_get_connection = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.nxos_config.get_connection'
)
self.get_connection = self.mock_get_connection.start()
self.conn = self.get_connection()
self.conn.edit_config = MagicMock()
self.mock_run_commands = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.nxos_config.run_commands'
)
self.run_commands = self.mock_run_commands.start()
self.cliconf_obj = Cliconf(MagicMock())
self.running_config = load_fixture('nxos_config', 'config.cfg')
def test_multiple_failures(self, monkeypatch):
monkeypatch.setattr(C, 'HOST_KEY_CHECKING', False)
monkeypatch.setattr(C, 'ANSIBLE_SSH_RETRIES', 9)
monkeypatch.setattr('time.sleep', lambda x: None)
self.mock_popen_res.stdout.read.side_effect = [b""] * 10
self.mock_popen_res.stderr.read.side_effect = [b""] * 10
type(self.mock_popen_res).returncode = PropertyMock(side_effect=[255] *
30)
self.mock_selector.select.side_effect = [
[(SelectorKey(self.mock_popen_res.stdout, 1001, [EVENT_READ],
None), EVENT_READ)],
[(SelectorKey(self.mock_popen_res.stderr, 1002, [EVENT_READ],
None), EVENT_READ)],
[],
] * 10
self.mock_selector.get_map.side_effect = lambda: True
self.conn._build_command = MagicMock()
self.conn._build_command.return_value = 'ssh'
self.conn.get_option = MagicMock()
self.conn.get_option.return_value = True
pytest.raises(AnsibleConnectionFailure, self.conn.exec_command, 'ssh',
'some data')
assert self.mock_popen.call_count == 10
def setUpClass(cls):
m = MagicMock()
cls.service_mock = MagicMock()
cls.service_mock.__class__ = MagicMock()
cls.service_lbmonitor_binding_mock = MagicMock()
cls.lbmonitor_service_binding_mock = MagicMock()
nssrc_modules_mock = {
'nssrc.com.citrix.netscaler.nitro.resource.config.basic':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.basic.service':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.basic.service.service':
cls.service_mock,
'nssrc.com.citrix.netscaler.nitro.resource.config.basic.service_lbmonitor_binding':
cls.service_lbmonitor_binding_mock,
'nssrc.com.citrix.netscaler.nitro.resource.config.basic.service_lbmonitor_binding.service_lbmonitor_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.lb':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbmonitor_service_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbmonitor_service_binding.lbmonitor_service_binding':
cls.lbmonitor_service_binding_mock,
}
cls.nitro_specific_patcher = patch.dict(sys.modules,
nssrc_modules_mock)
cls.nitro_base_patcher = nitro_base_patcher
def test_update_servicegroup_when_service_members_differ(self):
self.set_module_state('present')
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_servicegroup
servicegroup_proxy_mock = MagicMock()
attrs = {
'diff_object.return_value': {},
}
servicegroup_proxy_mock.configure_mock(**attrs)
m = MagicMock(return_value=servicegroup_proxy_mock)
sync_mock = Mock()
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_servicegroup',
ConfigProxy=m,
servicegroup_exists=Mock(side_effect=[True, True]),
servicegroup_identical=Mock(side_effect=[True, True]),
monitor_bindings_identical=Mock(side_effect=[True, True]),
sync_monitor_bindings=Mock(),
servicemembers_identical=Mock(side_effect=[False, True]),
sync_service_members=sync_mock,
do_state_change=Mock(return_value=Mock(errorcode=0)),
):
self.module = netscaler_servicegroup
result = self.exited()
# poor man's assert_called_once since python3.5 does not implement that mock method
self.assertEqual(len(sync_mock.mock_calls),
1,
msg='sync monitor bindings not called once')
self.assertTrue(result['changed'], msg='Change not recorded')
def test_network_cli_send(self, mocked_connect, mocked_terminal_re):
pc = PlayContext()
pc.network_os = 'ios'
conn = connection_loader.get('network_cli', pc, '/dev/null')
mock__terminal = MagicMock()
mocked_terminal_re.side_effect = [[re.compile(b'^ERROR')],
[re.compile(b'device#')]]
conn._terminal = mock__terminal
mock__shell = MagicMock()
conn._ssh_shell = mock__shell
response = b"""device#command
command response
device#
"""
mock__shell.recv.side_effect = [response, None]
conn.send(b'command')
mock__shell.sendall.assert_called_with(b'command\r')
self.assertEqual(to_text(conn._command_response), 'command response')
mock__shell.reset_mock()
mock__shell.recv.side_effect = [b"ERROR: error message device#"]
mocked_terminal_re.side_effect = [[re.compile(b'^ERROR')],
[re.compile(b'device#')]]
with self.assertRaises(AnsibleConnectionFailure) as exc:
conn.send(b'command')
self.assertEqual(str(exc.exception), 'ERROR: error message device#')
def setUp(self):
super(TestEosConfigModule, self).setUp()
self.mock_get_config = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.eos_config.get_config'
)
self.get_config = self.mock_get_config.start()
self.mock_get_connection = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.eos_config.get_connection'
)
self.get_connection = self.mock_get_connection.start()
self.mock_load_config = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.eos_config.load_config'
)
self.load_config = self.mock_load_config.start()
self.mock_run_commands = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.eos_config.run_commands'
)
self.run_commands = self.mock_run_commands.start()
self.mock_supports_sessions = patch(
'ansible_collections.notstdlib.moveitallout.plugins.cliconf.eos.Cliconf.supports_sessions'
)
self.supports_sessions = self.mock_supports_sessions.start()
self.mock_supports_sessions.return_value = True
self.conn = self.get_connection()
self.conn.edit_config = MagicMock()
self.cliconf_obj = Cliconf(MagicMock())
self.running_config = load_fixture('eos_config_config.cfg')
def setUpClass(cls):
class MockException(Exception):
pass
cls.MockException = MockException
m = MagicMock()
cls.server_mock = MagicMock()
cls.server_mock.__class__ = MagicMock(add=Mock())
nssrc_modules_mock = {
'nssrc.com.citrix.netscaler.nitro.resource.config.lb':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbvserver':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbvserver.lbvserver':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbvserver_service_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbvserver_service_binding.lbvserver_service_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbvserver_servicegroup_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbvserver_servicegroup_binding.lbvserver_servicegroup_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.ssl':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.ssl.sslvserver_sslcertkey_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.ssl.sslvserver_sslcertkey_binding.sslvserver_sslcertkey_binding':
m,
}
cls.nitro_specific_patcher = patch.dict(sys.modules,
nssrc_modules_mock)
cls.nitro_base_patcher = nitro_base_patcher
def test_servicegroup_monitor_bindings_sanity(self):
self.set_module_state('present')
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_servicegroup
servicegroup_proxy_mock = MagicMock()
attrs = {
'diff_object.return_value': {},
}
servicegroup_proxy_mock.configure_mock(**attrs)
m = MagicMock(return_value=servicegroup_proxy_mock)
sync_mock = Mock()
with patch.multiple(
'ansible_collections.notstdlib.moveitallout.plugins.modules.netscaler_servicegroup',
ConfigProxy=m,
servicegroup_exists=Mock(side_effect=[True, True]),
servicegroup_identical=Mock(side_effect=[True, True]),
monitor_bindings_identical=Mock(side_effect=[False, False]),
sync_monitor_bindings=Mock(),
servicemembers_identical=Mock(side_effect=[True, True]),
nitro_exception=self.MockException,
sync_service_members=sync_mock,
do_state_change=Mock(return_value=Mock(errorcode=0)),
):
self.module = netscaler_servicegroup
result = self.failed()
self.assertEqual(result['msg'],
'Monitor bindings are not identical')
def setUpClass(cls):
class MockException(Exception):
pass
cls.MockException = MockException
m = MagicMock()
cls.servicegroup_mock = MagicMock()
cls.servicegroup_mock.__class__ = MagicMock()
nssrc_modules_mock = {
'nssrc.com.citrix.netscaler.nitro.resource.config.basic':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.basic.servicegroup':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.basic.servicegroup.servicegroup':
cls.servicegroup_mock,
'nssrc.com.citrix.netscaler.nitro.resource.config.basic.servicegroup_servicegroupmember_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.basic.servicegroup_servicegroupmember_binding.servicegroup_servicegroupmember_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.basic.servicegroup_lbmonitor_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.basic.servicegroup_lbmonitor_binding.servicegroup_lbmonitor_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.lb':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbmonitor_servicegroup_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.lb.lbmonitor_servicegroup_binding.lbmonitor_servicegroup_binding':
m
}
cls.nitro_specific_patcher = patch.dict(sys.modules,
nssrc_modules_mock)
cls.nitro_base_patcher = nitro_base_patcher
def test_no_change_to_module_when_all_identical(self):
self.set_module_state('present')
from ansible_collections.notstdlib.moveitallout.plugins.modules import netscaler_servicegroup
servicegroup_proxy_mock = MagicMock()
attrs = {
'diff_object.return_value': {},
}
servicegroup_proxy_mock.configure_mock(**attrs)
m = MagicMock(return_value=servicegroup_proxy_mock)
servicegroup_exists_mock = Mock(side_effect=[True, True])
servicegroup_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_servicegroup',
ConfigProxy=m,
servicegroup_exists=servicegroup_exists_mock,
servicegroup_identical=servicegroup_identical_mock,
servicemembers_identical=Mock(side_effect=[True, True]),
monitor_bindings_identical=monitor_bindings_identical_mock,
do_state_change=Mock(return_value=Mock(errorcode=0)),
nitro_exception=self.MockException,
):
self.module = netscaler_servicegroup
result = self.exited()
self.assertFalse(result['changed'],
msg='Erroneous changed status update')
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_module_utils_basic_ansible_module_selinux_default_context(self):
from ansible_collections.notstdlib.moveitallout.plugins.module_utils import basic
basic._ANSIBLE_ARGS = None
am = basic.AnsibleModule(
argument_spec=dict(),
)
am.selinux_initial_context = MagicMock(return_value=[None, None, None, None])
am.selinux_enabled = MagicMock(return_value=True)
# we first test the cases where the python selinux lib is not installed
basic.HAVE_SELINUX = False
self.assertEqual(am.selinux_default_context(path='/foo/bar'), [None, None, None, None])
# all following tests assume the python selinux bindings are installed
basic.HAVE_SELINUX = True
basic.selinux = Mock()
with patch.dict('sys.modules', {'selinux': basic.selinux}):
# next, we test with a mocked implementation of selinux.matchpathcon to simulate
# an actual context being found
with patch('selinux.matchpathcon', return_value=[0, 'unconfined_u:object_r:default_t:s0']):
self.assertEqual(am.selinux_default_context(path='/foo/bar'), ['unconfined_u', 'object_r', 'default_t', 's0'])
# we also test the case where matchpathcon returned a failure
with patch('selinux.matchpathcon', return_value=[-1, '']):
self.assertEqual(am.selinux_default_context(path='/foo/bar'), [None, None, None, None])
# finally, we test where an OSError occurred during matchpathcon's call
with patch('selinux.matchpathcon', side_effect=OSError):
self.assertEqual(am.selinux_default_context(path='/foo/bar'), [None, None, None, None])
delattr(basic, 'selinux')
def test_module_utils_basic_ansible_module_selinux_enabled(self):
from ansible_collections.notstdlib.moveitallout.plugins.module_utils import basic
basic._ANSIBLE_ARGS = None
am = basic.AnsibleModule(
argument_spec=dict(),
)
# we first test the cases where the python selinux lib is
# not installed, which has two paths: one in which the system
# does have selinux installed (and the selinuxenabled command
# is present and returns 0 when run), or selinux is not installed
basic.HAVE_SELINUX = False
am.get_bin_path = MagicMock()
am.get_bin_path.return_value = '/path/to/selinuxenabled'
am.run_command = MagicMock()
am.run_command.return_value = (0, '', '')
self.assertRaises(SystemExit, am.selinux_enabled)
am.get_bin_path.return_value = None
self.assertEqual(am.selinux_enabled(), False)
# finally we test the case where the python selinux lib is installed,
# and both possibilities there (enabled vs. disabled)
basic.HAVE_SELINUX = True
basic.selinux = Mock()
with patch.dict('sys.modules', {'selinux': basic.selinux}):
with patch('selinux.is_selinux_enabled', return_value=0):
self.assertEqual(am.selinux_enabled(), False)
with patch('selinux.is_selinux_enabled', return_value=1):
self.assertEqual(am.selinux_enabled(), True)
delattr(basic, 'selinux')
def test_update_called_when_traffic_type_exists(self):
set_module_args(base_module_args)
module = setup_module_object()
actt = AnsibleCloudStackTrafficType(module)
actt.get_traffic_type = MagicMock(return_value=EXISTING_TRAFFIC_TYPES_RESPONSE['traffictype'][0])
actt.update_traffic_type = MagicMock()
actt.present_traffic_type()
self.assertTrue(actt.update_traffic_type.called)
def test_plugins_connection_aws_ssm_get_url(self, boto):
pc = PlayContext()
new_stdin = StringIO()
conn = connection_loader.get('aws_ssm', pc, new_stdin)
boto3 = MagicMock()
boto3.client('s3').return_value = MagicMock()
boto3.generate_presigned_url.return_value = MagicMock()
return (boto3.generate_presigned_url.return_value)
def test_plugins_connection_aws_ssm_fetch_file(self):
pc = PlayContext()
new_stdin = StringIO()
conn = connection_loader.get('aws_ssm', pc, new_stdin)
conn._connect = MagicMock()
conn._file_transport_command = MagicMock()
conn._file_transport_command.return_value = (0, 'stdout', 'stderr')
res, stdout, stderr = conn.fetch_file('/in/file', '/out/file')
def test_smoketest_load_file_common_args(self, am):
"""With no file arguments, an empty dict is returned"""
am.selinux_mls_enabled = MagicMock()
am.selinux_mls_enabled.return_value = True
am.selinux_default_context = MagicMock()
am.selinux_default_context.return_value = 'unconfined_u:object_r:default_t:s0'.split(
':', 3)
assert am.load_file_common_arguments(params={}) == {}
def test_traffic_type_returned_if_exists(self):
set_module_args(base_module_args)
module = setup_module_object()
actt = AnsibleCloudStackTrafficType(module)
actt.get_physical_network = MagicMock(return_value=VALID_LIST_NETWORKS_RESPONSE['physicalnetwork'][0])
actt.get_traffic_types = MagicMock(return_value=EXISTING_TRAFFIC_TYPES_RESPONSE)
tt = actt.present_traffic_type()
self.assertTrue(tt.get('kvmnetworklabel') == base_module_args['kvm_networklabel'])
self.assertTrue(tt.get('traffictype') == base_module_args['traffic_type'])
def test_plugins_connection_aws_ssm_flush_stderr(self, s_popen):
pc = PlayContext()
new_stdin = StringIO()
conn = connection_loader.get('aws_ssm', pc, new_stdin)
conn.poll_stderr = MagicMock()
conn.poll_stderr.register = MagicMock()
conn.stderr = None
s_popen.poll().return_value = 123
return(conn.stderr)
def test_update_not_called_when_traffic_type_doesnt_exist(self):
set_module_args(base_module_args)
module = setup_module_object()
actt = AnsibleCloudStackTrafficType(module)
actt.get_traffic_type = MagicMock(return_value=None)
actt.update_traffic_type = MagicMock()
actt.add_traffic_type = MagicMock()
actt.present_traffic_type()
self.assertFalse(actt.update_traffic_type.called)
self.assertTrue(actt.add_traffic_type.called)
def test_iosxr_config_lines_w_parents(self):
lines = ['shutdown']
parents = ['interface GigabitEthernet0/0']
set_module_args(dict(lines=lines, parents=parents))
module = MagicMock()
module.params = {'lines': lines, 'parents': parents, 'src': None}
candidate_config = iosxr_config.get_candidate(module)
self.conn.get_diff = MagicMock(return_value=self.cliconf_obj.get_diff(candidate_config, self.running_config))
commands = ['interface GigabitEthernet0/0', 'shutdown']
self.execute_module(changed=True, commands=commands)
def setUp(self):
super(TestNiosCNameRecordModule, self).setUp()
self.module = MagicMock(name='ansible_collections.notstdlib.moveitallout.plugins.modules.nios_cname_record.WapiModule')
self.module.check_mode = False
self.module.params = {'provider': None}
self.mock_wapi = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.nios_cname_record.WapiModule')
self.exec_command = self.mock_wapi.start()
self.mock_wapi_run = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.nios_cname_record.WapiModule.run')
self.mock_wapi_run.start()
self.load_config = self.mock_wapi_run.start()
def test_plugins_connection_aws_ssm_post_process(self):
pc = PlayContext()
new_stdin = StringIO()
conn = connection_loader.get('aws_ssm', pc, new_stdin)
conn.is_windows = MagicMock()
conn.is_windows.return_value = True
success = 3
fail = 2
conn.stdout = MagicMock()
returncode = 0
return(returncode, conn.stdout)
def setUp(self):
super(TestNiosApi, self).setUp()
self.module = MagicMock(name='AnsibleModule')
self.module.check_mode = False
self.module.params = {'provider': None}
self.mock_connector = patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.net_tools.nios.api.get_connector'
)
self.mock_connector.start()
def patched_openvswitch_db(monkeypatch):
mocked_ovs_db = MagicMock()
mocked_ovs_db.return_value = {
'table': 'open_vswitch',
'record': '.',
'col': 'other_config',
'key': 'pmd-cpu-mask',
'value': '0xaaa00000000'
}
monkeypatch.setattr(openvswitch_db, 'map_config_to_obj', mocked_ovs_db)
return openvswitch_db
def test_iosxr_config_match_none(self):
lines = ['ip address 1.2.3.4 255.255.255.0', 'description test string']
parents = ['interface GigabitEthernet0/0']
set_module_args(dict(lines=lines, parents=parents, match='none'))
commands = parents + lines
module = MagicMock()
module.params = {'lines': lines, 'parents': parents, 'src': None}
candidate_config = iosxr_config.get_candidate(module)
self.conn.get_diff = MagicMock(return_value=self.cliconf_obj.get_diff(candidate_config, self.running_config, diff_match='none', path=parents))
self.execute_module(changed=True, commands=commands, sort=False)
def test_iosxr_config_replace_block(self):
lines = ['description test string', 'test string']
parents = ['interface GigabitEthernet0/0']
set_module_args(dict(lines=lines, replace='block', parents=parents))
commands = parents + lines
module = MagicMock()
module.params = {'lines': lines, 'parents': parents, 'src': None}
candidate_config = iosxr_config.get_candidate(module)
self.conn.get_diff = MagicMock(return_value=self.cliconf_obj.get_diff(candidate_config, self.running_config, diff_replace='block', path=parents))
self.execute_module(changed=True, commands=commands)
def patched_openvswitch_bridge(monkeypatch):
mocked_bridge = MagicMock()
mocked_bridge.return_value = {
'bridge': 'test-br2',
'parent': 'test-br',
'vlan': 200,
'fail_mode': None,
'external_ids': None,
'set': None
}
monkeypatch.setattr(openvswitch_bridge, 'map_config_to_obj', mocked_bridge)
return openvswitch_bridge
def test_icx_config_lines_w_parents(self):
lines = ['disable']
parents = ['interface ethernet 1/1/4']
set_module_args(dict(lines=lines, parents=parents))
module = MagicMock()
module.params = {'lines': lines, 'parents': parents, 'src': None}
candidate_config = icx_config.get_candidate_config(module)
self.conn.get_diff = MagicMock(return_value=self.cliconf_obj.get_diff(candidate_config, self.running_config))
commands = ['interface ethernet 1/1/4', 'disable']
self.execute_module(changed=True, commands=commands)
