def setUp(self):
super(TestEosConfigModule, self).setUp()
self.mock_get_config = patch(
'ansible_collections.misc.not_a_real_collection.plugins.modules.eos_config.get_config'
)
self.get_config = self.mock_get_config.start()
self.mock_get_connection = patch(
'ansible_collections.misc.not_a_real_collection.plugins.modules.eos_config.get_connection'
)
self.get_connection = self.mock_get_connection.start()
self.mock_load_config = patch(
'ansible_collections.misc.not_a_real_collection.plugins.modules.eos_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.eos_config.run_commands'
)
self.run_commands = self.mock_run_commands.start()
self.mock_supports_sessions = patch(
'ansible_collections.misc.not_a_real_collection.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 test_no_change_to_module_when_all_identical(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=[True, True])
service_identical_mock = Mock(side_effect=[True, True])
monitor_bindings_identical_mock = Mock(side_effect=[True, True])
with patch.multiple(
'ansible_collections.misc.not_a_real_collection.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 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 setUpClass(cls):
class MockException(Exception):
pass
cls.MockException = MockException
m = MagicMock()
cls.cs_vserver_mock = MagicMock()
cls.cs_vserver_mock.__class__ = MagicMock(add=Mock())
nssrc_modules_mock = {
'nssrc.com.citrix.netscaler.nitro.resource.config.cs':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.cs.csvserver':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.cs.csvserver.csvserver':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.cs.csvserver_cspolicy_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.cs.csvserver_cspolicy_binding.csvserver_cspolicy_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.cs.csvserver_lbvserver_binding':
m,
'nssrc.com.citrix.netscaler.nitro.resource.config.cs.csvserver_lbvserver_binding.csvserver_lbvserver_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_update_service_when_monitor_bindings_differ(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=[True, True])
service_identical_mock = Mock(side_effect=[True, True])
monitor_bindings_identical_mock = Mock(side_effect=[False, True])
all_identical_mock = Mock(side_effect=[False])
sync_monitor_bindings_mock = Mock()
with patch.multiple(
'ansible_collections.misc.not_a_real_collection.plugins.modules.netscaler_service',
ConfigProxy=m,
service_exists=service_exists_mock,
service_identical=service_identical_mock,
monitor_bindings_identical=monitor_bindings_identical_mock,
all_identical=all_identical_mock,
sync_monitor_bindings=sync_monitor_bindings_mock,
do_state_change=Mock(return_value=Mock(errorcode=0)),
):
self.module = netscaler_service
result = self.exited()
# poor man's assert_called_once since python3.5 does not implement that mock method
self.assertEqual(len(sync_monitor_bindings_mock.mock_calls),
1,
msg='sync monitor bindings not called once')
self.assertTrue(result['changed'], msg='Change not recorded')
def test_run_with_simple_auth_and_search_base(monkeypatch, laps_password):
def get_laps_password(conn, cn, search_base):
return "CN=%s,%s" % (cn, search_base)
mock_ldap = MagicMock()
monkeypatch.setattr("ldap.initialize", mock_ldap)
mock_get_laps_password = MagicMock(side_effect=get_laps_password)
monkeypatch.setattr(laps_password, "get_laps_password", mock_get_laps_password)
actual = lookup_loader.get('laps_password').run(["host1", "host2"], domain="dc01", auth="simple", username="******",
password="******", allow_plaintext=True,
search_base="OU=Workstations,DC=domain,DC=com")
assert actual == ["CN=host1,OU=Workstations,DC=domain,DC=com", "CN=host2,OU=Workstations,DC=domain,DC=com"]
# Verify the call count to get_laps_password
assert mock_get_laps_password.call_count == 2
# Verify the initialize() method call
assert mock_ldap.call_count == 1
assert mock_ldap.call_args[0] == ("ldap://dc01:389",)
assert mock_ldap.call_args[1] == {"bytes_mode": False}
# Verify the number of calls made to the mocked LDAP object
assert mock_ldap.mock_calls[1][0] == "().set_option"
assert mock_ldap.mock_calls[1][1] == (FakeLdap.OPT_PROTOCOL_VERSION, 3)
assert mock_ldap.mock_calls[2][0] == "().set_option"
assert mock_ldap.mock_calls[2][1] == (FakeLdap.OPT_REFERRALS, 0)
assert mock_ldap.mock_calls[3][0] == '().bind_s'
assert mock_ldap.mock_calls[3][1] == (u"user", u"pass")
assert mock_ldap.mock_calls[4][0] == "().unbind_s"
assert mock_ldap.mock_calls[4][1] == ()
def test_servicegroup_monitor_bindings_sanity(self):
self.set_module_state('present')
from ansible_collections.misc.not_a_real_collection.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.misc.not_a_real_collection.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):
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_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 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.misc.not_a_real_collection.plugins.module_utils.net_tools.nios.api.get_connector')
self.mock_connector.start()
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_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 test_voss_config_ipv6(self):
lines = ['ip address 1 1.1.1.1/255.255.255.255',
'ipv6 interface address 2011:0:0:0:0:0:0:1/128']
parents = ['interface loopback 1']
set_module_args(dict(lines=lines, parents=parents))
module = MagicMock()
module.params = {'lines': lines, 'parents': parents, 'src': None}
candidate_config = voss_config.get_candidate_config(module)
self.conn.get_diff = MagicMock(return_value=self.cliconf_obj.get_diff(candidate_config, self.running_config))
self.execute_module(changed=False)
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_voss_config_match_exact(self):
lines = ['name "ServerA"', 'vlacp enable', 'no shutdown']
parents = ['interface GigabitEthernet 1/1']
set_module_args(dict(lines=lines, parents=parents, match='exact'))
module = MagicMock()
module.params = {'lines': lines, 'parents': parents, 'src': None}
candidate_config = voss_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_exec_with_become_no_plugin_set_use_task(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, True)
assert set_become_mock.call_count == 1
assert set_become_mock.mock_calls[0][1][0] is None
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_voss_config_replace_block(self):
lines = ['name "ServerB"', 'test string']
parents = ['interface GigabitEthernet 1/2']
set_module_args(dict(lines=lines, replace='block', parents=parents))
module = MagicMock()
module.params = {'lines': lines, 'parents': parents, 'src': None}
candidate_config = voss_config.get_candidate_config(module)
self.conn.get_diff = MagicMock(return_value=self.cliconf_obj.get_diff(candidate_config, self.running_config, diff_replace='block', path=parents))
commands = parents + lines
self.execute_module(changed=True, commands=commands)
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_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)
class ConnectionMock(object):
ismock = True
_play_context = None
# transport = 'ssh'
transport = None
_new_stdin = StdinMock()
get_option = MagicMock(return_value='root')
# my shell
_shell = MagicMock()
_shell.mkdtemp.return_value = 'mkdir command'
_shell.join_path.side_effect = os.path.join
_shell.get_option = MagicMock(return_value=['root', 'toor'])
def test_certificate_validate_with_custom_cacert(monkeypatch):
mock_ldap_option = MagicMock()
monkeypatch.setattr(FakeLdap, "set_option", mock_ldap_option)
mock_ldap = MagicMock()
monkeypatch.setattr("ldap.initialize", mock_ldap)
monkeypatch.setattr(os.path, 'exists', lambda x: True)
lookup_loader.get('laps_password').run([], domain="dc01", scheme="ldaps", cacert_file="cacert.pem")
assert mock_ldap_option.mock_calls[0][1] == (FakeLdap.OPT_X_TLS_REQUIRE_CERT, FakeLdap.OPT_X_TLS_DEMAND)
assert mock_ldap_option.mock_calls[1][1] == (FakeLdap.OPT_X_TLS_CACERTFILE, u"cacert.pem")
assert mock_ldap.mock_calls[3][0] == "().sasl_gssapi_bind_s"
assert mock_ldap.mock_calls[3][1] == ()
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_exec_with_become(self, test_win_updates):
test_become = os.urandom(8)
set_become_mock = MagicMock()
test_win_updates._connection.become = test_become
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)
# Asserts we don't override the become plugin.
assert set_become_mock.call_count == 1
assert set_become_mock.mock_calls[0][1][0] == test_become
def test_kinit_error_subprocess(self, monkeypatch):
expected_err = "kinit: krb5_parse_name: " \
"Configuration file does not specify default realm"
def mock_communicate(input=None, timeout=None):
return b"", to_bytes(expected_err)
mock_popen = MagicMock()
mock_popen.return_value.communicate = mock_communicate
mock_popen.return_value.returncode = 1
monkeypatch.setattr("subprocess.Popen", mock_popen)
winrm.HAS_PEXPECT = False
pc = PlayContext()
new_stdin = StringIO()
conn = connection_loader.get('winrm', pc, new_stdin)
conn.set_options(var_options={"_extras": {}})
conn._build_winrm_kwargs()
with pytest.raises(AnsibleConnectionFailure) as err:
conn._kerb_auth("invaliduser", "pass")
assert str(err.value) == \
"Kerberos auth failure for principal invaliduser with " \
"subprocess: %s" % (expected_err)
def test_kinit_success_pexpect(self, monkeypatch, options, expected):
pytest.importorskip("pexpect")
mock_pexpect = MagicMock()
mock_pexpect.return_value.exitstatus = 0
monkeypatch.setattr("pexpect.spawn", mock_pexpect)
winrm.HAS_PEXPECT = True
pc = PlayContext()
new_stdin = StringIO()
conn = connection_loader.get('winrm', pc, new_stdin)
conn.set_options(var_options=options)
conn._build_winrm_kwargs()
conn._kerb_auth("user@domain", "pass")
mock_calls = mock_pexpect.mock_calls
assert mock_calls[0][1] == expected
actual_env = mock_calls[0][2]['env']
assert list(actual_env.keys()) == ['KRB5CCNAME']
assert actual_env['KRB5CCNAME'].startswith("FILE:/")
assert mock_calls[0][2]['echo'] is False
assert mock_calls[1][0] == "().expect"
assert mock_calls[1][1] == (".*:", )
assert mock_calls[2][0] == "().sendline"
assert mock_calls[2][1] == ("pass", )
assert mock_calls[3][0] == "().read"
assert mock_calls[4][0] == "().wait"
def test_voss_config_src(self):
src = load_fixture('voss_config_src.cfg')
set_module_args(dict(src=src))
self.conn.get_diff = MagicMock(return_value=self.cliconf_obj.get_diff(src, self.running_config))
commands = ['prompt "VSP8K"', 'interface GigabitEthernet 1/1',
'name "UNUSED"', 'exit']
self.execute_module(changed=True, commands=commands)
def test_voss_config_src_ipv6(self):
src = load_fixture('voss_config_ipv6.cfg')
set_module_args(dict(src=src))
self.conn.get_diff = MagicMock(return_value=self.cliconf_obj.get_diff(src, self.running_config))
commands = ['interface loopback 1', 'ip address 1 2.2.2.2/255.255.255.255',
'ipv6 interface address 2011:0:0:0:0:0:0:2/128', 'exit']
self.execute_module(changed=True, commands=commands)
def test_voss_config_config(self):
config = 'prompt "VSP300"'
lines = ['prompt router']
set_module_args(dict(lines=lines, config=config))
self.conn.get_diff = MagicMock(return_value=self.cliconf_obj.get_diff('\n'.join(lines), config))
commands = ['prompt router']
self.execute_module(changed=True, commands=commands)
