def test_icx_config_before_after_no_change(self):
lines = ['hostname router']
set_module_args(
dict(lines=lines,
before=['test1', 'test2'],
after=['test3', 'test4']))
self.conn.get_diff = MagicMock(return_value=self.cliconf_obj.get_diff(
'\n'.join(lines), self.running_config))
self.execute_module()
def test_icx_config_match_exact(self):
lines = [
'speed-duplex 10-full', 'port-name test-interface-4', 'disable'
]
parents = ['interface ethernet 1/1/4']
set_module_args(dict(lines=lines, parents=parents, match='exact'))
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,
diff_match='exact',
path=parents))
commands = parents + lines
self.execute_module(changed=True, commands=commands, sort=False)
def test_manage_state_updates_nonmatching_permissions():
lambda_client_double = MagicMock()
# Policy actually: present Requested State: present Should: do nothing
lambda_client_double.get_policy.return_value = fake_policy_return
fake_module_params = copy.deepcopy(fake_module_params_different)
module_double.params = fake_module_params
lambda_policy.manage_state(module_double, lambda_client_double)
assert lambda_client_double.get_policy.call_count > 0
assert lambda_client_double.add_permission.call_count > 0
assert lambda_client_double.remove_permission.call_count > 0
def test_manage_state_removes_unwanted_permissions():
lambda_client_double = MagicMock()
# Policy actually: present Requested State: not present Should: remove
lambda_client_double.get_policy.return_value = fake_policy_return
fake_module_params = copy.deepcopy(fake_module_params_absent)
module_double.params = fake_module_params
lambda_policy.manage_state(module_double, lambda_client_double)
assert lambda_client_double.get_policy.call_count > 0
lambda_client_double.add_permission.assert_not_called()
assert lambda_client_double.remove_permission.call_count > 0
def test_sasl_bind_ldap_no_mechs_error(monkeypatch):
mock_ldap = MagicMock()
mock_ldap.return_value.sasl_gssapi_bind_s.side_effect = FakeLDAPAuthUnknownError("no mechs")
monkeypatch.setattr("ldap.initialize", mock_ldap)
with pytest.raises(AnsibleLookupError) as err:
lookup_loader.get('laps_password').run([], domain="dc01")
assert str(err.value) == "Failed to do a sasl bind against LDAP host 'ldap://dc01:389', the GSSAPI mech is " \
"not installed: no mechs"
def setUp(self):
super(TestNiosNAPTRRecordModule, self).setUp()
self.module = MagicMock(name='ansible_collections.misc.not_a_real_collection.plugins.modules.nios_naptr_record.WapiModule')
self.module.check_mode = False
self.module.params = {'provider': None}
self.mock_wapi = patch('ansible_collections.misc.not_a_real_collection.plugins.modules.nios_naptr_record.WapiModule')
self.exec_command = self.mock_wapi.start()
self.mock_wapi_run = patch('ansible_collections.misc.not_a_real_collection.plugins.modules.nios_naptr_record.WapiModule.run')
self.mock_wapi_run.start()
self.load_config = self.mock_wapi_run.start()
def test_ios_config_match_exact(self):
lines = [
'ip address 1.2.3.4 255.255.255.0', 'description test string',
'shutdown'
]
parents = ['interface GigabitEthernet0/0']
set_module_args(dict(lines=lines, parents=parents, match='exact'))
module = MagicMock()
module.params = {'lines': lines, 'parents': parents, 'src': None}
candidate_config = ios_config.get_candidate_config(module)
self.conn.get_diff = MagicMock(
return_value=self.cliconf_obj.get_diff(candidate_config,
self.running_config,
diff_match='exact',
path=parents))
commands = parents + lines
self.execute_module(changed=True, commands=commands, sort=False)
def setUp(self):
super(TestJunosPingModule, self).setUp()
self.mock_get_connection = patch(
'ansible_collections.misc.not_a_real_collection.plugins.modules.junos_ping.get_connection'
)
self.get_connection = self.mock_get_connection.start()
self.conn = self.get_connection()
self.conn.get = MagicMock()
def test_simple_bind_ldap_error(monkeypatch):
mock_ldap = MagicMock()
mock_ldap.return_value.bind_s.side_effect = FakeLDAPError("fake error")
monkeypatch.setattr("ldap.initialize", mock_ldap)
with pytest.raises(AnsibleLookupError) as err:
lookup_loader.get('laps_password').run([], domain="dc01", auth="simple", username="******", password="******",
allow_plaintext=True)
assert str(err.value) == "Failed to simple bind against LDAP host 'ldap://dc01:389': fake error"
def test_nxos_config_lines(self):
lines = ['hostname switch01', 'ip domain-name eng.ansible.com']
args = dict(lines=lines)
self.conn.get_diff = MagicMock(return_value=self.cliconf_obj.get_diff('\n'.join(lines), self.running_config))
set_module_args(args)
result = self.execute_module(changed=True)
config = ['hostname switch01']
self.assertEqual(sorted(config), sorted(result['commands']), result['commands'])
def test_cli_config_backup_returns__backup__(self, run_mock):
self.conn.get_capabilities = MagicMock(return_value='{}')
args = dict(backup=True)
set_module_args(args)
run_mock.return_value = {}
result = self.execute_module()
self.assertIn('__backup__', result)
def test_manage_state_leaves_already_removed_permissions():
lambda_client_double = MagicMock()
# Policy actually: absent Requested State: absent Should: do nothing
lambda_client_double.get_policy.side_effect = ClientError(
error_response, operation_name)
fake_module_params = copy.deepcopy(fake_module_params_absent)
module_double.params = fake_module_params
lambda_policy.manage_state(module_double, lambda_client_double)
assert lambda_client_double.get_policy.call_count > 0
lambda_client_double.add_permission.assert_not_called()
lambda_client_double.remove_permission.assert_not_called()
def test_nxos_config_src(self):
src = load_fixture('nxos_config', 'candidate.cfg')
args = dict(src=src)
self.conn.get_diff = MagicMock(return_value=self.cliconf_obj.get_diff(src, self.running_config))
set_module_args(args)
result = self.execute_module(changed=True)
config = ['hostname switch01', 'interface Ethernet1',
'description test interface', 'no shutdown', 'ip routing']
self.assertEqual(sorted(config), sorted(result['commands']), result['commands'])
def test_simple_auth_with_start_tls(monkeypatch):
mock_ldap_option = MagicMock()
monkeypatch.setattr(FakeLdap, "set_option", mock_ldap_option)
mock_ldap = MagicMock()
monkeypatch.setattr("ldap.initialize", mock_ldap)
lookup_loader.get('laps_password').run([], domain="dc01", start_tls=True, auth="simple", username="******",
password="******")
assert mock_ldap_option.mock_calls[0][1] == (FakeLdap.OPT_X_TLS_REQUIRE_CERT, FakeLdap.OPT_X_TLS_DEMAND)
assert mock_ldap.mock_calls[3][0] == "().start_tls_s"
assert mock_ldap.mock_calls[3][1] == ()
assert mock_ldap.mock_calls[4][0] == '().bind_s'
assert mock_ldap.mock_calls[4][1] == (u"user", u"pass")
assert mock_ldap.mock_calls[5][0] == "().read_rootdse_s"
assert mock_ldap.mock_calls[5][1] == ()
def test_nxos_config_parents(self):
lines = ['ip address 1.2.3.4/5', 'no shutdown']
parents = ['interface Ethernet10']
args = dict(lines=lines, parents=parents)
self.conn.get_diff = MagicMock(return_value=self.cliconf_obj.get_diff('\n'.join(parents + lines), self.running_config, path=parents))
set_module_args(args)
result = self.execute_module(changed=True)
config = ['interface Ethernet10', 'ip address 1.2.3.4/5', 'no shutdown']
self.assertEqual(config, result['commands'], result['commands'])
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_exec_with_become_no_plugin_set(self, test_win_updates):
set_become_mock = MagicMock()
test_win_updates._connection.become = None
test_win_updates._connection.set_become_plugin = set_become_mock
with patch('ansible.plugins.action.ActionBase._execute_module',
new=MagicMock()):
test_win_updates._execute_module_with_become(
'win_updates', {}, {}, True, False)
assert set_become_mock.call_count == 2
assert isinstance(set_become_mock.mock_calls[0][1][0], BecomeModule)
assert set_become_mock.mock_calls[0][1][0].name == 'runas'
assert set_become_mock.mock_calls[0][1][0].get_option(
'become_user') == 'SYSTEM'
assert set_become_mock.mock_calls[0][1][0].get_option(
'become_flags') == ''
assert set_become_mock.mock_calls[0][1][0].get_option(
'become_pass') is None
assert set_become_mock.mock_calls[1][1] == (None, )
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.ssl':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.ssl.sslcertkey':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.ssl.sslcertkey.sslcertkey':
m,
}
cls.nitro_specific_patcher = patch.dict(sys.modules,
nssrc_modules_mock)
cls.nitro_base_patcher = nitro_base_patcher
def test_voss_config_save_changed_true(self):
src = load_fixture('voss_config_src.cfg')
set_module_args(dict(src=src, save_when='changed'))
commands = ['prompt "VSP8K"', 'interface GigabitEthernet 1/1',
'name "UNUSED"', 'exit']
self.conn.get_diff = MagicMock(return_value=self.cliconf_obj.get_diff(src, self.running_config))
self.execute_module(changed=True, commands=commands)
self.assertEqual(self.run_commands.call_count, 1)
self.assertEqual(self.get_config.call_count, 1)
self.assertEqual(self.conn.edit_config.call_count, 1)
args = self.run_commands.call_args[0][1]
self.assertIn('save config\r', args)
def setUp(self):
super(TestVyosConfigModule, self).setUp()
self.mock_get_config = patch('ansible_collections.misc.not_a_real_collection.plugins.modules.vyos_config.get_config')
self.get_config = self.mock_get_config.start()
self.mock_load_config = patch('ansible_collections.misc.not_a_real_collection.plugins.modules.vyos_config.load_config')
self.load_config = self.mock_load_config.start()
self.mock_run_commands = patch('ansible_collections.misc.not_a_real_collection.plugins.modules.vyos_config.run_commands')
self.run_commands = self.mock_run_commands.start()
self.mock_get_connection = patch('ansible_collections.misc.not_a_real_collection.plugins.modules.vyos_config.get_connection')
self.get_connection = self.mock_get_connection.start()
self.cliconf_obj = Cliconf(MagicMock())
self.running_config = load_fixture('vyos_config_config.cfg')
self.conn = self.get_connection()
self.conn.edit_config = MagicMock()
self.running_config = load_fixture('vyos_config_config.cfg')
def test_icx_config_save_changed_true(self):
src = load_fixture('icx_config_src.cfg')
set_module_args(dict(src=src, save_when='changed'))
commands = ['hostname foo', 'interface ethernet 1/1/4', 'disable']
self.conn.get_diff = MagicMock(
return_value=self.cliconf_obj.get_diff(src, self.running_config))
self.execute_module(changed=True, commands=commands)
self.assertEqual(self.run_commands.call_count, 2)
self.assertEqual(self.get_config.call_count, 1)
self.assertEqual(self.conn.edit_config.call_count, 1)
args = self.run_commands.call_args[0][1]
self.assertIn('write memory', args)
def setUpClass(cls):
class MockException(Exception):
pass
cls.MockException = MockException
m = MagicMock()
nssrc_modules_mock = {
'nssrc.com.citrix.netscaler.nitro.resource.config.cs': m,
'nssrc.com.citrix.netscaler.nitro.resource.config.cs.cspolicy': m,
}
cls.nitro_specific_patcher = patch.dict(sys.modules, nssrc_modules_mock)
cls.nitro_base_patcher = nitro_base_patcher
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_module_exec_async_result(self, monkeypatch):
return_val = {
"ansible_async_watchdog_pid": 7584,
"ansible_job_id": "545519115287.9620",
"changed": True,
"finished": 0,
"results_file": r"C:\.ansible_async\545519115287.9620",
"started": 1
}
mock_execute = MagicMock(return_value=return_val)
monkeypatch.setattr(ActionModule, '_execute_module', mock_execute)
task = MagicMock(Task)
task.args = {}
task.async_val = 10
connection = MagicMock()
connection.module_implementation_preferences = ('.ps1', '.exe', '')
play_context = MagicMock()
play_context.check_mode = False
play_context.become = True
play_context.become_method = 'runas'
play_context.become_user = '******'
plugin = ActionModule(task,
connection,
play_context,
loader=None,
templar=None,
shared_loader_obj=None)
actual = plugin.run(None, {})
assert actual.get('failed') is None
assert actual['ansible_async_watchdog_pid'] == 7584
assert actual['ansible_job_id'] == "545519115287.9620"
assert actual['changed'] is True
assert actual['finished'] == 0
assert actual['results_file'] == r"C:\.ansible_async\545519115287.9620"
assert actual['started'] == 1
def test_junos_ping_success_stats(self):
set_module_args(dict(count=2, dest="10.10.10.10"))
self.conn.get = MagicMock(return_value=load_fixture(
'junos_ping_ping_10.10.10.10_count_2', content='str'))
result = self.execute_module()
self.assertEqual(result['commands'], 'ping 10.10.10.10 count 2')
self.assertEqual(result['packet_loss'], '0%')
self.assertEqual(result['packets_rx'], 2)
self.assertEqual(result['packets_tx'], 2)
self.assertEqual(result['rtt']['min'], 15.71)
self.assertEqual(result['rtt']['avg'], 16.87)
self.assertEqual(result['rtt']['max'], 18.04)
self.assertEqual(result['rtt']['stddev'], 1.165)
def test_absent_operation_sanity(self):
self.set_module_state('absent')
from ansible_collections.misc.not_a_real_collection.plugins.modules import netscaler_servicegroup
with patch.multiple(
'ansible_collections.misc.not_a_real_collection.plugins.modules.netscaler_servicegroup',
ConfigProxy=MagicMock(),
servicegroup_exists=Mock(side_effect=[True, True]),
nitro_exception=self.MockException,
):
self.module = netscaler_servicegroup
result = self.failed()
self.assertEqual(result['msg'], 'Service group is present')
def test_absent_operation_no_change(self):
self.set_module_state('absent')
from ansible_collections.misc.not_a_real_collection.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=[False, False])
with patch.multiple(
'ansible_collections.misc.not_a_real_collection.plugins.modules.netscaler_service',
ConfigProxy=m,
service_exists=service_exists_mock,
):
self.module = netscaler_service
result = self.exited()
service_proxy_mock.assert_not_called()
self.assertFalse(result['changed'],
msg='Changed status not set correctly')
def test_create_non_existing_service(self):
self.set_module_state('present')
from ansible_collections.misc.not_a_real_collection.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=[False, True])
with patch.multiple(
'ansible_collections.misc.not_a_real_collection.plugins.modules.netscaler_service',
ConfigProxy=m,
service_exists=service_exists_mock,
do_state_change=Mock(return_value=Mock(errorcode=0)),
):
self.module = netscaler_service
result = self.exited()
service_proxy_mock.assert_has_calls([call.add()])
self.assertTrue(result['changed'], msg='Change not recorded')
def psrp_connection():
"""Imports the psrp connection plugin with a mocked pypsrp module for testing"""
# Take a snapshot of sys.modules before we manipulate it
orig_modules = sys.modules.copy()
try:
fake_pypsrp = MagicMock()
fake_pypsrp.FEATURES = [
'wsman_locale',
'wsman_read_timeout',
'wsman_reconnections',
]
fake_wsman = MagicMock()
fake_wsman.AUTH_KWARGS = {
"certificate": ["certificate_key_pem", "certificate_pem"],
"credssp": [
"credssp_auth_mechanism", "credssp_disable_tlsv1_2",
"credssp_minimum_version"
],
"negotiate": [
"negotiate_delegate", "negotiate_hostname_override",
"negotiate_send_cbt", "negotiate_service"
],
"mock": ["mock_test1", "mock_test2"],
}
sys.modules["pypsrp"] = fake_pypsrp
sys.modules["pypsrp.complex_objects"] = MagicMock()
sys.modules["pypsrp.exceptions"] = MagicMock()
sys.modules["pypsrp.host"] = MagicMock()
sys.modules["pypsrp.powershell"] = MagicMock()
sys.modules["pypsrp.shell"] = MagicMock()
sys.modules["pypsrp.wsman"] = fake_wsman
sys.modules["requests.exceptions"] = MagicMock()
from ansible_collections.misc.not_a_real_collection.plugins.connection import psrp
# Take a copy of the original import state vars before we set to an ok import
orig_has_psrp = psrp.HAS_PYPSRP
orig_psrp_imp_err = psrp.PYPSRP_IMP_ERR
yield psrp
psrp.HAS_PYPSRP = orig_has_psrp
psrp.PYPSRP_IMP_ERR = orig_psrp_imp_err
finally:
# Restore sys.modules back to our pre-shenanigans
sys.modules = orig_modules
def setUp(self):
super(TestIosxrConfigModule, self).setUp()
self.patcher_get_config = patch(
'ansible_collections.misc.not_a_real_collection.plugins.modules.iosxr_config.get_config'
)
self.mock_get_config = self.patcher_get_config.start()
self.patcher_exec_command = patch(
'ansible_collections.misc.not_a_real_collection.plugins.modules.iosxr_config.load_config'
)
self.mock_exec_command = self.patcher_exec_command.start()
self.mock_get_connection = patch(
'ansible_collections.misc.not_a_real_collection.plugins.modules.iosxr_config.get_connection'
)
self.get_connection = self.mock_get_connection.start()
self.conn = self.get_connection()
self.conn.edit_config = MagicMock()
self.cliconf_obj = Cliconf(MagicMock())
self.running_config = load_fixture('iosxr_config_config.cfg')
