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_no_change_to_module_when_all_identical(self):
self.set_module_state('present')
from ansible_collections.community.general.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.community.general.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_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 setUp(self, mock_socket):
# TODO: this python version validation won't be needed as long as the _time_ns call is mocked.
if sys.version_info < OPENTELEMETRY_MINIMUM_PYTHON_VERSION:
self.skipTest(
"Python %s+ is needed for OpenTelemetry" %
",".join(map(str, OPENTELEMETRY_MINIMUM_PYTHON_VERSION)))
mock_socket.gethostname.return_value = 'my-host'
mock_socket.gethostbyname.return_value = '1.2.3.4'
self.opentelemetry = OpenTelemetrySource(display=None)
self.task_fields = {'args': {}}
self.mock_host = Mock('MockHost')
self.mock_host.name = 'myhost'
self.mock_host._uuid = 'myhost_uuid'
self.mock_task = Task()
self.mock_task.action = 'myaction'
self.mock_task.no_log = False
self.mock_task._role = 'myrole'
self.mock_task._uuid = 'myuuid'
self.mock_task.args = {}
self.mock_task.get_name = MagicMock(return_value='mytask')
self.mock_task.get_path = MagicMock(return_value='/mypath')
self.my_task = TaskData('myuuid', 'mytask', '/mypath', 'myplay',
'myaction', '')
self.my_task_result = TaskResult(host=self.mock_host,
task=self.mock_task,
return_data={},
task_fields=self.task_fields)
def test_get_kubernetes_options_when_not_ok(self):
module = MagicMock()
k = DOKubernetes(module)
k.rest = MagicMock()
k.rest.get = MagicMock()
k.rest.get.return_value.json = {"foo": "bar"}
k.rest.get.return_value.status_code = 400
self.assertIsNone(k.get_kubernetes_options())
def test_get_all_clusters_when_not_ok(self):
module = MagicMock()
k = DOKubernetesInfo(module)
k.rest = MagicMock()
k.rest.get = MagicMock()
k.rest.get.return_value.status_code = 400
k.rest.get.return_value.json = {"foo": "bar"}
self.assertIsNone(k.get_all_clusters())
def test_get_by_id_when_ok(self):
module = MagicMock()
k = DOKubernetesInfo(module)
k.rest = MagicMock()
k.rest.get = MagicMock()
k.rest.get.return_value.status_code = 200
k.rest.get.return_value.json = {"foo": "bar"}
self.assertEqual(k.get_by_id(), {"foo": "bar"})
def test_get_when_not_found(self):
module = MagicMock()
module.fail_json = MagicMock()
k = DOKubernetesInfo(module)
k.get_kubernetes = MagicMock()
k.get_kubernetes.return_value = None
k.get()
module.fail_json.assert_called()
def test_get_kubernetes_kubeconfig_when_not_ok(self):
module = MagicMock()
k = DOKubernetesInfo(module)
k.rest = MagicMock()
k.rest.get = MagicMock()
k.rest.get.return_value.status_code = 400
k.rest.get.return_value.body = "kubeconfig"
self.assertNotEqual(k.get_kubernetes_kubeconfig(), "kubeconfig")
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 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_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_get_by_name_found(self):
module = MagicMock()
k = DOKubernetes(module)
k.get_all_clusters = MagicMock()
k.get_all_clusters.return_value = {
"kubernetes_clusters": [{
"name": "foo"
}]
}
self.assertEqual(k.get_by_name("foo"), {"name": "foo"})
def test_get_by_name_not_found(self):
module = MagicMock()
k = DOKubernetesInfo(module)
k.get_all_clusters = MagicMock()
k.get_all_clusters.return_value = {
"kubernetes_clusters": [{
"name": "foo"
}]
}
self.assertIsNone(k.get_by_name("foo2"))
def setUp(self):
super(TestNiosARecordModule, self).setUp()
self.module = MagicMock(name='ansible_collections.community.general.plugins.modules.net_tools.nios.nios_a_record.WapiModule')
self.module.check_mode = False
self.module.params = {'provider': None}
self.mock_wapi = patch('ansible_collections.community.general.plugins.modules.net_tools.nios.nios_a_record.WapiModule')
self.exec_command = self.mock_wapi.start()
self.mock_wapi_run = patch('ansible_collections.community.general.plugins.modules.net_tools.nios.nios_a_record.WapiModule.run')
self.mock_wapi_run.start()
self.load_config = self.mock_wapi_run.start()
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.community.general.plugins.module_utils.net_tools.nios.api.get_connector'
)
self.mock_connector.start()
def test_delete_not_ok(self):
module = MagicMock()
module.exit_json = MagicMock()
k = DOKubernetes(module)
k.get_kubernetes = MagicMock()
k.get_kubernetes.return_value = None
k.delete()
k.module.exit_json.assert_called()
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 test_voss_config_lines_w_parents(self):
lines = ['no shutdown']
parents = ['interface GigabitEthernet 1/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))
commands = ['interface GigabitEthernet 1/1', 'no shutdown']
self.execute_module(changed=True, commands=commands)
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'])
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_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 super_switcher(scope="function", autouse=True):
# Mocking the inbuilt super as it is used in ApiSession initialization
original_super = __builtin__.super
__builtin__.super = MagicMock()
yield
# Revert the super to default state
__builtin__.super = original_super
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)
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)
