def setUp(self):
super(TestNxosVlansModule, self).setUp()
self.mock_FACT_LEGACY_SUBSETS = patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.network.nxos.facts.facts.FACT_LEGACY_SUBSETS'
)
self.FACT_LEGACY_SUBSETS = self.mock_FACT_LEGACY_SUBSETS.start()
self.mock_get_resource_connection_config = patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.network.common.cfg.base.get_resource_connection'
)
self.get_resource_connection_config = self.mock_get_resource_connection_config.start(
)
self.mock_get_resource_connection_facts = patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.network.common.facts.facts.get_resource_connection'
)
self.get_resource_connection_facts = self.mock_get_resource_connection_facts.start(
)
self.mock_edit_config = patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.network.nxos.config.vlans.vlans.Vlans.edit_config'
)
self.edit_config = self.mock_edit_config.start()
self.mock_get_device_data = patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.network.nxos.facts.vlans.vlans.VlansFacts.get_device_data'
)
self.get_device_data = self.mock_get_device_data.start()
def setUp(self):
super(TestIosxrFacts, self).setUp()
self.mock_run_commands = patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.network.iosxr.facts.legacy.base.run_commands'
)
self.run_commands = self.mock_run_commands.start()
self.mock_get_resource_connection = patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.network.common.facts.facts.get_resource_connection'
)
self.get_resource_connection = self.mock_get_resource_connection.start(
)
self.mock_get_capabilities = patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.network.iosxr.facts.legacy.base.get_capabilities'
)
self.get_capabilities = self.mock_get_capabilities.start()
self.get_capabilities.return_value = {
'device_info': {
'network_os': 'iosxr',
'network_os_hostname': 'iosxr01',
'network_os_image':
'bootflash:disk0/xrvr-os-mbi-6.1.3/mbixrvr-rp.vm',
'network_os_version': '6.1.3[Default]'
},
'network_api': 'cliconf'
}
def setUp(self):
super(TestIosFactsModule, self).setUp()
self.mock_run_commands = patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.network.ios.facts.legacy.base.run_commands'
)
self.run_commands = self.mock_run_commands.start()
self.mock_get_resource_connection = patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.network.common.facts.facts.get_resource_connection'
)
self.get_resource_connection = self.mock_get_resource_connection.start(
)
self.mock_get_capabilities = patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.network.ios.facts.legacy.base.get_capabilities'
)
self.get_capabilities = self.mock_get_capabilities.start()
self.get_capabilities.return_value = {
'device_info': {
'network_os': 'ios',
'network_os_hostname': 'an-ios-01',
'network_os_image': 'flash0:/vios-adventerprisek9-m',
'network_os_model': 'WS-C3750-24TS',
'network_os_version': '15.6(3)M2'
},
'network_api': 'cliconf'
}
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 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_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 setUp(self):
super(TestNxosVlanModule, self).setUp()
self.mock_run_commands = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules._nxos_vlan.run_commands'
)
self.run_commands = self.mock_run_commands.start()
self.mock_load_config = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules._nxos_vlan.load_config'
)
self.load_config = self.mock_load_config.start()
self.mock_get_config = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules._nxos_vlan.get_config'
)
self.get_config = self.mock_get_config.start()
self.mock_get_capabilities = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules._nxos_vlan.get_capabilities'
)
self.get_capabilities = self.mock_get_capabilities.start()
self.get_capabilities.return_value = {
'device_info': {
'network_os_platform': 'N9K-9000v'
},
'network_api': 'cliconf'
}
def test_clear_single_configuration(self):
self._set_args()
# No changes are required if the domains are empty
config = 'abc'
ldap = self._make_ldap_instance()
with mock.patch.object(ldap, 'get_configuration', return_value=config):
with mock.patch(self.REQ_FUNC, return_value=(204, None)) as req:
msg, result = ldap.clear_single_configuration()
self.assertTrue(result)
# Valid check_mode makes no changes
req.reset_mock()
ldap.check_mode = True
msg, result = ldap.clear_single_configuration()
self.assertTrue(result)
self.assertFalse(req.called)
# When domains exist, we need to clear
ldap = self._make_ldap_instance()
with mock.patch.object(ldap, 'get_configuration', return_value=None):
with mock.patch(self.REQ_FUNC, return_value=(204, None)) as req:
msg, result = ldap.clear_single_configuration()
self.assertFalse(result)
self.assertFalse(req.called)
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 test_get_configuration_pass(self):
"""Validate get configuration does not throw exception when normal request is returned."""
initial = {
"max_records": 1000,
"log_level": "writeOnly",
"full_policy": "overWrite",
"threshold": 90
}
expected = {
"auditLogMaxRecords": 1000,
"auditLogLevel": "writeOnly",
"auditLogFullPolicy": "overWrite",
"auditLogWarningThresholdPct": 90
}
self._set_args(**initial)
with mock.patch(self.REQ_FUNC,
return_value=(200, {
"runningAsProxy": True
})):
audit_log = AuditLog()
with mock.patch(self.REQ_FUNC, return_value=(200, expected)):
body = audit_log.get_configuration()
self.assertTrue(body == expected)
def setUp(self):
super(TestNxosInterfaceModule, self).setUp()
self.mock_run_commands = patch('ansible_collections.notstdlib.moveitallout.plugins.modules._nxos_interface.run_commands')
self.run_commands = self.mock_run_commands.start()
self.mock_load_config = patch('ansible_collections.notstdlib.moveitallout.plugins.modules._nxos_interface.load_config')
self.load_config = self.mock_load_config.start()
def test_instance_to_be_created_with_root_pass(default_args, mock_linode,
capfd, access_token):
default_args.update({
'type': 'foo',
'region': 'bar',
'image': 'baz',
'root_pass': '******',
})
set_module_args(default_args)
target = 'linode_api4.linode_client.LinodeGroup.instances'
with mock.patch(target, return_value=[]):
with pytest.raises(SystemExit) as sys_exit_exc:
target = 'linode_api4.linode_client.LinodeGroup.instance_create'
with mock.patch(target, return_value=mock_linode):
linode_v4.main()
assert sys_exit_exc.value.code == 0
out, err = capfd.readouterr()
results = json.loads(out)
assert results['changed'] is True
assert (results['instance']['label'] == mock_linode._raw_json['label'])
assert 'root_pass' not in results['instance']
def setUp(self):
"""Setup."""
super(TestCreateJavaKeystore, self).setUp()
orig_exists = os.path.exists
self.spec = ArgumentSpec()
self.mock_create_file = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.java_keystore.create_file',
side_effect=lambda path, content: path)
self.mock_run_commands = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.java_keystore.run_commands'
)
self.mock_os_path_exists = patch(
'os.path.exists',
side_effect=lambda path: True
if path == '/path/to/keystore.jks' else orig_exists(path))
self.mock_selinux_context = patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.basic.AnsibleModule.selinux_context',
side_effect=lambda path:
['unconfined_u', 'object_r', 'user_home_t', 's0'])
self.mock_is_special_selinux_path = patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.basic.AnsibleModule.is_special_selinux_path',
side_effect=lambda path: (False, None))
self.run_commands = self.mock_run_commands.start()
self.create_file = self.mock_create_file.start()
self.selinux_context = self.mock_selinux_context.start()
self.is_special_selinux_path = self.mock_is_special_selinux_path.start(
)
self.os_path_exists = self.mock_os_path_exists.start()
def test_module_utils_basic_ansible_module_find_mount_point(self):
from ansible_collections.notstdlib.moveitallout.plugins.module_utils import basic
basic._ANSIBLE_ARGS = None
am = basic.AnsibleModule(
argument_spec=dict(),
)
def _mock_ismount(path):
if path == b'/':
return True
return False
with patch('os.path.ismount', side_effect=_mock_ismount):
self.assertEqual(am.find_mount_point('/root/fs/../mounted/path/to/whatever'), '/')
def _mock_ismount(path):
if path == b'/subdir/mount':
return True
if path == b'/':
return True
return False
with patch('os.path.ismount', side_effect=_mock_ismount):
self.assertEqual(am.find_mount_point('/subdir/mount/path/to/whatever'), '/subdir/mount')
def test_update_configuration_delete_skip_fail(self):
"""Verify 422 and no force results in AnsibleJsonFail exception."""
body = {
"auditLogMaxRecords": 1000,
"auditLogLevel": "writeOnly",
"auditLogFullPolicy": "overWrite",
"auditLogWarningThresholdPct": 90
}
initial = {
"max_records": 2000,
"log_level": "writeOnly",
"full_policy": "overWrite",
"threshold": 90,
"force": False
}
self._set_args(**initial)
with mock.patch(self.REQ_FUNC,
return_value=(200, {
"runningAsProxy": True
})):
audit_log = AuditLog()
with self.assertRaisesRegexp(
AnsibleFailJson, r"Failed to update audit-log configuration!"):
with mock.patch(self.REQ_FUNC,
side_effect=[(200, body),
Exception(422,
{"errorMessage": "error"}),
(200, None), (200, None)]):
audit_log.update_configuration()
def test_update_configuration_delete_pass(self):
"""Verify 422 and force successfully returns True."""
body = {
"auditLogMaxRecords": 1000,
"auditLogLevel": "writeOnly",
"auditLogFullPolicy": "overWrite",
"auditLogWarningThresholdPct": 90
}
initial = {
"max_records": 2000,
"log_level": "writeOnly",
"full_policy": "overWrite",
"threshold": 90,
"force": True
}
self._set_args(**initial)
with mock.patch(self.REQ_FUNC,
return_value=(200, {
"runningAsProxy": True
})):
audit_log = AuditLog()
with mock.patch(self.REQ_FUNC,
side_effect=[(200, body),
(422, {
u"invalidFieldsIfKnown": None,
u"errorMessage":
u"Configuration change...",
u"localizedMessage":
u"Configuration change...",
u"retcode":
u"auditLogImmediateFullCondition",
u"codeType": u"devicemgrerror"
}), (200, None), (200, None)]):
self.assertTrue(audit_log.update_configuration())
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 setUp(self):
super(TestExosConfigModule, self).setUp()
self.mock_get_config = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.exos_config.get_config'
)
self.get_config = self.mock_get_config.start()
self.mock_load_config = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.exos_config.load_config'
)
self.load_config = self.mock_load_config.start()
self.mock_run_commands = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.exos_config.run_commands'
)
self.run_commands = self.mock_run_commands.start()
self.mock_get_startup_config = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.exos_config.get_startup_config'
)
self.get_startup_config = self.mock_get_startup_config.start()
self.cliconf_obj = Cliconf(MagicMock())
self.mock_get_diff = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.exos_config.get_diff'
)
self.get_diff = self.mock_get_diff.start()
self.running_config = load_fixture('exos_config_config.cfg')
def setUp(self):
super(TestIosBannerModule, self).setUp()
self.mock_get_config = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.ios_banner.get_config')
self.get_config = self.mock_get_config.start()
self.mock_load_config = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.ios_banner.load_config')
self.load_config = self.mock_load_config.start()
def setUp(self):
super(TestEosBannerModule, self).setUp()
self.mock_run_commands = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.eos_banner.run_commands')
self.run_commands = self.mock_run_commands.start()
self.mock_load_config = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.eos_banner.load_config')
self.load_config = self.mock_load_config.start()
def setUp(self):
super(TestNxosVxlanVtepVniModule, self).setUp()
self.mock_load_config = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.nxos_vxlan_vtep_vni.load_config')
self.load_config = self.mock_load_config.start()
self.mock_get_config = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.nxos_vxlan_vtep_vni.get_config')
self.get_config = self.mock_get_config.start()
def setUp(self):
super(TestCnosLoggingModule, self).setUp()
self.mock_get_config = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.cnos_logging.get_config')
self.get_config = self.mock_get_config.start()
self.mock_load_config = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.cnos_logging.load_config')
self.load_config = self.mock_load_config.start()
def setUp(self):
super(TestNxosPimModule, self).setUp()
self.mock_get_config = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.nxos_pim.get_config')
self.get_config = self.mock_get_config.start()
self.mock_load_config = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.nxos_pim.load_config')
self.load_config = self.mock_load_config.start()
def test_not_linux(self):
# if neither match, the fallback should be the top-level class
with patch('platform.system', return_value="Foo"):
with patch(
'ansible_collections.notstdlib.moveitallout.plugins.module_utils.common.sys_info.get_distribution',
return_value=None):
assert isinstance(load_platform_subclass(self.LinuxTest),
self.LinuxTest)
def setUp(self):
super(TestICXSCPModule, self).setUp()
self.mock_exec_scp = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.icx_copy.exec_scp')
self.mock_run_commands = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.icx_copy.run_commands')
self.exec_command = self.mock_exec_scp.start()
self.run_commands = self.mock_run_commands.start()
self.mock_exec_command = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.icx_copy.exec_command')
self.exec_commands = self.mock_exec_command.start()
def setUp(self):
super(TestCloudEngineLacpModule, self).setUp()
self.mock_get_config = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.ce_is_is_instance.get_nc_config')
self.get_nc_config = self.mock_get_config.start()
self.mock_set_config = patch('ansible_collections.notstdlib.moveitallout.plugins.modules.ce_is_is_instance.set_nc_config')
self.set_nc_config = self.mock_set_config.start()
self.set_nc_config.return_value = None
def setUp(self):
self.patcher_get_config = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.cnos_config.get_config'
)
self.mock_get_config = self.patcher_get_config.start()
self.patcher_exec_command = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.cnos_config.load_config'
)
self.mock_exec_command = self.patcher_exec_command.start()
def setUp(self):
self.mock_run_nvos_commands = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.pn_admin_syslog.run_cli'
)
self.run_nvos_commands = self.mock_run_nvos_commands.start()
self.mock_run_check_cli = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.pn_admin_syslog.check_cli'
)
self.run_check_cli = self.mock_run_check_cli.start()
def setUp(self):
self.mock_run_nvos_commands = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.pn_ipv6security_raguard_port.run_cli'
)
self.run_nvos_commands = self.mock_run_nvos_commands.start()
self.mock_run_check_cli = patch(
'ansible_collections.notstdlib.moveitallout.plugins.modules.pn_ipv6security_raguard_port.check_cli'
)
self.run_check_cli = self.mock_run_check_cli.start()
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()
