def test_is_valid_shell_none(self):
"""
Tests return of when os.path.exists(/etc/shells) isn't available
"""
with patch("os.path.exists", MagicMock(return_value=False)):
self.assertIsNone(cmdmod._is_valid_shell("foo"))
def test_pbm_si(self):
mock_get_pbm_si = MagicMock()
with patch('salt.utils.pbm.pbm.ServiceInstance', mock_get_pbm_si):
salt.utils.pbm.get_placement_solver(self.mock_si)
mock_get_pbm_si.assert_called_once_with('ServiceInstance',
self.mock_stub)
def test_retrieve_policy_ids(self):
mock_retrieve_policy_ids = MagicMock(return_value=self.mock_policy_ids)
self.mock_prof_mgr.QueryProfile = mock_retrieve_policy_ids
salt.utils.pbm.get_storage_policies(self.mock_prof_mgr)
mock_retrieve_policy_ids.assert_called_once_with(self.mock_res_type)
def test_dead(self):
'''
Test to ensure that the named service is dead
'''
ret = [{'changes': {}, 'comment': '', 'name': 'salt', 'result': True},
{'changes': 'saltstack',
'comment': 'The service salt is already dead', 'name': 'salt',
'result': True},
{'changes': {},
'comment': 'Service salt is set to be killed', 'name': 'salt',
'result': None},
{'changes': 'saltstack',
'comment': 'Service salt was killed', 'name': 'salt',
'result': True},
{'changes': {},
'comment': 'Service salt failed to die', 'name': 'salt',
'result': False},
{'changes': 'saltstack',
'comment': 'The service salt is already dead', 'name': 'salt',
'result': True}]
info_mock = MagicMock(return_value={'StartType': ''})
mock = MagicMock(return_value="salt")
with patch.object(service, '_enabled_used_error', mock):
self.assertEqual(service.dead("salt", enabled=1), 'salt')
tmock = MagicMock(return_value=True)
fmock = MagicMock(return_value=False)
with patch.object(service, '_available', fmock):
self.assertDictEqual(service.dead("salt"), ret[0])
with patch.object(service, '_available', tmock):
mock = MagicMock(return_value={'changes': 'saltstack'})
with patch.dict(service.__opts__, {'test': True}):
with patch.dict(service.__salt__, {'service.enabled': fmock,
'service.stop': tmock,
'service.status': fmock,
'service.info': info_mock}):
with patch.object(service, '_enable', mock):
self.assertDictEqual(service.dead("salt", True), ret[5])
with patch.dict(service.__salt__, {'service.enabled': tmock,
'service.status': tmock,
'service.info': info_mock}):
self.assertDictEqual(service.dead("salt"), ret[2])
with patch.dict(service.__opts__, {'test': False}):
with patch.dict(service.__salt__, {'service.enabled': fmock,
'service.stop': tmock,
'service.status': fmock,
'service.info': info_mock}):
with patch.object(service, '_enable', mock):
self.assertDictEqual(service.dead("salt", True), ret[1])
with patch.dict(service.__salt__, {'service.enabled': MagicMock(side_effect=[True, True, False]),
'service.status': MagicMock(side_effect=[True, False, False]),
'service.stop': MagicMock(return_value="stack"),
'service.info': info_mock}):
with patch.object(service, '_enable', MagicMock(return_value={'changes': 'saltstack'})):
self.assertDictEqual(service.dead("salt", True), ret[3])
# test an initd which a wrong status (True even if dead)
with patch.dict(service.__salt__, {'service.enabled': MagicMock(side_effect=[False, False, False]),
'service.status': MagicMock(side_effect=[True, True, True]),
'service.stop': MagicMock(return_value="stack"),
'service.info': info_mock}):
with patch.object(service, '_disable', MagicMock(return_value={})):
self.assertDictEqual(service.dead("salt", False), ret[4])
class JBoss7TestCase(TestCase, LoaderModuleMockMixin):
jboss_config = {}
org_run_operation = None
def setup_loader_modules(self):
self.org_run_operation = MagicMock()
self.addCleanup(delattr, self, "org_run_operation")
return {
jboss7: {"__salt__": {"jboss7_cli.run_operation": self.org_run_operation}}
}
def test_create_simple_binding(self):
jboss7.create_simple_binding(self.jboss_config, "java:global/env", "DEV")
self.org_run_operation.assert_called_with(
self.jboss_config,
'/subsystem=naming/binding="java:global/env":add(binding-type=simple, value="DEV")',
)
def test_create_simple_binding_with_backslash(self):
jboss7.create_simple_binding(self.jboss_config, "java:global/env", r"DEV\2")
self.org_run_operation.assert_called_with(
self.jboss_config,
r'/subsystem=naming/binding="java:global/env":add(binding-type=simple, value="DEV\\\\2")',
)
def test_update_binding(self):
jboss7.update_simple_binding(self.jboss_config, "java:global/env", "INT")
self.org_run_operation.assert_called_with(
self.jboss_config,
'/subsystem=naming/binding="java:global/env":write-attribute(name=value, value="INT")',
)
def test_update_binding_with_backslash(self):
jboss7.update_simple_binding(self.jboss_config, "java:global/env", r"INT\2")
self.org_run_operation.assert_called_with(
self.jboss_config,
r'/subsystem=naming/binding="java:global/env":write-attribute(name=value, value="INT\\\\2")',
)
def test_read_binding(self):
def cli_command_response(jboss_config, cli_command):
if (
cli_command
== '/subsystem=naming/binding="java:global/env":read-resource'
):
return {
"outcome": "success",
"result": {"binding-type": "simple", "value": "DEV"},
}
self.org_run_operation.side_effect = cli_command_response
result = jboss7.read_simple_binding(self.jboss_config, "java:global/env")
self.assertEqual(result["outcome"], "success")
self.assertEqual(result["result"]["value"], "DEV")
def test_create_datasource_all_properties_included(self):
def cli_command_response(jboss_config, cli_command, fail_on_error=False):
if (
cli_command
== '/subsystem=datasources/data-source="appDS":read-resource-description'
):
return {
"outcome": "success",
"result": {
"attributes": {
"driver-name": {"type": "STRING"},
"connection-url": {"type": "STRING"},
"jndi-name": {"type": "STRING"},
"user-name": {"type": "STRING"},
"password": {"type": "STRING"},
}
},
}
self.org_run_operation.side_effect = cli_command_response
datasource_properties = OrderedDict()
datasource_properties["driver-name"] = "mysql"
datasource_properties["connection-url"] = "jdbc:mysql://localhost:3306/app"
datasource_properties["jndi-name"] = "java:jboss/datasources/appDS"
datasource_properties["user-name"] = "app"
datasource_properties["password"] = "******"
jboss7.create_datasource(self.jboss_config, "appDS", datasource_properties)
self.org_run_operation.assert_called_with(
self.jboss_config,
'/subsystem=datasources/data-source="appDS":add(driver-name="mysql",connection-url="jdbc:mysql://localhost:3306/app",jndi-name="java:jboss/datasources/appDS",user-name="app",password="******")',
fail_on_error=False,
)
def test_create_datasource_format_boolean_value_when_string(self):
def cli_command_response(jboss_config, cli_command, fail_on_error=False):
if (
cli_command
== '/subsystem=datasources/data-source="appDS":read-resource-description'
):
return {
"outcome": "success",
"result": {"attributes": {"use-ccm": {"type": "BOOLEAN"}}},
}
self.org_run_operation.side_effect = cli_command_response
datasource_properties = OrderedDict()
datasource_properties["use-ccm"] = "true"
jboss7.create_datasource(self.jboss_config, "appDS", datasource_properties)
self.org_run_operation.assert_called_with(
self.jboss_config,
'/subsystem=datasources/data-source="appDS":add(use-ccm=true)',
fail_on_error=False,
)
def test_create_datasource_format_boolean_value_when_boolean(self):
def cli_command_response(jboss_config, cli_command, fail_on_error=False):
if (
cli_command
== '/subsystem=datasources/data-source="appDS":read-resource-description'
):
return {
"outcome": "success",
"result": {"attributes": {"use-ccm": {"type": "BOOLEAN"}}},
}
self.org_run_operation.side_effect = cli_command_response
datasource_properties = OrderedDict()
datasource_properties["use-ccm"] = True
jboss7.create_datasource(self.jboss_config, "appDS", datasource_properties)
self.org_run_operation.assert_called_with(
self.jboss_config,
'/subsystem=datasources/data-source="appDS":add(use-ccm=true)',
fail_on_error=False,
)
def test_create_datasource_format_int_value_when_int(self):
def cli_command_response(jboss_config, cli_command, fail_on_error=False):
if (
cli_command
== '/subsystem=datasources/data-source="appDS":read-resource-description'
):
return {
"outcome": "success",
"result": {"attributes": {"min-pool-size": {"type": "INT"}}},
}
self.org_run_operation.side_effect = cli_command_response
datasource_properties = OrderedDict()
datasource_properties["min-pool-size"] = 15
jboss7.create_datasource(self.jboss_config, "appDS", datasource_properties)
self.org_run_operation.assert_called_with(
self.jboss_config,
'/subsystem=datasources/data-source="appDS":add(min-pool-size=15)',
fail_on_error=False,
)
def test_create_datasource_format_int_value_when_string(self):
def cli_command_response(jboss_config, cli_command, fail_on_error=False):
if (
cli_command
== '/subsystem=datasources/data-source="appDS":read-resource-description'
):
return {
"outcome": "success",
"result": {"attributes": {"min-pool-size": {"type": "INT"}}},
}
self.org_run_operation.side_effect = cli_command_response
datasource_properties = OrderedDict()
datasource_properties["min-pool-size"] = "15"
jboss7.create_datasource(self.jboss_config, "appDS", datasource_properties)
self.org_run_operation.assert_called_with(
self.jboss_config,
'/subsystem=datasources/data-source="appDS":add(min-pool-size=15)',
fail_on_error=False,
)
def test_read_datasource(self):
def cli_command_response(jboss_config, cli_command):
if (
cli_command
== '/subsystem=datasources/data-source="appDS":read-resource'
):
return {
"outcome": "success",
"result": {
"driver-name": "mysql",
"connection-url": "jdbc:mysql://localhost:3306/app",
"jndi-name": "java:jboss/datasources/appDS",
"user-name": "app",
"password": "******",
},
}
self.org_run_operation.side_effect = cli_command_response
ds_result = jboss7.read_datasource(self.jboss_config, "appDS")
ds_properties = ds_result["result"]
self.assertEqual(ds_properties["driver-name"], "mysql")
self.assertEqual(
ds_properties["connection-url"], "jdbc:mysql://localhost:3306/app"
)
self.assertEqual(ds_properties["jndi-name"], "java:jboss/datasources/appDS")
self.assertEqual(ds_properties["user-name"], "app")
self.assertEqual(ds_properties["password"], "app_password")
def test_update_datasource(self):
datasource_properties = {
"driver-name": "mysql",
"connection-url": "jdbc:mysql://localhost:3306/app",
"jndi-name": "java:jboss/datasources/appDS",
"user-name": "newuser",
"password": "******",
}
def cli_command_response(jboss_config, cli_command, fail_on_error=False):
if (
cli_command
== '/subsystem=datasources/data-source="appDS":read-resource-description'
):
return {
"outcome": "success",
"result": {
"attributes": {
"driver-name": {"type": "STRING"},
"connection-url": {"type": "STRING"},
"jndi-name": {"type": "STRING"},
"user-name": {"type": "STRING"},
"password": {"type": "STRING"},
}
},
}
elif (
cli_command
== '/subsystem=datasources/data-source="appDS":read-resource'
):
return {
"outcome": "success",
"result": {
"driver-name": "mysql",
"connection-url": "jdbc:mysql://localhost:3306/app",
"jndi-name": "java:jboss/datasources/appDS",
"user-name": "app",
"password": "******",
},
}
elif (
cli_command
== '/subsystem=datasources/data-source="appDS":write-attribute(name="user-name",value="newuser")'
):
return {"outcome": "success", "success": True}
self.org_run_operation.side_effect = cli_command_response
jboss7.update_datasource(self.jboss_config, "appDS", datasource_properties)
self.org_run_operation.assert_any_call(
self.jboss_config,
'/subsystem=datasources/data-source="appDS":write-attribute(name="user-name",value="newuser")',
fail_on_error=False,
)
def setUp(self):
# setup the service instance
self.si_mock = MagicMock()
# RootFolder
self.root_folder_mock = MagicMock()
self.get_root_folder_mock = \
MagicMock(return_value=self.root_folder_mock)
# CreateContainerView()
self.container_view_mock = MagicMock()
self.create_container_view_mock = \
MagicMock(return_value=self.container_view_mock)
self.si_mock.content.viewManager.CreateContainerView = \
self.create_container_view_mock
# RetrieveContents()
self.result_mock = MagicMock()
self.retrieve_contents_mock = MagicMock(return_value=self.result_mock)
self.si_mock.content.propertyCollector.RetrieveContents = \
self.retrieve_contents_mock
# Destroy()
self.destroy_mock = MagicMock()
self.container_view_mock.Destroy = self.destroy_mock
# override mocks
self.obj_type_mock = MagicMock()
self.traversal_spec_ret_mock = MagicMock()
self.traversal_spec_mock = \
MagicMock(return_value=self.traversal_spec_ret_mock)
self.property_spec_ret_mock = MagicMock()
self.property_spec_mock = \
MagicMock(return_value=self.property_spec_ret_mock)
self.obj_spec_ret_mock = MagicMock()
self.obj_spec_mock = \
MagicMock(return_value=self.obj_spec_ret_mock)
self.filter_spec_ret_mock = MagicMock()
self.filter_spec_mock = \
MagicMock(return_value=self.filter_spec_ret_mock)
def test_get_details(self):
mock_get_details = MagicMock()
with patch.dict(esxdatacenter.__proxy__,
{"esxdatacenter.get_details": mock_get_details}):
esxdatacenter.get_details()
mock_get_details.assert_called_once_with()
class AptUtilsTestCase(TestCase, LoaderModuleMockMixin):
"""
apt utils test case
"""
def setup_loader_modules(self):
return {aptpkg: {}}
def test_call_apt_default(self):
"""
Call default apt.
:return:
"""
with patch.dict(
aptpkg.__salt__,
{
"cmd.run_all": MagicMock(),
"config.get": MagicMock(return_value=False)
},
):
aptpkg._call_apt(["apt-get", "install", "emacs"]) # pylint: disable=W0106
aptpkg.__salt__["cmd.run_all"].assert_called_once_with(
["apt-get", "install", "emacs"],
env={},
output_loglevel="trace",
python_shell=False,
)
@patch("salt.utils.systemd.has_scope", MagicMock(return_value=True))
def test_call_apt_in_scope(self):
"""
Call apt within the scope.
:return:
"""
with patch.dict(
aptpkg.__salt__,
{
"cmd.run_all": MagicMock(),
"config.get": MagicMock(return_value=True)
},
):
aptpkg._call_apt(["apt-get", "purge", "vim"]) # pylint: disable=W0106
aptpkg.__salt__["cmd.run_all"].assert_called_once_with(
[
"systemd-run",
"--scope",
"--description",
'"salt.modules.aptpkg"',
"apt-get",
"purge",
"vim",
],
env={},
output_loglevel="trace",
python_shell=False,
)
def test_call_apt_with_kwargs(self):
"""
Call apt with the optinal keyword arguments.
:return:
"""
with patch.dict(
aptpkg.__salt__,
{
"cmd.run_all": MagicMock(),
"config.get": MagicMock(return_value=False)
},
):
aptpkg._call_apt(
["dpkg", "-l", "python"],
python_shell=True,
output_loglevel="quiet",
ignore_retcode=False,
username="******",
) # pylint: disable=W0106
aptpkg.__salt__["cmd.run_all"].assert_called_once_with(
["dpkg", "-l", "python"],
env={},
ignore_retcode=False,
output_loglevel="quiet",
python_shell=True,
username="******",
)
def test_call_apt_dpkg_lock(self):
"""
Call apt and ensure the dpkg locking is handled
:return:
"""
cmd_side_effect = [
{
"stderr": "Could not get lock"
},
{
"stderr": "Could not get lock"
},
{
"stderr": "Could not get lock"
},
{
"stderr": "Could not get lock"
},
{
"stderr": "",
"stdout": ""
},
]
cmd_mock = MagicMock(side_effect=cmd_side_effect)
cmd_call = (call(
["dpkg", "-l", "python"],
env={},
ignore_retcode=False,
output_loglevel="quiet",
python_shell=True,
username="******",
), )
expected_calls = [cmd_call * 5]
with patch.dict(
aptpkg.__salt__,
{
"cmd.run_all": cmd_mock,
"config.get": MagicMock(return_value=False)
},
):
with patch("time.sleep", MagicMock()) as sleep_mock:
aptpkg._call_apt(
["dpkg", "-l", "python"],
python_shell=True,
output_loglevel="quiet",
ignore_retcode=False,
username="******",
) # pylint: disable=W0106
# We should have sleept at least 4 times
assert sleep_mock.call_count >= 4
# We should attempt to call the cmd 5 times
self.assertEqual(cmd_mock.call_count, 5)
cmd_mock.has_calls(expected_calls)
def test_uptime_macos(self):
'''
Test modules.status.uptime function for macOS
'''
m = self._set_up_test_uptime()
kern_boottime = ('{{ sec = {0}, usec = {1:0<6} }} Mon Oct 03 03:09:18.23 2016'
''.format(*six.text_type(m.now - m.ut).split('.')))
with patch.multiple(salt.utils.platform,
is_linux=MagicMock(return_value=False),
is_sunos=MagicMock(return_value=False),
is_darwin=MagicMock(return_value=True),
is_freebsd=MagicMock(return_value=False),
is_openbsd=MagicMock(return_value=False),
is_netbsd=MagicMock(return_value=False)), \
patch('salt.utils.path.which', MagicMock(return_value=True)), \
patch.dict(status.__salt__, {'cmd.run': MagicMock(return_value=os.linesep.join(['1', '2', '3'])),
'sysctl.get': MagicMock(return_value=kern_boottime)}), \
patch('time.time', MagicMock(return_value=m.now)):
ret = status.uptime()
self.assertDictEqual(ret, m.ret)
with patch.dict(status.__salt__, {'sysctl.get': MagicMock(return_value='')}):
with self.assertRaises(CommandExecutionError):
status.uptime()
class AptPkgTestCase(TestCase, LoaderModuleMockMixin):
"""
Test cases for salt.modules.aptpkg
"""
def setup_loader_modules(self):
return {aptpkg: {"__grains__": {}}}
def test_version(self):
"""
Test - Returns a string representing the package version or an empty string if
not installed.
"""
version = LOWPKG_INFO["wget"]["version"]
mock = MagicMock(return_value=version)
with patch.dict(aptpkg.__salt__, {"pkg_resource.version": mock}):
self.assertEqual(aptpkg.version(*["wget"]), version)
def test_upgrade_available(self):
"""
Test - Check whether or not an upgrade is available for a given package.
"""
with patch("salt.modules.aptpkg.latest_version",
MagicMock(return_value="")):
self.assertFalse(aptpkg.upgrade_available("wget"))
def test_add_repo_key(self):
"""
Test - Add a repo key.
"""
with patch("salt.modules.aptpkg.get_repo_keys",
MagicMock(return_value=REPO_KEYS)):
mock = MagicMock(return_value={"retcode": 0, "stdout": "OK"})
with patch.dict(aptpkg.__salt__, {"cmd.run_all": mock}):
self.assertTrue(
aptpkg.add_repo_key(keyserver="keyserver.ubuntu.com",
keyid="FBB75451"))
def test_add_repo_key_failed(self):
"""
Test - Add a repo key using incomplete input data.
"""
with patch("salt.modules.aptpkg.get_repo_keys",
MagicMock(return_value=REPO_KEYS)):
kwargs = {"keyserver": "keyserver.ubuntu.com"}
mock = MagicMock(return_value={"retcode": 0, "stdout": "OK"})
with patch.dict(aptpkg.__salt__, {"cmd.run_all": mock}):
self.assertRaises(SaltInvocationError, aptpkg.add_repo_key,
**kwargs)
def test_get_repo_keys(self):
"""
Test - List known repo key details.
"""
mock = MagicMock(return_value={"retcode": 0, "stdout": APT_KEY_LIST})
with patch.dict(aptpkg.__salt__, {"cmd.run_all": mock}):
self.assertEqual(aptpkg.get_repo_keys(), REPO_KEYS)
def test_file_dict(self):
"""
Test - List the files that belong to a package, grouped by package.
"""
mock = MagicMock(return_value=LOWPKG_FILES)
with patch.dict(aptpkg.__salt__, {"lowpkg.file_dict": mock}):
self.assertEqual(aptpkg.file_dict("wget"), LOWPKG_FILES)
def test_file_list(self):
"""
Test - List the files that belong to a package.
"""
files = {
"errors": LOWPKG_FILES["errors"],
"files": LOWPKG_FILES["packages"]["wget"],
}
mock = MagicMock(return_value=files)
with patch.dict(aptpkg.__salt__, {"lowpkg.file_list": mock}):
self.assertEqual(aptpkg.file_list("wget"), files)
def test_get_selections(self):
"""
Test - View package state from the dpkg database.
"""
selections = {"install": ["wget"]}
mock = MagicMock(return_value="wget\t\t\t\t\t\tinstall")
with patch.dict(aptpkg.__salt__, {"cmd.run_stdout": mock}):
self.assertEqual(aptpkg.get_selections("wget"), selections)
def test_info_installed(self):
"""
Test - Return the information of the named package(s) installed on the system.
"""
names = {
"group": "section",
"packager": "maintainer",
"url": "homepage"
}
installed = copy.deepcopy({"wget": LOWPKG_INFO["wget"]})
for name in names:
if installed["wget"].get(names[name], False):
installed["wget"][name] = installed["wget"].pop(names[name])
mock = MagicMock(return_value=LOWPKG_INFO)
with patch.dict(aptpkg.__salt__, {"lowpkg.info": mock}):
del installed["wget"]["status"]
self.assertEqual(aptpkg.info_installed("wget"), installed)
self.assertEqual(len(aptpkg.info_installed()), 1)
def test_owner(self):
"""
Test - Return the name of the package that owns the file.
"""
paths = ["/usr/bin/wget"]
mock = MagicMock(return_value="wget: /usr/bin/wget")
with patch.dict(aptpkg.__salt__, {"cmd.run_stdout": mock}):
self.assertEqual(aptpkg.owner(*paths), "wget")
def test_refresh_db(self):
"""
Test - Updates the APT database to latest packages based upon repositories.
"""
refresh_db = {
"http://security.ubuntu.com trusty-security InRelease": True,
"http://security.ubuntu.com trusty-security/main Sources": True,
"http://security.ubuntu.com trusty-security/main Translation-en":
None,
"http://security.ubuntu.com trusty-security/main amd64 Packages":
True,
"http://security.ubuntu.com trusty-security/main i386 Packages":
True,
}
mock = MagicMock(return_value={"retcode": 0, "stdout": APT_Q_UPDATE})
with patch("salt.utils.pkg.clear_rtag", MagicMock()):
with patch.dict(
aptpkg.__salt__,
{
"cmd.run_all": mock,
"config.get": MagicMock(return_value=False)
},
):
self.assertEqual(aptpkg.refresh_db(), refresh_db)
def test_refresh_db_failed(self):
"""
Test - Update the APT database using unreachable repositories.
"""
kwargs = {"failhard": True}
mock = MagicMock(return_value={
"retcode": 0,
"stdout": APT_Q_UPDATE_ERROR
})
with patch("salt.utils.pkg.clear_rtag", MagicMock()):
with patch.dict(
aptpkg.__salt__,
{
"cmd.run_all": mock,
"config.get": MagicMock(return_value=False)
},
):
self.assertRaises(CommandExecutionError, aptpkg.refresh_db,
**kwargs)
def test_autoremove(self):
"""
Test - Remove packages not required by another package.
"""
with patch("salt.modules.aptpkg.list_pkgs",
MagicMock(return_value=PACKAGES)):
patch_kwargs = {
"__salt__": {
"config.get":
MagicMock(return_value=True),
"cmd.run_all":
MagicMock(return_value=MagicMock(return_value=AUTOREMOVE)),
}
}
with patch.multiple(aptpkg, **patch_kwargs):
assert aptpkg.autoremove() == {}
assert aptpkg.autoremove(purge=True) == {}
assert aptpkg.autoremove(list_only=True) == []
assert aptpkg.autoremove(list_only=True, purge=True) == []
def test_install(self):
"""
Test - Install packages.
"""
with patch("salt.modules.aptpkg.install",
MagicMock(return_value=INSTALL)):
self.assertEqual(aptpkg.install(name="tmux"), INSTALL)
kwargs = {"force_conf_new": True}
self.assertEqual(aptpkg.install(name="tmux", **kwargs), INSTALL)
def test_remove(self):
"""
Test - Remove packages.
"""
with patch("salt.modules.aptpkg._uninstall",
MagicMock(return_value=UNINSTALL)):
self.assertEqual(aptpkg.remove(name="tmux"), UNINSTALL)
def test_purge(self):
"""
Test - Remove packages along with all configuration files.
"""
with patch("salt.modules.aptpkg._uninstall",
MagicMock(return_value=UNINSTALL)):
self.assertEqual(aptpkg.purge(name="tmux"), UNINSTALL)
def test_upgrade(self):
"""
Test - Upgrades all packages.
"""
with patch("salt.utils.pkg.clear_rtag", MagicMock()):
with patch("salt.modules.aptpkg.list_pkgs",
MagicMock(return_value=UNINSTALL)):
mock_cmd = MagicMock(return_value={
"retcode": 0,
"stdout": UPGRADE
})
patch_kwargs = {
"__salt__": {
"config.get": MagicMock(return_value=True),
"cmd.run_all": mock_cmd,
}
}
with patch.multiple(aptpkg, **patch_kwargs):
self.assertEqual(aptpkg.upgrade(), dict())
kwargs = {"force_conf_new": True}
self.assertEqual(aptpkg.upgrade(**kwargs), dict())
def test_upgrade_downloadonly(self):
"""
Tests the download-only options for upgrade.
"""
with patch("salt.utils.pkg.clear_rtag", MagicMock()):
with patch("salt.modules.aptpkg.list_pkgs",
MagicMock(return_value=UNINSTALL)):
mock_cmd = MagicMock(return_value={
"retcode": 0,
"stdout": UPGRADE
})
patch_kwargs = {
"__salt__": {
"config.get": MagicMock(return_value=True),
"cmd.run_all": mock_cmd,
},
}
with patch.multiple(aptpkg, **patch_kwargs):
aptpkg.upgrade()
args_matching = [
True for args in patch_kwargs["__salt__"]
["cmd.run_all"].call_args[0]
if "--download-only" in args
]
# Here we shouldn't see the parameter and args_matching should be empty.
self.assertFalse(any(args_matching))
aptpkg.upgrade(downloadonly=True)
args_matching = [
True for args in patch_kwargs["__salt__"]
["cmd.run_all"].call_args[0]
if "--download-only" in args
]
# --download-only should be in the args list and we should have at least on True in the list.
self.assertTrue(any(args_matching))
aptpkg.upgrade(download_only=True)
args_matching = [
True for args in patch_kwargs["__salt__"]
["cmd.run_all"].call_args[0]
if "--download-only" in args
]
# --download-only should be in the args list and we should have at least on True in the list.
self.assertTrue(any(args_matching))
def test_show(self):
"""
Test that the pkg.show function properly parses apt-cache show output.
This test uses an abridged output per package, for simplicity.
"""
show_mock_success = MagicMock(
return_value={
"retcode":
0,
"pid":
12345,
"stderr":
"",
"stdout":
textwrap.dedent("""\
Package: foo1.0
Architecture: amd64
Version: 1.0.5-3ubuntu4
Description: A silly package (1.0 release cycle)
Provides: foo
Suggests: foo-doc
Package: foo1.0
Architecture: amd64
Version: 1.0.4-2ubuntu1
Description: A silly package (1.0 release cycle)
Provides: foo
Suggests: foo-doc
Package: foo-doc
Architecture: all
Version: 1.0.5-3ubuntu4
Description: Silly documentation for a silly package (1.0 release cycle)
Package: foo-doc
Architecture: all
Version: 1.0.4-2ubuntu1
Description: Silly documentation for a silly package (1.0 release cycle)
"""),
})
show_mock_failure = MagicMock(
return_value={
"retcode":
1,
"pid":
12345,
"stderr":
textwrap.dedent("""\
N: Unable to locate package foo*
N: Couldn't find any package by glob 'foo*'
N: Couldn't find any package by regex 'foo*'
E: No packages found
"""),
"stdout":
"",
})
refresh_mock = Mock()
expected = {
"foo1.0": {
"1.0.5-3ubuntu4": {
"Architecture": "amd64",
"Description": "A silly package (1.0 release cycle)",
"Provides": "foo",
"Suggests": "foo-doc",
},
"1.0.4-2ubuntu1": {
"Architecture": "amd64",
"Description": "A silly package (1.0 release cycle)",
"Provides": "foo",
"Suggests": "foo-doc",
},
},
"foo-doc": {
"1.0.5-3ubuntu4": {
"Architecture":
"all",
"Description":
"Silly documentation for a silly package (1.0 release cycle)",
},
"1.0.4-2ubuntu1": {
"Architecture":
"all",
"Description":
"Silly documentation for a silly package (1.0 release cycle)",
},
},
}
# Make a copy of the above dict and strip out some keys to produce the
# expected filtered result.
filtered = copy.deepcopy(expected)
for k1 in filtered:
for k2 in filtered[k1]:
# Using list() because we will modify the dict during iteration
for k3 in list(filtered[k1][k2]):
if k3 not in ("Description", "Provides"):
filtered[k1][k2].pop(k3)
with patch.dict(aptpkg.__salt__,
{"cmd.run_all": show_mock_success}), patch.object(
aptpkg, "refresh_db", refresh_mock):
# Test success (no refresh)
self.assertEqual(aptpkg.show("foo*"), expected)
refresh_mock.assert_not_called()
refresh_mock.reset_mock()
# Test success (with refresh)
self.assertEqual(aptpkg.show("foo*", refresh=True), expected)
self.assert_called_once(refresh_mock)
refresh_mock.reset_mock()
# Test filtered return
self.assertEqual(
aptpkg.show("foo*", filter="description,provides"), filtered)
refresh_mock.assert_not_called()
refresh_mock.reset_mock()
with patch.dict(aptpkg.__salt__,
{"cmd.run_all": show_mock_failure}), patch.object(
aptpkg, "refresh_db", refresh_mock):
# Test failure (no refresh)
self.assertEqual(aptpkg.show("foo*"), {})
refresh_mock.assert_not_called()
refresh_mock.reset_mock()
# Test failure (with refresh)
self.assertEqual(aptpkg.show("foo*", refresh=True), {})
self.assert_called_once(refresh_mock)
refresh_mock.reset_mock()
def test_mod_repo_enabled(self):
"""
Checks if a repo is enabled or disabled depending on the passed kwargs.
"""
with patch.dict(
aptpkg.__salt__,
{
"config.option": MagicMock(),
"no_proxy": MagicMock(return_value=False)
},
):
with patch("salt.modules.aptpkg._check_apt",
MagicMock(return_value=True)):
with patch("salt.modules.aptpkg.refresh_db",
MagicMock(return_value={})):
with patch("salt.utils.data.is_true",
MagicMock(return_value=True)) as data_is_true:
with patch("salt.modules.aptpkg.sourceslist",
MagicMock(),
create=True):
repo = aptpkg.mod_repo("foo", enabled=False)
data_is_true.assert_called_with(False)
# with disabled=True; should call salt.utils.data.is_true True
data_is_true.reset_mock()
repo = aptpkg.mod_repo("foo", disabled=True)
data_is_true.assert_called_with(True)
# with enabled=True; should call salt.utils.data.is_true with False
data_is_true.reset_mock()
repo = aptpkg.mod_repo("foo", enabled=True)
data_is_true.assert_called_with(True)
# with disabled=True; should call salt.utils.data.is_true False
data_is_true.reset_mock()
repo = aptpkg.mod_repo("foo", disabled=False)
data_is_true.assert_called_with(False)
@patch("salt.utils.path.os_walk",
MagicMock(return_value=[("test", "test", "test")]))
@patch("os.path.getsize", MagicMock(return_value=123456))
@patch("os.path.getctime", MagicMock(return_value=1234567890.123456))
@patch(
"fnmatch.filter",
MagicMock(return_value=["/var/cache/apt/archive/test_package.rpm"]),
)
def test_list_downloaded(self):
"""
Test downloaded packages listing.
:return:
"""
DOWNLOADED_RET = {
"test-package": {
"1.0": {
"path": "/var/cache/apt/archive/test_package.rpm",
"size": 123456,
"creation_date_time_t": 1234567890,
"creation_date_time": "2009-02-13T23:31:30",
}
}
}
with patch.dict(
aptpkg.__salt__,
{
"lowpkg.bin_pkg_info":
MagicMock(return_value={
"name": "test-package",
"version": "1.0"
})
},
):
list_downloaded = aptpkg.list_downloaded()
self.assertEqual(len(list_downloaded), 1)
self.assertDictEqual(list_downloaded, DOWNLOADED_RET)
def test__skip_source(self):
"""
Test __skip_source.
:return:
"""
# Valid source
source_type = "deb"
source_uri = "http://cdn-aws.deb.debian.org/debian"
source_line = "deb http://cdn-aws.deb.debian.org/debian stretch main\n"
mock_source = MockSourceEntry(source_uri, source_type, source_line,
False)
ret = aptpkg._skip_source(mock_source)
self.assertFalse(ret)
# Invalid source type
source_type = "ded"
source_uri = "http://cdn-aws.deb.debian.org/debian"
source_line = "deb http://cdn-aws.deb.debian.org/debian stretch main\n"
mock_source = MockSourceEntry(source_uri, source_type, source_line,
True)
ret = aptpkg._skip_source(mock_source)
self.assertTrue(ret)
# Invalid source type , not skipped
source_type = "deb"
source_uri = "http://cdn-aws.deb.debian.org/debian"
source_line = "deb [http://cdn-aws.deb.debian.org/debian] stretch main\n"
mock_source = MockSourceEntry(source_uri, source_type, source_line,
True)
ret = aptpkg._skip_source(mock_source)
self.assertFalse(ret)
def test_normalize_name(self):
"""
Test that package is normalized only when it should be
"""
with patch.dict(aptpkg.__grains__, {"osarch": "amd64"}):
result = aptpkg.normalize_name("foo")
assert result == "foo", result
result = aptpkg.normalize_name("foo:amd64")
assert result == "foo", result
result = aptpkg.normalize_name("foo:any")
assert result == "foo", result
result = aptpkg.normalize_name("foo:i386")
assert result == "foo:i386", result
def test_list_repos(self):
"""
Checks results from list_repos
"""
# Valid source
source_type = "deb"
source_uri = "http://cdn-aws.deb.debian.org/debian/"
source_line = "deb http://cdn-aws.deb.debian.org/debian/ stretch main\n"
mock_source = MockSourceEntry(source_uri, source_type, source_line,
False)
mock_source_list = MockSourceList()
mock_source_list.list = [mock_source]
with patch("salt.modules.aptpkg._check_apt",
MagicMock(return_value=True)):
with patch("salt.modules.aptpkg.sourceslist",
MagicMock(),
create=True):
with patch(
"salt.modules.aptpkg.sourceslist.SourcesList",
MagicMock(return_value=mock_source_list),
create=True,
):
repos = aptpkg.list_repos()
self.assertIn(source_uri, repos)
assert isinstance(repos[source_uri], list)
assert len(repos[source_uri]) == 1
# Make sure last character in of the URI in line is still a /
self.assertIn("line", repos[source_uri][0])
_uri = _get_uri(repos[source_uri][0]["line"])
self.assertEqual(_uri[-1], "/")
# Make sure last character in URI is still a /
self.assertIn("uri", repos[source_uri][0])
self.assertEqual(repos[source_uri][0]["uri"][-1], "/")
def test_expand_repo_def(self):
"""
Checks results from expand_repo_def
"""
source_type = "deb"
source_uri = "http://cdn-aws.deb.debian.org/debian/"
source_line = "deb http://cdn-aws.deb.debian.org/debian/ stretch main\n"
source_file = "/etc/apt/sources.list"
mock_source = MockSourceEntry(source_uri,
source_type,
source_line,
False,
file=source_file)
# Valid source
with patch("salt.modules.aptpkg._check_apt",
MagicMock(return_value=True)):
with patch("salt.modules.aptpkg.sourceslist",
MagicMock(),
create=True):
with patch(
"salt.modules.aptpkg.sourceslist.SourceEntry",
MagicMock(return_value=mock_source),
create=True,
):
repo = "deb http://cdn-aws.deb.debian.org/debian/ stretch main\n"
sanitized = aptpkg.expand_repo_def(repo=repo,
file=source_file)
assert isinstance(sanitized, dict)
self.assertIn("uri", sanitized)
# Make sure last character in of the URI is still a /
self.assertEqual(sanitized["uri"][-1], "/")
def test_show(self):
"""
Test that the pkg.show function properly parses apt-cache show output.
This test uses an abridged output per package, for simplicity.
"""
show_mock_success = MagicMock(
return_value={
"retcode":
0,
"pid":
12345,
"stderr":
"",
"stdout":
textwrap.dedent("""\
Package: foo1.0
Architecture: amd64
Version: 1.0.5-3ubuntu4
Description: A silly package (1.0 release cycle)
Provides: foo
Suggests: foo-doc
Package: foo1.0
Architecture: amd64
Version: 1.0.4-2ubuntu1
Description: A silly package (1.0 release cycle)
Provides: foo
Suggests: foo-doc
Package: foo-doc
Architecture: all
Version: 1.0.5-3ubuntu4
Description: Silly documentation for a silly package (1.0 release cycle)
Package: foo-doc
Architecture: all
Version: 1.0.4-2ubuntu1
Description: Silly documentation for a silly package (1.0 release cycle)
"""),
})
show_mock_failure = MagicMock(
return_value={
"retcode":
1,
"pid":
12345,
"stderr":
textwrap.dedent("""\
N: Unable to locate package foo*
N: Couldn't find any package by glob 'foo*'
N: Couldn't find any package by regex 'foo*'
E: No packages found
"""),
"stdout":
"",
})
refresh_mock = Mock()
expected = {
"foo1.0": {
"1.0.5-3ubuntu4": {
"Architecture": "amd64",
"Description": "A silly package (1.0 release cycle)",
"Provides": "foo",
"Suggests": "foo-doc",
},
"1.0.4-2ubuntu1": {
"Architecture": "amd64",
"Description": "A silly package (1.0 release cycle)",
"Provides": "foo",
"Suggests": "foo-doc",
},
},
"foo-doc": {
"1.0.5-3ubuntu4": {
"Architecture":
"all",
"Description":
"Silly documentation for a silly package (1.0 release cycle)",
},
"1.0.4-2ubuntu1": {
"Architecture":
"all",
"Description":
"Silly documentation for a silly package (1.0 release cycle)",
},
},
}
# Make a copy of the above dict and strip out some keys to produce the
# expected filtered result.
filtered = copy.deepcopy(expected)
for k1 in filtered:
for k2 in filtered[k1]:
# Using list() because we will modify the dict during iteration
for k3 in list(filtered[k1][k2]):
if k3 not in ("Description", "Provides"):
filtered[k1][k2].pop(k3)
with patch.dict(aptpkg.__salt__,
{"cmd.run_all": show_mock_success}), patch.object(
aptpkg, "refresh_db", refresh_mock):
# Test success (no refresh)
self.assertEqual(aptpkg.show("foo*"), expected)
refresh_mock.assert_not_called()
refresh_mock.reset_mock()
# Test success (with refresh)
self.assertEqual(aptpkg.show("foo*", refresh=True), expected)
self.assert_called_once(refresh_mock)
refresh_mock.reset_mock()
# Test filtered return
self.assertEqual(
aptpkg.show("foo*", filter="description,provides"), filtered)
refresh_mock.assert_not_called()
refresh_mock.reset_mock()
with patch.dict(aptpkg.__salt__,
{"cmd.run_all": show_mock_failure}), patch.object(
aptpkg, "refresh_db", refresh_mock):
# Test failure (no refresh)
self.assertEqual(aptpkg.show("foo*"), {})
refresh_mock.assert_not_called()
refresh_mock.reset_mock()
# Test failure (with refresh)
self.assertEqual(aptpkg.show("foo*", refresh=True), {})
self.assert_called_once(refresh_mock)
refresh_mock.reset_mock()
class MacGroupTestCase(TestCase):
'''
TestCase for the salt.modules.mac_group module
'''
mac_group.__context__ = {}
mac_group.__salt__ = {}
mock_group = {'passwd': '*', 'gid': 0, 'name': 'test', 'members': ['root']}
mock_getgrall = [grp.struct_group(('foo', '*', 20, ['test']))]
# 'add' function tests: 6
@patch('salt.modules.mac_group.info', MagicMock(return_value=mock_group))
def test_add_group_exists(self):
'''
Tests if the group already exists or not
'''
self.assertRaises(CommandExecutionError, mac_group.add, 'test')
@patch('salt.modules.mac_group.info', MagicMock(return_value={}))
def test_add_whitespace(self):
'''
Tests if there is whitespace in the group name
'''
self.assertRaises(SaltInvocationError, mac_group.add, 'white space')
@patch('salt.modules.mac_group.info', MagicMock(return_value={}))
def test_add_underscore(self):
'''
Tests if the group name starts with an underscore or not
'''
self.assertRaises(SaltInvocationError, mac_group.add, '_Test')
@patch('salt.modules.mac_group.info', MagicMock(return_value={}))
def test_add_gid_int(self):
'''
Tests if the gid is an int or not
'''
self.assertRaises(SaltInvocationError, mac_group.add, 'foo', 'foo')
@patch('salt.modules.mac_group.info', MagicMock(return_value={}))
@patch('salt.modules.mac_group._list_gids', MagicMock(return_value=['3456']))
def test_add_gid_exists(self):
'''
Tests if the gid is already in use or not
'''
self.assertRaises(CommandExecutionError, mac_group.add, 'foo', 3456)
@patch('salt.modules.mac_group.info', MagicMock(return_value={}))
@patch('salt.modules.mac_group._list_gids', MagicMock(return_value=[]))
def test_add(self):
'''
Tests if specified group was added
'''
mock_ret = MagicMock(return_value=0)
with patch.dict(mac_group.__salt__, {'cmd.retcode': mock_ret}):
self.assertTrue(mac_group.add('test', 500))
# 'delete' function tests: 4
def test_delete_whitespace(self):
'''
Tests if there is whitespace in the group name
'''
self.assertRaises(SaltInvocationError, mac_group.delete, 'white space')
def test_delete_underscore(self):
'''
Tests if the group name starts with an underscore or not
'''
self.assertRaises(SaltInvocationError, mac_group.delete, '_Test')
@patch('salt.modules.mac_group.info', MagicMock(return_value={}))
def test_delete_group_exists(self):
'''
Tests if the group to be deleted exists or not
'''
self.assertTrue(mac_group.delete('test'))
@patch('salt.modules.mac_group.info', MagicMock(return_value=mock_group))
def test_delete(self):
'''
Tests if the specified group was deleted
'''
mock_ret = MagicMock(return_value=0)
with patch.dict(mac_group.__salt__, {'cmd.retcode': mock_ret}):
self.assertTrue(mac_group.delete('test'))
# 'info' function tests: 2
def test_info_whitespace(self):
'''
Tests if there is whitespace in the group name
'''
self.assertRaises(SaltInvocationError, mac_group.info, 'white space')
@patch('grp.getgrall', MagicMock(return_value=mock_getgrall))
def test_info(self):
'''
Tests the return of group information
'''
ret = {'passwd': '*', 'gid': 20, 'name': 'foo', 'members': ['test']}
self.assertEqual(mac_group.info('foo'), ret)
# '_format_info' function tests: 1
def test_format_info(self):
'''
Tests the formatting of returned group information
'''
data = grp.struct_group(('wheel', '*', 0, ['root']))
ret = {'passwd': '*', 'gid': 0, 'name': 'wheel', 'members': ['root']}
self.assertEqual(mac_group._format_info(data), ret)
# 'getent' function tests: 1
@patch('grp.getgrall', MagicMock(return_value=mock_getgrall))
def test_getent(self):
'''
Tests the return of information on all groups
'''
ret = [{'passwd': '*', 'gid': 20, 'name': 'foo', 'members': ['test']}]
self.assertEqual(mac_group.getent(), ret)
# 'chgid' function tests: 4
def test_chgid_gid_int(self):
'''
Tests if gid is an integer or not
'''
self.assertRaises(SaltInvocationError, mac_group.chgid, 'foo', 'foo')
@patch('salt.modules.mac_group.info', MagicMock(return_value={}))
def test_chgid_group_exists(self):
'''
Tests if the group id exists or not
'''
mock_pre_gid = MagicMock(return_value='')
with patch.dict(mac_group.__salt__,
{'file.group_to_gid': mock_pre_gid}):
self.assertRaises(CommandExecutionError,
mac_group.chgid, 'foo', 4376)
@patch('salt.modules.mac_group.info', MagicMock(return_value=mock_group))
def test_chgid_gid_same(self):
'''
Tests if the group id is the same as argument
'''
mock_pre_gid = MagicMock(return_value=0)
with patch.dict(mac_group.__salt__,
{'file.group_to_gid': mock_pre_gid}):
self.assertTrue(mac_group.chgid('test', 0))
@patch('salt.modules.mac_group.info', MagicMock(return_value=mock_group))
def test_chgid(self):
'''
Tests the gid for a named group was changed
'''
mock_pre_gid = MagicMock(return_value=0)
mock_ret = MagicMock(return_value=0)
with patch.dict(mac_group.__salt__,
{'file.group_to_gid': mock_pre_gid}):
with patch.dict(mac_group.__salt__, {'cmd.retcode': mock_ret}):
self.assertTrue(mac_group.chgid('test', 500))
def mock_proc(__cmd__, **kwargs):
cmd_handler.cmd = " ".join(__cmd__)
return MagicMock(return_value=MockTimedProc(stdout=None, stderr=None))
def test_shell_properly_handled_on_macOS(self):
"""
cmd.run should invoke a new bash login only
when bash is the default shell for the selected user
"""
class _CommandHandler(object):
"""
Class for capturing cmd
"""
def __init__(self):
self.cmd = None
def clear(self):
self.cmd = None
cmd_handler = _CommandHandler()
def mock_proc(__cmd__, **kwargs):
cmd_handler.cmd = " ".join(__cmd__)
return MagicMock(return_value=MockTimedProc(stdout=None, stderr=None))
with patch("pwd.getpwnam") as getpwnam_mock:
with patch("salt.utils.timed_subprocess.TimedProc", mock_proc):
# User default shell is '/usr/local/bin/bash'
user_default_shell = "/usr/local/bin/bash"
with patch.dict(
cmdmod.__salt__,
{
"user.info": MagicMock(
return_value={"shell": user_default_shell}
)
},
):
cmd_handler.clear()
cmdmod._run(
"ls", cwd=tempfile.gettempdir(), runas="foobar", use_vt=False
)
self.assertRegex(
cmd_handler.cmd,
"{} -l -c".format(user_default_shell),
"cmd invokes right bash session on macOS",
)
# User default shell is '/bin/zsh'
user_default_shell = "/bin/zsh"
with patch.dict(
cmdmod.__salt__,
{
"user.info": MagicMock(
return_value={"shell": user_default_shell}
)
},
):
cmd_handler.clear()
cmdmod._run(
"ls", cwd=tempfile.gettempdir(), runas="foobar", use_vt=False
)
self.assertNotRegex(
cmd_handler.cmd,
"bash -l -c",
"cmd does not invoke user shell on macOS",
)
def test_return_managed_object_name(self):
mock_get_properties_of_managed_object = MagicMock()
with patch('salt.utils.vmware.get_properties_of_managed_object',
MagicMock(return_value={'name': 'fake_name'})):
ret = salt.utils.vmware.get_managed_object_name(self.mock_mo_ref)
self.assertEqual(ret, 'fake_name')
def test_uptime_linux(self):
'''
Test modules.status.uptime function for Linux
'''
m = self._set_up_test_uptime()
with patch.multiple(salt.utils.platform,
is_linux=MagicMock(return_value=True),
is_sunos=MagicMock(return_value=False),
is_darwin=MagicMock(return_value=False),
is_freebsd=MagicMock(return_value=False),
is_openbsd=MagicMock(return_value=False),
is_netbsd=MagicMock(return_value=False)), \
patch('salt.utils.path.which', MagicMock(return_value=True)), \
patch.dict(status.__salt__, {'cmd.run': MagicMock(return_value=os.linesep.join(['1', '2', '3']))}), \
patch('time.time', MagicMock(return_value=m.now)), \
patch('os.path.exists', MagicMock(return_value=True)):
proc_uptime = salt.utils.stringutils.to_str('{0} {1}'.format(m.ut, m.idle))
with patch('salt.utils.files.fopen', mock_open(read_data=proc_uptime)):
ret = status.uptime()
self.assertDictEqual(ret, m.ret)
with patch('os.path.exists', MagicMock(return_value=False)):
with self.assertRaises(CommandExecutionError):
status.uptime()
class GetContentTestCase(TestCase):
'''Tests for salt.utils.get_content'''
# Method names to be patched
traversal_spec_method_name = \
'salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec'
property_spec_method_name = \
'salt.utils.vmware.vmodl.query.PropertyCollector.PropertySpec'
obj_spec_method_name = \
'salt.utils.vmware.vmodl.query.PropertyCollector.ObjectSpec'
filter_spec_method_name = \
'salt.utils.vmware.vmodl.query.PropertyCollector.FilterSpec'
# Class variables
si_mock = None
root_folder_mock = None
root_folder_prop = None
container_view_mock = None
create_container_view_mock = None
result_mock = None
retrieve_contents_mock = None
destroy_mock = None
obj_type_mock = None
traversal_spec_ret_mock = None
traversal_spec_mock = None
property_spec_ret_mock = None
property_spec_mock = None
obj_spec_ret_mock = None
obj_spec_mock = None
filter_spec_ret_mock = None
filter_spec_mock = None
def setUp(self):
# setup the service instance
self.si_mock = MagicMock()
# RootFolder
self.root_folder_mock = MagicMock()
self.get_root_folder_mock = \
MagicMock(return_value=self.root_folder_mock)
# CreateContainerView()
self.container_view_mock = MagicMock()
self.create_container_view_mock = \
MagicMock(return_value=self.container_view_mock)
self.si_mock.content.viewManager.CreateContainerView = \
self.create_container_view_mock
# RetrieveContents()
self.result_mock = MagicMock()
self.retrieve_contents_mock = MagicMock(return_value=self.result_mock)
self.si_mock.content.propertyCollector.RetrieveContents = \
self.retrieve_contents_mock
# Destroy()
self.destroy_mock = MagicMock()
self.container_view_mock.Destroy = self.destroy_mock
# override mocks
self.obj_type_mock = MagicMock()
self.traversal_spec_ret_mock = MagicMock()
self.traversal_spec_mock = \
MagicMock(return_value=self.traversal_spec_ret_mock)
self.property_spec_ret_mock = MagicMock()
self.property_spec_mock = \
MagicMock(return_value=self.property_spec_ret_mock)
self.obj_spec_ret_mock = MagicMock()
self.obj_spec_mock = \
MagicMock(return_value=self.obj_spec_ret_mock)
self.filter_spec_ret_mock = MagicMock()
self.filter_spec_mock = \
MagicMock(return_value=self.filter_spec_ret_mock)
def test_empty_container_ref(self):
with patch('salt.utils.vmware.get_root_folder',
self.get_root_folder_mock):
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.get_root_folder_mock.assert_called_once_with(self.si_mock)
self.create_container_view_mock.assert_called_once_with(
self.root_folder_mock, [self.obj_type_mock], True)
def test_defined_container_ref(self):
container_ref_mock = MagicMock()
with patch('salt.utils.vmware.get_root_folder',
self.get_root_folder_mock):
with patch(self.obj_spec_method_name, self.obj_type_mock):
salt.utils.vmware.get_content(self.si_mock,
self.obj_type_mock,
container_ref=container_ref_mock)
self.assertEqual(self.get_root_folder_mock.call_count, 0)
self.create_container_view_mock.assert_called_once_with(
container_ref_mock, [self.obj_type_mock], True)
# Also checks destroy is called
def test_local_traversal_spec(self):
with patch('salt.utils.vmware.get_root_folder',
self.get_root_folder_mock):
with patch(self.traversal_spec_method_name,
self.traversal_spec_mock):
with patch(self.obj_spec_method_name, self.obj_spec_mock):
ret = salt.utils.vmware.get_content(
self.si_mock, self.obj_type_mock)
self.create_container_view_mock.assert_called_once_with(
self.root_folder_mock, [self.obj_type_mock], True)
self.traversal_spec_mock.assert_called_once_with(
name='traverseEntities',
path='view',
skip=False,
type=vim.view.ContainerView)
self.obj_spec_mock.assert_called_once_with(
obj=self.container_view_mock,
skip=True,
selectSet=[self.traversal_spec_ret_mock])
# check destroy is called
self.assertEqual(self.destroy_mock.call_count, 1)
def test_create_container_view_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = 'VimFault msg'
self.si_mock.content.viewManager.CreateContainerView = \
MagicMock(side_effect=exc)
with patch('salt.utils.vmware.get_root_folder',
self.get_root_folder_mock):
with self.assertRaises(excs.VMwareApiError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(excinfo.exception.strerror, 'VimFault msg')
def test_create_container_view_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = 'RuntimeFault msg'
self.si_mock.content.viewManager.CreateContainerView = \
MagicMock(side_effect=exc)
with patch('salt.utils.vmware.get_root_folder',
self.get_root_folder_mock):
with self.assertRaises(excs.VMwareRuntimeError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(excinfo.exception.strerror, 'RuntimeFault msg')
def test_destroy_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = 'VimFault msg'
self.si_mock.content.viewManager.CreateContainerView = MagicMock(
return_value=MagicMock(Destroy=MagicMock(side_effect=exc)))
with patch('salt.utils.vmware.get_root_folder',
self.get_root_folder_mock):
with self.assertRaises(excs.VMwareApiError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(excinfo.exception.strerror, 'VimFault msg')
def test_destroy_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = 'RuntimeFault msg'
self.si_mock.content.viewManager.CreateContainerView = MagicMock(
return_value=MagicMock(Destroy=MagicMock(side_effect=exc)))
with patch('salt.utils.vmware.get_root_folder',
self.get_root_folder_mock):
with self.assertRaises(excs.VMwareRuntimeError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(excinfo.exception.strerror, 'RuntimeFault msg')
# Also checks destroy is not called
def test_external_traversal_spec(self):
traversal_spec_obj_mock = MagicMock()
with patch('salt.utils.vmware.get_root_folder',
self.get_root_folder_mock):
with patch(self.traversal_spec_method_name,
self.traversal_spec_mock):
with patch(self.obj_spec_method_name, self.obj_spec_mock):
salt.utils.vmware.get_content(
self.si_mock,
self.obj_type_mock,
traversal_spec=traversal_spec_obj_mock)
self.obj_spec_mock.assert_called_once_with(
obj=self.root_folder_mock,
skip=True,
selectSet=[traversal_spec_obj_mock])
# Check local traversal methods are not called
self.assertEqual(self.create_container_view_mock.call_count, 0)
self.assertEqual(self.traversal_spec_mock.call_count, 0)
# check destroy is not called
self.assertEqual(self.destroy_mock.call_count, 0)
def test_property_obj_filter_specs_and_contents(self):
with patch(self.traversal_spec_method_name, self.traversal_spec_mock):
with patch(self.property_spec_method_name,
self.property_spec_mock):
with patch(self.obj_spec_method_name, self.obj_spec_mock):
with patch(self.filter_spec_method_name,
self.filter_spec_mock):
ret = salt.utils.vmware.get_content(
self.si_mock, self.obj_type_mock)
self.traversal_spec_mock.assert_called_once_with(
name='traverseEntities',
path='view',
skip=False,
type=vim.view.ContainerView)
self.property_spec_mock.assert_called_once_with(
type=self.obj_type_mock, all=True, pathSet=None)
self.obj_spec_mock.assert_called_once_with(
obj=self.container_view_mock,
skip=True,
selectSet=[self.traversal_spec_ret_mock])
self.retrieve_contents_mock.assert_called_once_with(
[self.filter_spec_ret_mock])
self.assertEqual(ret, self.result_mock)
def test_retrieve_contents_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = 'VimFault msg'
self.si_mock.content.propertyCollector.RetrieveContents = \
MagicMock(side_effect=exc)
with self.assertRaises(excs.VMwareApiError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(excinfo.exception.strerror, 'VimFault msg')
def test_retrieve_contents_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
exc.msg = 'RuntimeFault msg'
self.si_mock.content.propertyCollector.RetrieveContents = \
MagicMock(side_effect=exc)
with self.assertRaises(excs.VMwareRuntimeError) as excinfo:
salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock)
self.assertEqual(excinfo.exception.strerror, 'RuntimeFault msg')
def test_local_properties_set(self):
container_ref_mock = MagicMock()
with patch(self.traversal_spec_method_name, self.traversal_spec_mock):
with patch(self.property_spec_method_name,
self.property_spec_mock):
with patch(self.obj_spec_method_name, self.obj_spec_mock):
salt.utils.vmware.get_content(
self.si_mock,
self.obj_type_mock,
container_ref=container_ref_mock,
local_properties=True)
self.assertEqual(self.traversal_spec_mock.call_count, 0)
self.obj_spec_mock.assert_called_once_with(obj=container_ref_mock,
skip=False,
selectSet=None)
class M2CryptTestCase(TestCase):
@patch('os.umask', MagicMock())
@patch('os.chmod', MagicMock())
@patch('os.access', MagicMock(return_value=True))
def test_gen_keys(self):
with patch('M2Crypto.RSA.RSA.save_pem', MagicMock()) as save_pem:
with patch('M2Crypto.RSA.RSA.save_pub_key', MagicMock()) as save_pub:
with patch('os.path.isfile', return_value=True):
self.assertEqual(crypt.gen_keys('/keydir', 'keyname', 2048),
'/keydir{0}keyname.pem'.format(os.sep))
save_pem.assert_not_called()
save_pub.assert_not_called()
with patch('os.path.isfile', return_value=False):
self.assertEqual(crypt.gen_keys('/keydir', 'keyname', 2048),
'/keydir{0}keyname.pem'.format(os.sep))
save_pem.assert_called_once_with('/keydir{0}keyname.pem'.format(os.sep), cipher=None)
save_pub.assert_called_once_with('/keydir{0}keyname.pub'.format(os.sep))
@patch('os.umask', MagicMock())
@patch('os.chmod', MagicMock())
@patch('os.chown', MagicMock())
@patch('os.access', MagicMock(return_value=True))
def test_gen_keys_with_passphrase(self):
with patch('M2Crypto.RSA.RSA.save_pem', MagicMock()) as save_pem:
with patch('M2Crypto.RSA.RSA.save_pub_key', MagicMock()) as save_pub:
with patch('os.path.isfile', return_value=True):
self.assertEqual(crypt.gen_keys('/keydir', 'keyname', 2048, passphrase='password'),
'/keydir{0}keyname.pem'.format(os.sep))
save_pem.assert_not_called()
save_pub.assert_not_called()
with patch('os.path.isfile', return_value=False):
self.assertEqual(crypt.gen_keys('/keydir', 'keyname', 2048, passphrase='password'),
'/keydir{0}keyname.pem'.format(os.sep))
callback = save_pem.call_args[1]['callback']
save_pem.assert_called_once_with('/keydir{0}keyname.pem'.format(os.sep),
cipher='des_ede3_cbc',
callback=callback)
self.assertEqual(callback(None), b'password')
save_pub.assert_called_once_with('/keydir{0}keyname.pub'.format(os.sep))
def test_sign_message(self):
key = M2Crypto.RSA.load_key_string(six.b(PRIVKEY_DATA))
with patch('salt.crypt.get_rsa_key', return_value=key):
self.assertEqual(SIG, salt.crypt.sign_message('/keydir/keyname.pem', MSG))
def test_sign_message_with_passphrase(self):
key = M2Crypto.RSA.load_key_string(six.b(PRIVKEY_DATA))
with patch('salt.crypt.get_rsa_key', return_value=key):
self.assertEqual(SIG, crypt.sign_message('/keydir/keyname.pem', MSG, passphrase='password'))
def test_verify_signature(self):
key = M2Crypto.RSA.load_pub_key_bio(M2Crypto.BIO.MemoryBuffer(six.b(PUBKEY_DATA)))
with patch('M2Crypto.RSA.load_pub_key', return_value=key):
self.assertTrue(crypt.verify_signature('/keydir/keyname.pub', MSG, SIG))
def test_encrypt_decrypt_bin(self):
priv_key = M2Crypto.RSA.load_key_string(six.b(PRIVKEY_DATA))
pub_key = M2Crypto.RSA.load_pub_key_bio(M2Crypto.BIO.MemoryBuffer(six.b(PUBKEY_DATA)))
encrypted = salt.crypt.private_encrypt(priv_key, b'salt')
decrypted = salt.crypt.public_decrypt(pub_key, encrypted)
self.assertEqual(b'salt', decrypted)
def setUp(self):
self.mock_root_folder = MagicMock()
self.mock_content = MagicMock(rootFolder=self.mock_root_folder)
self.mock_si = MagicMock(RetrieveContent=MagicMock(
return_value=self.mock_content))
class PoudriereTestCase(TestCase):
'''
Test cases for salt.modules.poudriere
'''
# 'is_jail' function tests: 1
@patch('salt.modules.poudriere._check_config_exists',
MagicMock(return_value=True))
def test_is_jail(self):
'''
Test if it return True if jail exists False if not.
'''
mock = MagicMock(return_value='salt stack')
with patch.dict(poudriere.__salt__, {'cmd.run': mock}):
self.assertTrue(poudriere.is_jail('salt'))
self.assertFalse(poudriere.is_jail('SALT'))
# 'make_pkgng_aware' function tests: 1
def test_make_pkgng_aware(self):
'''
Test if it make jail ``jname`` pkgng aware.
'''
ret1 = 'Could not create or find required directory /tmp/salt'
ret2 = 'Looks like file /tmp/salt/salt-make.conf could not be created'
ret3 = {'changes': 'Created /tmp/salt/salt-make.conf'}
mock = MagicMock(return_value='/tmp/salt')
mock_true = MagicMock(return_value=True)
with patch.dict(poudriere.__salt__, {
'config.option': mock,
'file.write': mock_true
}):
with patch.object(os.path, 'isdir', MagicMock(return_value=False)):
with patch.object(os, 'makedirs', mock_true):
self.assertEqual(poudriere.make_pkgng_aware('salt'), ret1)
with patch.object(os.path, 'isdir', mock_true):
self.assertEqual(poudriere.make_pkgng_aware('salt'), ret2)
with patch.object(os.path, 'isfile', mock_true):
self.assertDictEqual(poudriere.make_pkgng_aware('salt'),
ret3)
# 'parse_config' function tests: 1
@patch('salt.utils.fopen', mock_open())
def test_parse_config(self):
'''
Test if it returns a dict of poudriere main configuration definitions.
'''
mock = MagicMock(return_value='/tmp/salt')
with patch.dict(poudriere.__salt__, {'config.option': mock}):
with patch.object(poudriere, '_check_config_exists',
MagicMock(side_effect=[True, False])):
self.assertDictEqual(poudriere.parse_config(), {})
self.assertEqual(poudriere.parse_config(),
'Could not find /tmp/salt on file system')
# 'version' function tests: 1
def test_version(self):
'''
Test if it return poudriere version.
'''
mock = MagicMock(return_value='9.0-RELEASE')
with patch.dict(poudriere.__salt__, {'cmd.run': mock}):
self.assertEqual(poudriere.version(), '9.0-RELEASE')
# 'list_jails' function tests: 1
@patch('salt.modules.poudriere._check_config_exists',
MagicMock(return_value=True))
def test_list_jails(self):
'''
Test if it return a list of current jails managed by poudriere.
'''
mock = MagicMock(return_value='salt stack')
with patch.dict(poudriere.__salt__, {'cmd.run': mock}):
self.assertListEqual(poudriere.list_jails(), ['salt stack'])
# 'list_ports' function tests: 1
@patch('salt.modules.poudriere._check_config_exists',
MagicMock(return_value=True))
def test_list_ports(self):
'''
Test if it return a list of current port trees managed by poudriere.
'''
mock = MagicMock(return_value='salt stack')
with patch.dict(poudriere.__salt__, {'cmd.run': mock}):
self.assertListEqual(poudriere.list_ports(), ['salt stack'])
# 'create_jail' function tests: 1
@patch('salt.modules.poudriere._check_config_exists',
MagicMock(return_value=True))
def test_create_jail(self):
'''
Test if it creates a new poudriere jail if one does not exist.
'''
mock_stack = MagicMock(return_value='90amd64 stack')
mock_true = MagicMock(return_value=True)
with patch.dict(poudriere.__salt__, {'cmd.run': mock_stack}):
self.assertEqual(poudriere.create_jail('90amd64', 'amd64'),
'90amd64 already exists')
with patch.object(poudriere, 'make_pkgng_aware', mock_true):
self.assertEqual(poudriere.create_jail('80amd64', 'amd64'),
'Issue creating jail 80amd64')
with patch.object(poudriere, 'make_pkgng_aware', mock_true):
with patch.object(poudriere, 'is_jail',
MagicMock(side_effect=[False, True])):
with patch.dict(poudriere.__salt__, {'cmd.run': mock_stack}):
self.assertEqual(poudriere.create_jail('80amd64', 'amd64'),
'Created jail 80amd64')
# 'update_jail' function tests: 1
@patch('salt.modules.poudriere._check_config_exists',
MagicMock(return_value=True))
def test_update_jail(self):
'''
Test if it run freebsd-update on `name` poudriere jail.
'''
mock = MagicMock(return_value='90amd64 stack')
with patch.dict(poudriere.__salt__, {'cmd.run': mock}):
self.assertEqual(poudriere.update_jail('90amd64'), '90amd64 stack')
self.assertEqual(poudriere.update_jail('80amd64'),
'Could not find jail 80amd64')
# 'delete_jail' function tests: 1
@patch('salt.modules.poudriere._check_config_exists',
MagicMock(return_value=True))
def test_delete_jail(self):
'''
Test if it deletes poudriere jail with `name`.
'''
ret = 'Looks like there was an issue deleteing jail 90amd64'
mock_stack = MagicMock(return_value='90amd64 stack')
with patch.dict(poudriere.__salt__, {'cmd.run': mock_stack}):
self.assertEqual(poudriere.delete_jail('90amd64'), ret)
self.assertEqual(poudriere.delete_jail('80amd64'),
'Looks like jail 80amd64 has not been created')
ret1 = 'Deleted jail "80amd64" but was unable to remove jail make file'
with patch.object(poudriere, 'is_jail',
MagicMock(side_effect=[True, False, True, False])):
with patch.dict(poudriere.__salt__, {'cmd.run': mock_stack}):
with patch.object(poudriere, '_config_dir',
MagicMock(return_value='/tmp/salt')):
self.assertEqual(poudriere.delete_jail('80amd64'),
'Deleted jail 80amd64')
with patch.object(os.path, 'isfile',
MagicMock(return_value=True)):
self.assertEqual(poudriere.delete_jail('80amd64'),
ret1)
# 'create_ports_tree' function tests: 1
@patch('salt.modules.poudriere._check_config_exists',
MagicMock(return_value=True))
def test_create_ports_tree(self):
'''
Test if it not working need to run portfetch non interactive.
'''
mock = MagicMock(return_value='salt stack')
with patch.dict(poudriere.__salt__, {'cmd.run': mock}):
self.assertEqual(poudriere.create_ports_tree(), 'salt stack')
# 'update_ports_tree' function tests: 1
@patch('salt.modules.poudriere._check_config_exists',
MagicMock(return_value=True))
def test_update_ports_tree(self):
'''
Test if it updates the ports tree, either the default
or the `ports_tree` specified.
'''
mock = MagicMock(return_value='salt stack')
with patch.dict(poudriere.__salt__, {'cmd.run': mock}):
self.assertEqual(poudriere.update_ports_tree('staging'),
'salt stack')
# 'bulk_build' function tests: 1
@patch('salt.modules.poudriere._check_config_exists',
MagicMock(return_value=True))
def test_bulk_build(self):
'''
Test if it run bulk build on poudriere server.
'''
ret = 'Could not find file /root/pkg_list on filesystem'
mock = MagicMock(return_value='salt stack')
with patch.dict(poudriere.__salt__, {'cmd.run': mock}):
self.assertEqual(poudriere.bulk_build('90amd64', '/root/pkg_list'),
ret)
with patch.object(os.path, 'isfile', MagicMock(return_value=True)):
self.assertEqual(
poudriere.bulk_build('90amd64', '/root/pkg_list'),
'Could not find jail 90amd64')
ret = ('There may have been an issue building '
'packages dumping output: 90amd64 stack')
with patch.object(os.path, 'isfile', MagicMock(return_value=True)):
mock = MagicMock(return_value='90amd64 stack packages built')
with patch.dict(poudriere.__salt__, {'cmd.run': mock}):
self.assertEqual(
poudriere.bulk_build('90amd64', '/root/pkg_list'),
'90amd64 stack packages built')
mock = MagicMock(return_value='90amd64 stack')
with patch.dict(poudriere.__salt__, {'cmd.run': mock}):
self.assertEqual(
poudriere.bulk_build('90amd64', '/root/pkg_list'), ret)
class DnsmasqTestCase(TestCase):
'''
TestCase for the salt.modules.at module
'''
def test_version(self):
'''
test to show installed version of dnsmasq.
'''
mock = MagicMock(return_value='A B C')
with patch.dict(dnsmasq.__salt__, {'cmd.run': mock}):
self.assertEqual(dnsmasq.version(), "C")
def test_fullversion(self):
'''
Test to Show installed version of dnsmasq and compile options.
'''
mock = MagicMock(return_value='A B C\nD E F G H I')
with patch.dict(dnsmasq.__salt__, {'cmd.run': mock}):
self.assertDictEqual(dnsmasq.fullversion(),
{'version': 'C',
'compile options': ['G', 'H', 'I']})
def test_set_config(self):
'''
test to show installed version of dnsmasq.
'''
mock = MagicMock(return_value={'conf-dir': 'A'})
with patch.object(dnsmasq, 'get_config', mock):
mock = MagicMock(return_value=['.', '~', 'bak', '#'])
with patch.object(os, 'listdir', mock):
self.assertDictEqual(dnsmasq.set_config(), {})
@patch('salt.modules.dnsmasq.get_config', MagicMock(return_value={'conf-dir': 'A'}))
def test_set_config_filter_pub_kwargs(self):
'''
Test that the kwargs returned from running the set_config function
do not contain the __pub that may have been passed through in **kwargs.
'''
mock_domain = 'local'
mock_address = '/some-test-address.local/8.8.4.4'
with patch.dict(dnsmasq.__salt__, {'file.append': MagicMock()}):
ret = dnsmasq.set_config(follow=False,
domain=mock_domain,
address=mock_address,
__pub_pid=8184,
__pub_jid=20161101194639387946,
__pub_tgt='salt-call')
self.assertEqual(ret, {'domain': mock_domain, 'address': mock_address})
def test_get_config(self):
'''
test to dumps all options from the config file.
'''
mock = MagicMock(return_value={'conf-dir': 'A'})
with patch.object(dnsmasq, 'get_config', mock):
mock = MagicMock(return_value=['.', '~', 'bak', '#'])
with patch.object(os, 'listdir', mock):
self.assertDictEqual(dnsmasq.get_config(), {'conf-dir': 'A'})
def test_parse_dnsmasq_no_file(self):
'''
Tests that a CommandExecutionError is when a filename that doesn't exist is
passed in.
'''
self.assertRaises(CommandExecutionError, dnsmasq._parse_dnamasq, 'filename')
@patch('os.path.isfile', MagicMock(return_value=True))
def test_parse_dnamasq(self):
'''
test for generic function for parsing dnsmasq files including includes.
'''
text_file_data = '\n'.join(["line here", "second line", "A=B", "#"])
with patch('salt.utils.fopen',
mock_open(read_data=text_file_data),
create=True) as m:
m.return_value.__iter__.return_value = text_file_data.splitlines()
self.assertDictEqual(dnsmasq._parse_dnamasq('filename'),
{'A': 'B',
'unparsed': ['line here',
'second line']})
import salt.exceptions as excs
import salt.utils.vmware
# Import Third Party Libs
try:
from pyVmomi import vim, vmodl
HAS_PYVMOMI = True
except ImportError:
HAS_PYVMOMI = False
# Get Logging Started
log = logging.getLogger(__name__)
@skipIf(NO_MOCK, NO_MOCK_REASON)
@skipIf(not HAS_PYVMOMI, 'The \'pyvmomi\' library is missing')
@patch('salt.utils.vmware.time.time', MagicMock(return_value=1))
@patch('salt.utils.vmware.time.sleep', MagicMock(return_value=None))
class WaitForTaskTestCase(TestCase):
'''Tests for salt.utils.vmware.wait_for_task'''
def test_first_task_info_raise_vim_fault(self):
exc = vim.fault.VimFault()
exc.msg = 'VimFault msg'
mock_task = MagicMock()
type(mock_task).info = PropertyMock(side_effect=exc)
with self.assertRaises(excs.VMwareApiError) as excinfo:
salt.utils.vmware.wait_for_task(mock_task, 'fake_instance_name',
'task_type')
self.assertEqual(excinfo.exception.strerror, 'VimFault msg')
def test_first_task_info_raise_runtime_fault(self):
exc = vmodl.RuntimeFault()
def test_running(self):
'''
Test to verify that the service is running
'''
ret = [{'comment': '', 'changes': {}, 'name': 'salt', 'result': True},
{'changes': {},
'comment': 'The service salt is already running',
'name': 'salt', 'result': True},
{'changes': 'saltstack',
'comment': 'The service salt is already running',
'name': 'salt', 'result': True},
{'changes': {},
'comment': 'Service salt is set to start', 'name': 'salt',
'result': None},
{'changes': 'saltstack',
'comment': 'Started Service salt', 'name': 'salt',
'result': True},
{'changes': {},
'comment': 'The service salt is already running',
'name': 'salt', 'result': True},
{'changes': 'saltstack',
'comment': 'Service salt failed to start', 'name': 'salt',
'result': False},
{'changes': 'saltstack',
'comment': 'Started Service salt\nService masking not available on this minion',
'name': 'salt', 'result': True, 'warnings': ["The 'unmask' argument is not supported by this platform/action"]}]
tmock = MagicMock(return_value=True)
fmock = MagicMock(return_value=False)
vmock = MagicMock(return_value="salt")
with patch.object(service, '_enabled_used_error', vmock):
self.assertEqual(service.running("salt", enabled=1), 'salt')
with patch.object(service, '_available', fmock):
self.assertDictEqual(service.running("salt"), ret[0])
with patch.object(service, '_available', tmock):
with patch.dict(service.__opts__, {'test': False}):
with patch.dict(service.__salt__, {'service.enabled': tmock,
'service.status': tmock}):
self.assertDictEqual(service.running("salt"), ret[1])
mock = MagicMock(return_value={'changes': 'saltstack'})
with patch.dict(service.__salt__, {'service.enabled': MagicMock(side_effect=[False, True]),
'service.status': tmock}):
with patch.object(service, '_enable', mock):
self.assertDictEqual(service.running("salt", True), ret[2])
with patch.dict(service.__salt__, {'service.enabled': MagicMock(side_effect=[True, False]),
'service.status': tmock}):
with patch.object(service, '_disable', mock):
self.assertDictEqual(service.running("salt", False), ret[2])
with patch.dict(service.__salt__, {'service.status': MagicMock(side_effect=[False, True]),
'service.enabled': MagicMock(side_effect=[False, True]),
'service.start': MagicMock(return_value="stack")}):
with patch.object(service, '_enable', MagicMock(return_value={'changes': 'saltstack'})):
self.assertDictEqual(service.running("salt", True), ret[4])
with patch.dict(service.__salt__, {'service.status': MagicMock(side_effect=[False, True]),
'service.enabled': MagicMock(side_effect=[False, True]),
'service.unmask': MagicMock(side_effect=[False, True]),
'service.start': MagicMock(return_value="stack")}):
with patch.object(service, '_enable', MagicMock(return_value={'changes': 'saltstack'})):
self.assertDictEqual(service.running("salt", True, unmask=True), ret[7])
with patch.dict(service.__opts__, {'test': True}):
with patch.dict(service.__salt__, {'service.status': tmock}):
self.assertDictEqual(service.running("salt"), ret[5])
with patch.dict(service.__salt__, {'service.status': fmock}):
self.assertDictEqual(service.running("salt"), ret[3])
with patch.dict(service.__opts__, {'test': False}):
with patch.dict(service.__salt__, {'service.status': MagicMock(side_effect=[False, False]),
'service.enabled': MagicMock(side_effecct=[True, True]),
'service.start': MagicMock(return_value='stack')}):
with patch.object(service, '_enable', MagicMock(return_value={'changes': 'saltstack'})):
self.assertDictEqual(service.running('salt', True), ret[6])
def setUp(self):
self.si = MagicMock()
self.obj_type = MagicMock()
self.prop_list = MagicMock()
self.container_ref = MagicMock()
self.traversal_spec = MagicMock()
def setup_loader_modules(self):
self.org_run_operation = MagicMock()
self.addCleanup(delattr, self, "org_run_operation")
return {
jboss7: {"__salt__": {"jboss7_cli.run_operation": self.org_run_operation}}
}
def setUp(self):
self.mock_si = MagicMock()
self.fake_mo_ref = vim.ManagedEntity('Fake')
self.mock_props = MagicMock()
self.mock_item_name = {'name': 'fake_name'}
self.mock_item = MagicMock()
def setUp(self):
self.policy_ids = MagicMock()
self.mock_policies = MagicMock()
self.mock_prof_mgr = MagicMock(RetrieveContent=MagicMock(
return_value=self.mock_policies))
def setUp(self):
self.mock_mo_ref = MagicMock()
def setUp(self):
self.mock_policy_spec = MagicMock()
self.mock_policy = MagicMock()
self.mock_prof_mgr = MagicMock()
def test_is_valid_shell_windows(self):
"""
Tests return if running on windows
"""
with patch("salt.utils.platform.is_windows", MagicMock(return_value=True)):
self.assertTrue(cmdmod._is_valid_shell("foo"))
