def test_get_locale(self):
'''
Test for Get the current system locale
'''
with patch.dict(localemod.__context__, {'salt.utils.systemd.booted': True}):
with patch.multiple(localemod,
_parse_dbus_locale=MagicMock(return_value={'LANG': 'A'}),
HAS_DBUS=True):
self.assertEqual('A', localemod.get_locale())
localemod._parse_dbus_locale.assert_called_once_with()
with patch.multiple(localemod,
_parse_localectl=MagicMock(return_value={'LANG': 'A'}),
HAS_DBUS=False):
self.assertEqual('A', localemod.get_locale())
localemod._parse_localectl.assert_called_once_with()
with patch.dict(localemod.__context__, {'salt.utils.systemd.booted': False}):
with patch.dict(localemod.__grains__, {'os_family': ['Gentoo']}):
with patch.dict(localemod.__salt__, {'cmd.run': MagicMock(return_value='A')}):
with patch.object(localemod,
'_parse_localectl',
return_value={'LANG': 'A'}):
self.assertEqual(localemod.get_locale(), 'A')
with patch.dict(localemod.__grains__, {'os_family': ['RedHat']}):
with patch.dict(localemod.__salt__, {'cmd.run': MagicMock(return_value='A=B')}):
with patch.object(localemod,
'_parse_localectl',
return_value={'LANG': 'B'}):
self.assertEqual(localemod.get_locale(), 'B')
with patch.dict(localemod.__grains__, {'os_family': ['Unknown']}):
with patch.dict(localemod.__salt__, {'cmd.run': MagicMock(return_value='A=B')}):
self.assertRaises(CommandExecutionError, localemod.get_locale)
def test_present_from_scratch(self):
mock_get = MagicMock(return_value={"result": None})
with patch.multiple(
boto_cloudfront,
__salt__={"boto_cloudfront.get_distribution": mock_get},
__opts__={"test": True},
):
comment = "Distribution {0} set for creation.".format(self.name)
self.assertDictEqual(
boto_cloudfront.present(self.name, self.config, self.tags),
self.base_ret_with({
"result": None,
"comment": comment,
"changes": {
"old": None,
"new": self.name
},
}),
)
mock_create_failure = MagicMock(return_value={"error": "create error"})
with patch.multiple(
boto_cloudfront,
__salt__={
"boto_cloudfront.get_distribution": mock_get,
"boto_cloudfront.create_distribution": mock_create_failure,
},
__opts__={"test": False},
):
comment = "Error creating distribution {0}: create error"
self.assertDictEqual(
boto_cloudfront.present(self.name, self.config, self.tags),
self.base_ret_with({
"result": False,
"comment": comment.format(self.name)
}),
)
mock_create_success = MagicMock(return_value={"result": True})
with patch.multiple(
boto_cloudfront,
__salt__={
"boto_cloudfront.get_distribution": mock_get,
"boto_cloudfront.create_distribution": mock_create_success,
},
__opts__={"test": False},
):
comment = "Created distribution {0}."
self.assertDictEqual(
boto_cloudfront.present(self.name, self.config, self.tags),
self.base_ret_with({
"result": True,
"comment": comment.format(self.name),
"changes": {
"old": None,
"new": self.name
},
}),
)
def test_present_from_scratch(self):
mock_get = MagicMock(return_value={'result': None})
with patch.multiple(
boto_cloudfront,
__salt__={'boto_cloudfront.get_distribution': mock_get},
__opts__={'test': True},
):
comment = 'Distribution {0} set for creation.'.format(self.name)
self.assertDictEqual(
boto_cloudfront.present(self.name, self.config, self.tags),
self.base_ret_with({
'result': None,
'comment': comment,
'pchanges': {
'old': None,
'new': self.name
},
}),
)
mock_create_failure = MagicMock(return_value={'error': 'create error'})
with patch.multiple(
boto_cloudfront,
__salt__={
'boto_cloudfront.get_distribution': mock_get,
'boto_cloudfront.create_distribution': mock_create_failure,
},
__opts__={'test': False},
):
comment = 'Error creating distribution {0}: create error'
self.assertDictEqual(
boto_cloudfront.present(self.name, self.config, self.tags),
self.base_ret_with({
'result': False,
'comment': comment.format(self.name),
}),
)
mock_create_success = MagicMock(return_value={'result': True})
with patch.multiple(
boto_cloudfront,
__salt__={
'boto_cloudfront.get_distribution': mock_get,
'boto_cloudfront.create_distribution': mock_create_success,
},
__opts__={'test': False},
):
comment = 'Created distribution {0}.'
self.assertDictEqual(
boto_cloudfront.present(self.name, self.config, self.tags),
self.base_ret_with({
'result': True,
'comment': comment.format(self.name),
'changes': {
'old': None,
'new': self.name
},
}),
)
def setUp(self):
loader_module = getattr(self, 'loader_module', None)
if loader_module is not None:
if NO_MOCK:
self.skipTest(NO_MOCK_REASON)
loader_module_name = loader_module.__name__
loader_module_globals = getattr(self, 'loader_module_globals',
None)
loader_module_blacklisted_dunders = getattr(
self, 'loader_module_blacklisted_dunders', ())
if loader_module_globals is None:
loader_module_globals = {}
elif callable(loader_module_globals):
loader_module_globals = loader_module_globals()
else:
loader_module_globals = copy.deepcopy(loader_module_globals)
salt_dunders = (
'__opts__',
'__salt__',
'__runner__',
'__context__',
'__utils__',
'__ext_pillar__',
'__thorium__',
'__states__',
'__serializers__',
'__ret__',
'__grains__',
'__pillar__',
'__sdb__',
# Proxy is commented out on purpose since some code in salt expects a NameError
# and is most of the time not a required dunder
# '__proxy__'
)
for dunder_name in salt_dunders:
if dunder_name not in loader_module_globals:
if dunder_name in loader_module_blacklisted_dunders:
continue
loader_module_globals[dunder_name] = {}
for key in loader_module_globals:
if not hasattr(loader_module, key):
if key in salt_dunders:
setattr(loader_module, key, {})
else:
setattr(loader_module, key, None)
if loader_module_globals:
patcher = patch.multiple(loader_module_name,
**loader_module_globals)
patcher.start()
def cleanup(patcher, loader_module_globals):
patcher.stop()
del loader_module_globals
self.addCleanup(cleanup, patcher, loader_module_globals)
super(LoaderModuleMockMixin, self).setUp()
def setup_log(self):
"""
Mock logger functions
"""
testing_config = self.default_config.copy()
testing_config["root_dir"] = self.root_dir
for name in ("pki_dir", "cachedir"):
testing_config[name] = name
testing_config[self.logfile_config_setting_name] = getattr(
self, self.logfile_config_setting_name, self.log_file)
self.testing_config = testing_config
self.addCleanup(setattr, self, "testing_config", None)
self.log_impl = LogImplMock()
self.addCleanup(self.log_impl._destroy)
self.addCleanup(setattr, self, "log_impl", None)
mocked_functions = {}
for name in dir(self.log_impl):
if name.startswith("_"):
continue
func = getattr(self.log_impl, name)
if not callable(func):
continue
mocked_functions[name] = func
patcher = patch.multiple(salt._logging, **mocked_functions)
patcher.start()
self.addCleanup(patcher.stop)
def test_cpustats_openbsd(self):
"""
Test modules.status.cpustats function for OpenBSD
"""
m = self._set_up_test_cpustats_openbsd()
systat = (
"\n"
"\n"
" 1 users Load 0.20 0.07 0.05 salt.localdomain 09:42:42\n"
"CPU User Nice System Interrupt Idle\n"
"0 0.0% 0.0% 4.5% 0.5% 95.0%\n"
)
with patch.multiple(
salt.utils.platform,
is_linux=MagicMock(return_value=False),
is_sunos=MagicMock(return_value=False),
is_darwin=MagicMock(return_value=False),
is_freebsd=MagicMock(return_value=False),
is_openbsd=MagicMock(return_value=True),
is_netbsd=MagicMock(return_value=False),
), patch("salt.utils.path.which",
MagicMock(return_value=True)), patch.dict(
status.__grains__, {"kernel": "OpenBSD"}), patch.dict(
status.__salt__,
{"cmd.run": MagicMock(return_value=systat)}):
ret = status.cpustats()
self.assertDictEqual(ret, m.ret)
def test_repo_noadd_mod_ref(self):
'''
Test mod_repo detects the repo already exists,
calls modify to update 'autorefresh' and refreshes the repo with
`zypper --gpg-auto-import-keys refresh <repo-name>`
:return:
'''
url = self.new_repo_config['url']
name = self.new_repo_config['name']
self.zypper_patcher_config['_get_configured_repos'] = Mock(
**{'return_value.sections.return_value': [name]}
)
zypper_patcher = patch.multiple(
'salt.modules.zypper', **self.zypper_patcher_config)
with zypper_patcher:
zypper.mod_repo(
name,
**{'url': url, 'refresh': True, 'gpgautoimport': True}
)
self.assertEqual(
zypper.__zypper__.xml.call.call_args_list,
[call('--gpg-auto-import-keys', 'refresh', name)]
)
zypper.__zypper__.refreshable.xml.call.assert_called_once_with(
'--gpg-auto-import-keys', 'mr', '--refresh', name
)
def test_uptime_sunos(self):
"""
Test modules.status.uptime function for SunOS
"""
m = self._set_up_test_uptime()
m2 = self._set_up_test_uptime_sunos()
with patch.multiple(
salt.utils.platform,
is_linux=MagicMock(return_value=False),
is_sunos=MagicMock(return_value=True),
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"])),
"cmd.run_all":
MagicMock(return_value=m2.ret),
},
), patch("time.time", MagicMock(return_value=m.now)):
ret = status.uptime()
self.assertDictEqual(ret, m.ret)
def test_present_correct_state():
name = "my_distribution"
base_ret = {"name": name, "changes": {}}
# Most attributes elided since there are so many required ones
config = {"Enabled": True, "HttpVersion": "http2"}
tags = {"test_tag1": "value1"}
mock_get = MagicMock(
return_value={
"result": {
"distribution": {
"DistributionConfig": config
},
"tags": tags,
"etag": "test etag",
}
})
with patch.multiple(
boto_cloudfront,
__salt__={"boto_cloudfront.get_distribution": mock_get},
__opts__={"test": False},
):
comment = "Distribution {0} has correct config."
assert boto_cloudfront.present(name, config, tags) == base_ret_with({
"result":
True,
"comment":
comment.format(name)
})
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(*str(m.now - m.ut).split('.')))
with patch.multiple(salt.utils,
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)):
with patch.dict(
status.__salt__, {
'cmd.run': MagicMock(return_value="1\n2\n3"),
'sysctl.get': MagicMock(return_value=kern_boottime)
}):
with 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()
def test_remove_noaction(self):
"""
Test - Remove packages.
"""
with patch(
"salt.modules.opkg.list_pkgs",
MagicMock(side_effect=[self.packages, self.packages]),
):
std_out = "\nRemoving vim (7.4) from root...\n"
ret_value = {"retcode": 0, "stdout": std_out}
mock = MagicMock(return_value=ret_value)
patch_kwargs = {
"__salt__": {
"cmd.run_all":
mock,
"pkg_resource.parse_targets":
MagicMock(return_value=({
"vim": "7.4"
}, "repository")),
"restartcheck.restartcheck":
MagicMock(
return_value="No packages seem to need to be restarted"
),
}
}
with patch.multiple(opkg, **patch_kwargs):
self.assertEqual(opkg.remove("vim:7.4", test=True),
self.removed)
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_repo_add_mod_ref(self):
'''
Test mod_repo adds the new repo,
calls modify to update 'autorefresh' and refreshes the repo with
`zypper --gpg-auto-import-keys refresh <repo-name>`
:return:
'''
zypper_patcher = patch.multiple(
'salt.modules.zypper', **self.zypper_patcher_config)
url = self.new_repo_config['url']
name = self.new_repo_config['name']
with zypper_patcher:
zypper.mod_repo(
name,
**{'url': url, 'refresh': True, 'gpgautoimport': True}
)
self.assertEqual(
zypper.__zypper__.xml.call.call_args_list,
[
call('ar', url, name),
call('--gpg-auto-import-keys', 'refresh', name)
]
)
zypper.__zypper__.refreshable.xml.call.assert_called_once_with(
'--gpg-auto-import-keys', 'mr', '--refresh', name
)
def test_install_noaction(self):
"""
Test - Install packages.
"""
with patch("salt.modules.opkg.list_pkgs",
MagicMock(side_effect=({}, {}))):
std_out = "Downloading http://feedserver/feeds/test/vim_7.4_arch.ipk.\n\nInstalling vim (7.4) on root\n"
ret_value = {"retcode": 0, "stdout": std_out}
mock = MagicMock(return_value=ret_value)
patch_kwargs = {
"__salt__": {
"cmd.run_all":
mock,
"pkg_resource.parse_targets":
MagicMock(return_value=({
"vim": "7.4"
}, "repository")),
"restartcheck.restartcheck":
MagicMock(
return_value="No packages seem to need to be restarted"
),
}
}
with patch.multiple(opkg, **patch_kwargs):
self.assertEqual(opkg.install("vim:7.4", test=True),
self.installed)
def test_push(self):
'''
Test if push works with good posix path.
'''
filename = '/saltines/test.file'
with patch('salt.modules.cp.os.path',
MagicMock(isfile=Mock(return_value=True), wraps=cp.os.path)), \
patch.multiple('salt.modules.cp',
_auth=MagicMock(**{'return_value.gen_token.return_value': 'token'}),
__opts__={'id': 'abc', 'file_buffer_size': 10}), \
patch('salt.utils.files.fopen', mock_open(read_data=b'content')) as m_open, \
patch('salt.transport.Channel.factory', MagicMock()):
response = cp.push(filename)
assert response, response
num_opens = len(m_open.filehandles[filename])
assert num_opens == 1, num_opens
fh_ = m_open.filehandles[filename][0]
assert fh_.read.call_count == 2, fh_.read.call_count
salt.transport.Channel.factory({}).send.assert_called_once_with(
dict(
loc=fh_.tell(), # pylint: disable=resource-leakage
cmd='_file_recv',
tok='token',
path=['saltines', 'test.file'],
data=
b'', # data is empty here because load['data'] is overwritten
id='abc'))
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("{} {}".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()
def test_repo_noadd_modbaseurl_ref(self):
'''
Test mod_repo detects the repo already exists,
no modification was requested and no refresh requested either
:return:
'''
url = self.new_repo_config['url']
name = self.new_repo_config['name']
self.zypper_patcher_config['_get_configured_repos'] = Mock(
**{'return_value.sections.side_effect': [[name], [], [], [name]]}
)
zypper_patcher = patch.multiple(
'salt.modules.zypper', **self.zypper_patcher_config)
with zypper_patcher:
params = {'baseurl': url + "-changed", 'enabled': False}
zypper.mod_repo(name, **params)
expected_params = {
'alias': 'mock-repo-name',
'autorefresh': True,
'baseurl': 'http://repo.url/some/path-changed',
'enabled': False,
'priority': 1,
'cache': False,
'keeppackages': False,
'type': 'rpm-md'}
self.assertTrue(zypper.mod_repo.call_count == 2)
self.assertTrue(zypper.mod_repo.mock_calls[1] == call(name, **expected_params))
def test_upgrade_allow_downgrades(uninstall_var, upgrade_var):
"""
Tests the allow_downgrades option for upgrade.
"""
with patch("salt.utils.pkg.clear_rtag", MagicMock()):
with patch("salt.modules.aptpkg.list_pkgs",
MagicMock(return_value=uninstall_var)):
mock_cmd = MagicMock(return_value={
"retcode": 0,
"stdout": upgrade_var
})
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 "--allow-downgrades" in args
]
# Here we shouldn't see the parameter and args_matching should be empty.
assert any(args_matching) is False
aptpkg.upgrade(allow_downgrades=True)
args_matching = [
True for args in patch_kwargs["__salt__"]
["cmd.run_all"].call_args[0]
if "--allow-downgrades" in args
]
# --allow-downgrades should be in the args list and we should have at least on True in the list.
assert any(args_matching) is True
def setup_log(self):
"""
Mock logger functions
"""
testing_config = self.default_config.copy()
testing_config["root_dir"] = self.root_dir
for name in ("pki_dir", "cachedir"):
testing_config[name] = name
testing_config[self.logfile_config_setting_name] = getattr(
self, self.logfile_config_setting_name, self.log_file)
self.testing_config = testing_config
self.addCleanup(setattr, self, "testing_config", None)
self.log_setup = LogSetupMock()
patcher = patch.multiple(
log,
setup_console_logger=self.log_setup.setup_console_logger,
setup_extended_logging=self.log_setup.setup_extended_logging,
setup_logfile_logger=self.log_setup.setup_logfile_logger,
get_multiprocessing_logging_queue=self.log_setup.
get_multiprocessing_logging_queue,
setup_multiprocessing_logging_listener=self.log_setup.
setup_multiprocessing_logging_listener,
setup_temp_logger=self.log_setup.setup_temp_logger,
)
patcher.start()
self.addCleanup(patcher.stop)
self.addCleanup(setattr, self, "log_setup", None)
def setup_log(self):
'''
Mock logger functions
'''
testing_config = self.default_config.copy()
testing_config['root_dir'] = self.root_dir
for name in ('pki_dir', 'cachedir'):
testing_config[name] = name
testing_config[self.logfile_config_setting_name] = getattr(
self, self.logfile_config_setting_name, self.log_file)
self.testing_config = testing_config
self.addCleanup(setattr, self, 'testing_config', None)
self.log_setup = LogSetupMock()
patcher = patch.multiple(
log,
setup_console_logger=self.log_setup.setup_console_logger,
setup_extended_logging=self.log_setup.setup_extended_logging,
setup_logfile_logger=self.log_setup.setup_logfile_logger,
get_multiprocessing_logging_queue=self.log_setup.
get_multiprocessing_logging_queue,
setup_multiprocessing_logging_listener=self.log_setup.
setup_multiprocessing_logging_listener,
setup_temp_logger=self.log_setup.setup_temp_logger)
patcher.start()
self.addCleanup(patcher.stop)
self.addCleanup(setattr, self, 'log_setup', None)
def test_uptime_linux(self):
'''
Test modules.status.uptime function for Linux
'''
m = self._set_up_test_uptime()
with patch.multiple(salt.utils,
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)):
with patch.dict(status.__salt__,
{'cmd.run': MagicMock(return_value="1\n2\n3")}):
with patch('time.time', MagicMock(return_value=m.now)):
with patch('os.path.exists', MagicMock(return_value=True)):
proc_uptime = '{0} {1}'.format(m.ut, m.idle)
with patch('salt.utils.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()
def test_previous_and_next_releases():
with patch.multiple(
SaltVersionsInfo,
_previous_release=None,
_next_release=None,
_current_release=SaltVersionsInfo.CALIFORNIUM,
):
assert SaltVersionsInfo.current_release() == SaltVersionsInfo.CALIFORNIUM
assert SaltVersionsInfo.next_release() == SaltVersionsInfo.EINSTEINIUM
assert SaltVersionsInfo.previous_release() == SaltVersionsInfo.BERKELIUM
with patch.multiple(
SaltVersionsInfo,
_previous_release=None,
_next_release=None,
_current_release=SaltVersionsInfo.NEPTUNIUM,
):
assert SaltVersionsInfo.current_release() == SaltVersionsInfo.NEPTUNIUM
assert SaltVersionsInfo.next_release() == SaltVersionsInfo.PLUTONIUM
assert SaltVersionsInfo.previous_release() == SaltVersionsInfo.URANIUM
def test_zip(self):
with patch('glob.glob', lambda pathname: [pathname]):
with patch.multiple(os.path, **{'isdir': MagicMock(return_value=False),
'exists': MagicMock(return_value=True)}):
with patch('zipfile.ZipFile', MagicMock()):
ret = archive.zip_(
'/tmp/salt.{{grains.id}}.zip',
'/tmp/tmpePe8yO,/tmp/tmpLeSw1A',
template='jinja'
)
self.assertEqual(['tmp/tmpePe8yO', 'tmp/tmpLeSw1A'], ret)
def test_upgrade(self):
'''
Test - Upgrades all packages.
'''
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())
def __init__(self, stdout=None, stderr=None):
# Late import
import salt.utils
if stdout is None:
stdout = salt.utils.fopen(os.devnull, 'w') # pylint: disable=resource-leakage
if stderr is None:
stderr = salt.utils.fopen(os.devnull, 'w') # pylint: disable=resource-leakage
self.__stdout = stdout
self.__stderr = stderr
self.__redirected = False
self.patcher = patch.multiple(sys,
stderr=self.__stderr,
stdout=self.__stdout)
def test_gen_keys(self):
with patch.multiple(os, umask=MagicMock(), chmod=MagicMock(),
access=MagicMock(return_value=True)):
with patch('salt.utils.files.fopen', mock_open()):
open_priv_wb = call('/keydir{0}keyname.pem'.format(os.sep), 'wb+')
open_pub_wb = call('/keydir{0}keyname.pub'.format(os.sep), 'wb+')
with patch('os.path.isfile', return_value=True):
self.assertEqual(crypt.gen_keys('/keydir', 'keyname', 2048), '/keydir{0}keyname.pem'.format(os.sep))
self.assertNotIn(open_priv_wb, salt.utils.files.fopen.mock_calls)
self.assertNotIn(open_pub_wb, salt.utils.files.fopen.mock_calls)
with patch('os.path.isfile', return_value=False):
with patch('salt.utils.files.fopen', mock_open()):
crypt.gen_keys('/keydir', 'keyname', 2048)
salt.utils.files.fopen.assert_has_calls([open_priv_wb, open_pub_wb], any_order=True)
def test_present_distribution_retrieval_error(self):
"""
Test for boto_cloudfront.present when we cannot get the distribution.
"""
mock_get = MagicMock(return_value={"error": "get_distribution error"})
with patch.multiple(
boto_cloudfront,
__salt__={"boto_cloudfront.get_distribution": mock_get},
__opts__={"test": False},
):
comment = "Error checking distribution {0}: get_distribution error"
assert boto_cloudfront.present(self.name, self.config, self.tags) == self.base_ret_with(
{"result": False, "comment": comment.format(self.name)}
)
def test_uptime_return_success_not_supported(self):
'''
Test modules.status.uptime function for other platforms
'''
with patch.multiple(salt.utils,
is_linux=MagicMock(return_value=False),
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)):
exc_mock = MagicMock(side_effect=CommandExecutionError)
with self.assertRaises(CommandExecutionError):
with patch.dict(status.__salt__, {'cmd.run': exc_mock}):
status.uptime()
def test_autoremove(self):
'''
Test - Remove packages not required by another package.
'''
patch_kwargs = {
'__salt__': {
'config.get': MagicMock(return_value=True),
'cmd.run': MagicMock(return_value=AUTOREMOVE)
}
}
with patch.multiple(aptpkg, **patch_kwargs):
self.assertEqual(aptpkg.autoremove(), dict())
self.assertEqual(aptpkg.autoremove(purge=True), dict())
self.assertEqual(aptpkg.autoremove(list_only=True), list())
self.assertEqual(aptpkg.autoremove(list_only=True, purge=True),
list())
def test_remove(self):
'''
Test - Remove packages.
'''
with patch('salt.modules.opkg.list_pkgs', MagicMock(side_effect=[PACKAGES, {}])):
ret_value = {'retcode': 0}
mock = MagicMock(return_value=ret_value)
patch_kwargs = {
'__salt__': {
'cmd.run_all': mock,
'pkg_resource.parse_targets': MagicMock(return_value=({'vim': '7.4'}, 'repository')),
'restartcheck.restartcheck': MagicMock(return_value='No packages seem to need to be restarted')
}
}
with patch.multiple(opkg, **patch_kwargs):
self.assertEqual(opkg.remove('vim'), REMOVED)