def test_get_pkg_id_with_files(self, pkg_id_pkginfo_mock):
'''
Test getting a the id for a package
'''
expected = ['com.apple.this']
cmd_mock = MagicMock(side_effect=[
'/path/to/PackageInfo\n/path/to/some/other/fake/PackageInfo',
'',
''
])
pkg_id_pkginfo_mock.side_effect = [['com.apple.this'], []]
temp_mock = MagicMock(return_value='/tmp/dmg-ABCDEF')
remove_mock = MagicMock()
with patch.dict(macpackage.__salt__, {'cmd.run': cmd_mock,
'temp.dir': temp_mock,
'file.remove': remove_mock}):
out = macpackage.get_pkg_id('/path/to/file.pkg')
temp_mock.assert_called_once_with(prefix='pkg-')
cmd_calls = [
call('xar -t -f /path/to/file.pkg | grep PackageInfo', python_shell=True, output_loglevel='quiet'),
call('xar -x -f /path/to/file.pkg /path/to/PackageInfo /path/to/some/other/fake/PackageInfo',
cwd='/tmp/dmg-ABCDEF', output_loglevel='quiet')
]
cmd_mock.assert_has_calls(cmd_calls)
pkg_id_pkginfo_calls = [
call('/path/to/PackageInfo'),
call('/path/to/some/other/fake/PackageInfo')
]
pkg_id_pkginfo_mock.assert_has_calls(pkg_id_pkginfo_calls)
remove_mock.assert_called_once_with('/tmp/dmg-ABCDEF')
self.assertEqual(out, expected)
def _runner(self,
expected_ret,
test=False,
check=False,
add=False,
add_assertion=False):
mock_check = MagicMock(return_value=check)
mock_add = MagicMock(return_value=add)
with patch.dict(ipset.__opts__, {'test': test}):
with patch.dict(ipset.__salt__, {
'ipset.check': mock_check,
'ipset.add': mock_add
}):
actual_ret = ipset.present(self.fake_name,
self.fake_entries,
set_name=self.fake_name)
mock_check.assert_has_calls(
[call(self.fake_name, e, 'ipv4') for e in self.fake_entries],
any_order=True)
if add_assertion:
expected_calls = [
call(self.fake_name, e, 'ipv4', set_name=self.fake_name)
for e in self.fake_entries
]
if add is not True:
# if the add fails, then it will only get called once.
expected_calls = expected_calls[:1]
mock_add.assert_has_calls(expected_calls, any_order=True)
else:
self.assertTrue(mock_add.call_count == 0)
self.assertDictEqual(actual_ret, expected_ret)
def test_set_proxy_windows_no_ftp(self):
'''
Test to make sure that we correctly set the proxy info
on Windows
'''
proxy.__grains__['os'] = 'Windows'
mock_reg = MagicMock()
mock_cmd = MagicMock()
with patch.dict(proxy.__salt__, {'reg.set_value': mock_reg, 'cmd.run': mock_cmd}):
out = proxy.set_proxy_win('192.168.0.1', 3128, types=['http', 'https'],
bypass_hosts=['.moo.com', '.salt.com'])
calls = [
call('HKEY_CURRENT_USER',
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Internet Settings',
'ProxyServer',
'http=192.168.0.1:3128;https=192.168.0.1:3128;'),
call('HKEY_CURRENT_USER',
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Internet Settings',
'ProxyEnable',
1,
vtype='REG_DWORD'),
call('HKEY_CURRENT_USER',
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Internet Settings',
'ProxyOverride',
'<local>;.moo.com;.salt.com')
]
mock_reg.assert_has_calls(calls)
mock_cmd.assert_called_once_with('netsh winhttp import proxy source=ie')
self.assertTrue(out)
def test_get_pkg_id_with_files(self, pkg_id_pkginfo_mock):
'''
Test getting a the id for a package
'''
expected = ['com.apple.this']
cmd_mock = MagicMock(side_effect=[
'/path/to/PackageInfo\n/path/to/some/other/fake/PackageInfo',
'',
''
])
pkg_id_pkginfo_mock.side_effect = [['com.apple.this'], []]
temp_mock = MagicMock(return_value='/tmp/dmg-ABCDEF')
remove_mock = MagicMock()
with patch.dict(macpackage.__salt__, {'cmd.run': cmd_mock,
'temp.dir': temp_mock,
'file.remove': remove_mock}):
out = macpackage.get_pkg_id('/path/to/file.pkg')
temp_mock.assert_called_once_with(prefix='pkg-')
cmd_calls = [
call('xar -t -f /path/to/file.pkg | grep PackageInfo', python_shell=True, output_loglevel='quiet'),
call('xar -x -f /path/to/file.pkg /path/to/PackageInfo /path/to/some/other/fake/PackageInfo',
cwd='/tmp/dmg-ABCDEF', output_loglevel='quiet')
]
cmd_mock.assert_has_calls(cmd_calls)
pkg_id_pkginfo_calls = [
call('/path/to/PackageInfo'),
call('/path/to/some/other/fake/PackageInfo')
]
pkg_id_pkginfo_mock.assert_has_calls(pkg_id_pkginfo_calls)
remove_mock.assert_called_once_with('/tmp/dmg-ABCDEF')
self.assertEqual(out, expected)
def _runner(self,
expected_ret,
test=False,
check=False,
delete=False,
delete_assertion=False):
mock_check = MagicMock(return_value=check)
mock_delete = MagicMock(return_value=delete)
with patch.dict(ipset.__opts__, {'test': test}):
with patch.dict(ipset.__salt__, {
'ipset.check': mock_check,
'ipset.delete': mock_delete
}):
actual_ret = ipset.absent(self.fake_name,
self.fake_entries,
set_name=self.fake_name)
mock_check.assert_has_calls(
[call(self.fake_name, e, 'ipv4') for e in self.fake_entries],
any_order=True)
if delete_assertion:
expected_calls = [
call(self.fake_name, e, 'ipv4', set_name=self.fake_name)
for e in self.fake_entries
]
if delete is not True:
expected_calls = expected_calls[:1]
mock_delete.assert_has_calls(expected_calls, any_order=True)
else:
self.assertTrue(mock_delete.call_count == 0)
self.assertDictEqual(actual_ret, expected_ret)
def test_installed_cert_hash_different(self):
'''
Test installing a certificate into the OSX keychain when it's already installed but
the certificate has changed
'''
expected = {
'changes': {'installed': 'Friendly Name', 'uninstalled': 'Friendly Name'},
'comment': 'Found a certificate with the same name but different hash, removing it.\n',
'name': '/path/to/cert.p12',
'result': True
}
list_mock = MagicMock(side_effect=[['Friendly Name'], []])
friendly_mock = MagicMock(return_value='Friendly Name')
install_mock = MagicMock(return_value='1 identity imported.')
uninstall_mock = MagicMock(return_value='removed.')
hash_mock = MagicMock(side_effect=['ABCD', 'XYZ'])
with patch.dict(keychain.__salt__, {'keychain.list_certs': list_mock,
'keychain.get_friendly_name': friendly_mock,
'keychain.install': install_mock,
'keychain.uninstall': uninstall_mock,
'keychain.get_hash': hash_mock}):
out = keychain.installed('/path/to/cert.p12', 'passw0rd')
list_mock.assert_has_calls(calls=[call('/Library/Keychains/System.keychain'),
call('/Library/Keychains/System.keychain')])
friendly_mock.assert_called_once_with('/path/to/cert.p12', 'passw0rd')
install_mock.assert_called_once_with('/path/to/cert.p12', 'passw0rd', '/Library/Keychains/System.keychain')
uninstall_mock.assert_called_once_with('Friendly Name', '/Library/Keychains/System.keychain',
keychain_password=None)
self.assertEqual(out, expected)
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_stages(self, call_stage_mock):
'''
This is a very basic test and needs expansion, since call_stage is mocked!
'''
overstate = salt.overstate.OverState(self.master_config)
overstate.over = overstate._OverState__sort_stages(OVERSTATE_SLS)
overstate.stages()
expected_calls = [
call('all', {
'require': {
'mysql': 'webservers'
},
'match': '*'
}),
call('mysql', {
'match': 'db*',
'sls': {
'mysql.server': 'drbd'
}
}),
call('webservers', {
'require': ['mysql'],
'match': 'web*'
})
]
call_stage_mock.assert_has_calls(expected_calls, any_order=False)
def test_installed_cert_hash_different(self):
'''
Test installing a certificate into the macOS keychain when it's
already installed but the certificate has changed
'''
expected = {
'changes': {'installed': 'Friendly Name', 'uninstalled': 'Friendly Name'},
'comment': 'Found a certificate with the same name but different hash, removing it.\n',
'name': '/path/to/cert.p12',
'result': True
}
list_mock = MagicMock(side_effect=[['Friendly Name'], []])
friendly_mock = MagicMock(return_value='Friendly Name')
install_mock = MagicMock(return_value='1 identity imported.')
uninstall_mock = MagicMock(return_value='removed.')
hash_mock = MagicMock(side_effect=['ABCD', 'XYZ'])
with patch.dict(keychain.__salt__, {'keychain.list_certs': list_mock,
'keychain.get_friendly_name': friendly_mock,
'keychain.install': install_mock,
'keychain.uninstall': uninstall_mock,
'keychain.get_hash': hash_mock}):
out = keychain.installed('/path/to/cert.p12', 'passw0rd')
list_mock.assert_has_calls(calls=[call('/Library/Keychains/System.keychain'),
call('/Library/Keychains/System.keychain')])
friendly_mock.assert_called_once_with('/path/to/cert.p12', 'passw0rd')
install_mock.assert_called_once_with('/path/to/cert.p12', 'passw0rd', '/Library/Keychains/System.keychain')
uninstall_mock.assert_called_once_with('Friendly Name', '/Library/Keychains/System.keychain',
keychain_password=None)
self.assertEqual(out, expected)
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_ruby_nonroot(self):
mock = MagicMock(return_value={'retcode': 0, 'stdout': 'stdout'})
expected = [
call('/usr/local/rvm/bin/rvm autolibs disable 2.0.0', runas='rvm', cwd=None),
call('/usr/local/rvm/bin/rvm install --disable-binary 2.0.0', runas='rvm', cwd=None)]
with patch.dict(rvm.__salt__, {'cmd.run_all': mock}):
rvm.install_ruby('2.0.0', runas='rvm')
self.assertEqual(mock.call_args_list, expected)
def test_install_ruby_nonroot(self):
mock = MagicMock(return_value={"retcode": 0, "stdout": "stdout"})
expected = [
call("/usr/local/rvm/bin/rvm autolibs disable 2.0.0", runas="rvm", cwd=None),
call("/usr/local/rvm/bin/rvm install --disable-binary 2.0.0", runas="rvm", cwd=None),
]
with patch.dict(rvm.__salt__, {"cmd.run_all": mock}):
rvm.install_ruby("2.0.0", runas="rvm")
self.assertEqual(mock.call_args_list, expected)
def _test_call(self, function, expected_sql, *args, **kwargs):
connect_mock = MagicMock()
mysql._connect = connect_mock
with patch.dict(mysql.__salt__, {"config.option": MagicMock()}):
function(*args, **kwargs)
if isinstance(expected_sql, dict):
calls = call().cursor().execute("{0}".format(expected_sql["sql"]), expected_sql["sql_args"])
else:
calls = call().cursor().execute("{0}".format(expected_sql))
connect_mock.assert_has_calls(calls)
def _test_call(self, function, expected_sql, *args, **kwargs):
connect_mock = MagicMock()
mysql._connect = connect_mock
with patch.dict(mysql.__salt__, {'config.option': MagicMock()}):
function(*args, **kwargs)
if isinstance(expected_sql, dict):
calls = (call().cursor().execute('{0}'.format(expected_sql['sql']), expected_sql['sql_args']))
else:
calls = (call().cursor().execute('{0}'.format(expected_sql)))
connect_mock.assert_has_calls(calls)
def test_set_proxy_macos(self):
'''
Test to make sure we can set the proxy settings on macOS
'''
proxy.__grains__['os'] = 'Darwin'
expected = {'changes': {
'new': [
{'port': '3128',
'server': '192.168.0.1',
'service': 'http',
'user': '******'},
{'port': '3128',
'server': '192.168.0.1',
'service': 'https',
'user': '******'},
{'port': '3128',
'server': '192.168.0.1',
'service': 'ftp',
'user': '******'},
{'bypass_domains': ['salt.com', 'test.com']}]
},
'comment': 'http proxy settings updated correctly\nhttps proxy settings updated correctly\nftp proxy '
'settings updated correctly\nProxy bypass domains updated correctly\n',
'name': '192.168.0.1',
'result': True}
set_proxy_mock = MagicMock(return_value=True)
patches = {
'proxy.get_http_proxy': MagicMock(return_value={}),
'proxy.get_https_proxy': MagicMock(return_value={}),
'proxy.get_ftp_proxy': MagicMock(return_value={}),
'proxy.get_proxy_bypass': MagicMock(return_value=[]),
'proxy.set_http_proxy': set_proxy_mock,
'proxy.set_https_proxy': set_proxy_mock,
'proxy.set_ftp_proxy': set_proxy_mock,
'proxy.set_proxy_bypass': set_proxy_mock,
}
with patch.dict(proxy.__salt__, patches):
out = proxy.managed('192.168.0.1', '3128', user='******', password='******',
bypass_domains=['salt.com', 'test.com'])
if six.PY3:
# Sorting is different in Py3
out['changes']['new'][-1]['bypass_domains'] = sorted(out['changes']['new'][-1]['bypass_domains'])
calls = [
call('192.168.0.1', '3128', 'frank', 'passw0rd', 'Ethernet'),
call('192.168.0.1', '3128', 'frank', 'passw0rd', 'Ethernet'),
call('192.168.0.1', '3128', 'frank', 'passw0rd', 'Ethernet'),
call(['salt.com', 'test.com'], 'Ethernet')
]
set_proxy_mock.assert_has_calls(calls)
self.assertEqual(out, expected)
def test_stages(self, call_stage_mock):
'''
This is a very basic test and needs expansion, since call_stage is mocked!
'''
overstate = salt.overstate.OverState(self.master_config)
overstate.over = overstate._OverState__sort_stages(OVERSTATE_SLS)
overstate.stages()
expected_calls = [call('all', {'require': {'mysql': 'webservers'}, 'match': '*'}),
call('mysql', {'match': 'db*', 'sls': {'mysql.server': 'drbd'}}),
call('webservers', {'require': ['mysql'], 'match': 'web*'})]
call_stage_mock.assert_has_calls(expected_calls, any_order=False)
def test_gen_keys(self):
with patch('salt.utils.fopen', mock_open()):
open_priv_wb = call('/keydir/keyname.pem', 'wb+')
open_pub_wb = call('/keydir/keyname.pub', 'wb+')
with patch('os.path.isfile', return_value=True):
self.assertEqual(crypt.gen_keys('/keydir', 'keyname', 2048), '/keydir/keyname.pem')
self.assertNotIn(open_priv_wb, salt.utils.fopen.mock_calls)
self.assertNotIn(open_pub_wb, salt.utils.fopen.mock_calls)
with patch('os.path.isfile', return_value=False):
with patch('salt.utils.fopen', mock_open()):
crypt.gen_keys('/keydir', 'keyname', 2048)
salt.utils.fopen.assert_has_calls([open_priv_wb, open_pub_wb], any_order=True)
def test_gen_keys(self):
with patch('salt.utils.fopen', mock_open()):
open_priv_wb = call('/keydir/keyname.pem', 'wb+')
open_pub_wb = call('/keydir/keyname.pub', 'wb+')
with patch('os.path.isfile', return_value=True):
self.assertEqual(crypt.gen_keys('/keydir', 'keyname', 2048), '/keydir/keyname.pem')
self.assertNotIn(open_priv_wb, salt.utils.fopen.mock_calls)
self.assertNotIn(open_pub_wb, salt.utils.fopen.mock_calls)
with patch('os.path.isfile', return_value=False):
with patch('salt.utils.fopen', mock_open()):
crypt.gen_keys('/keydir', 'keyname', 2048)
salt.utils.fopen.assert_has_calls([open_priv_wb, open_pub_wb], any_order=True)
def test_third_attempt_successful_connection(self):
exc = vim.fault.HostConnectFault()
exc.msg = '[SSL: CERTIFICATE_VERIFY_FAILED]'
exc2 = Exception('certificate verify failed')
mock_sc = MagicMock(side_effect=[exc, exc2, None])
mock_ssl_unverif = MagicMock()
mock_ssl_context = MagicMock()
with patch('salt.utils.vmware.SmartConnect', mock_sc):
with patch('ssl._create_unverified_context', mock_ssl_unverif):
with patch('ssl.SSLContext', mock_ssl_context):
salt.utils.vmware._get_service_instance(
host='fake_host.fqdn',
username='******',
password='******',
protocol='fake_protocol',
port=1,
mechanism='sspi',
principal='fake_principal',
domain='fake_domain')
mock_ssl_context.assert_called_once_with(
ssl.PROTOCOL_TLSv1)
mock_ssl_unverif.assert_called_once_with()
calls = [
call(host='fake_host.fqdn',
user='******',
pwd='fake_password',
protocol='fake_protocol',
port=1,
b64token='fake_token',
mechanism='sspi'),
call(host='fake_host.fqdn',
user='******',
pwd='fake_password',
protocol='fake_protocol',
port=1,
sslContext=mock_ssl_unverif.return_value,
b64token='fake_token',
mechanism='sspi'),
call(host='fake_host.fqdn',
user='******',
pwd='fake_password',
protocol='fake_protocol',
port=1,
sslContext=mock_ssl_context.return_value,
b64token='fake_token',
mechanism='sspi'),
]
mock_sc.assert_has_calls(calls)
def test_install_pkgs(self):
'''
Test package install behavior for the following conditions:
- only base package name is given ('png')
- a flavor is specified ('vim--gtk2')
- a branch is specified ('ruby%2.3')
'''
class ListPackages(object):
def __init__(self):
self._iteration = 0
def __call__(self):
pkg_lists = [
{'vim': '7.4.1467p1-gtk2'},
{'png': '1.6.23', 'vim': '7.4.1467p1-gtk2', 'ruby': '2.3.1p1'}
]
pkgs = pkg_lists[self._iteration]
self._iteration += 1
return pkgs
parsed_targets = (
{'vim--gtk2': None, 'png': None, 'ruby%2.3': None},
"repository"
)
cmd_out = {
'retcode': 0,
'stdout': 'quirks-2.241 signed on 2016-07-26T16:56:10Z',
'stderr': ''
}
run_all_mock = MagicMock(return_value=cmd_out)
patches = {
'cmd.run_all': run_all_mock,
'pkg_resource.parse_targets': MagicMock(return_value=parsed_targets),
'pkg_resource.stringify': MagicMock(),
'pkg_resource.sort_pkglist': MagicMock(),
}
with patch.dict(openbsdpkg.__salt__, patches):
with patch('salt.modules.openbsdpkg.list_pkgs', ListPackages()):
added = openbsdpkg.install()
expected = {
'png': {'new': '1.6.23', 'old': ''},
'ruby': {'new': '2.3.1p1', 'old': ''}
}
self.assertDictEqual(added, expected)
expected_calls = [
call('pkg_add -x -I png--%', output_loglevel='trace', python_shell=False),
call('pkg_add -x -I ruby--%2.3', output_loglevel='trace', python_shell=False),
call('pkg_add -x -I vim--gtk2%', output_loglevel='trace', python_shell=False),
]
run_all_mock.assert_has_calls(expected_calls, any_order=True)
self.assertEqual(run_all_mock.call_count, 3)
def test_install_ruby_nonroot(self):
mock = MagicMock(return_value={'retcode': 0, 'stdout': 'stdout'})
expected = [
call('/usr/local/rvm/bin/rvm autolibs disable 2.0.0',
runas='rvm',
cwd=None),
call('/usr/local/rvm/bin/rvm install --disable-binary 2.0.0',
runas='rvm',
cwd=None)
]
with patch.dict(rvm.__salt__, {'cmd.run_all': mock}):
rvm.install_ruby('2.0.0', runas='rvm')
self.assertEqual(mock.call_args_list, expected)
def test_set_proxy_osx(self):
'''
Test to make sure we can set the proxy settings on OSX
'''
proxy.__grains__['os'] = 'Darwin'
expected = {'changes': {
'new': [
{'port': '3128',
'server': '192.168.0.1',
'service': 'http',
'user': '******'},
{'port': '3128',
'server': '192.168.0.1',
'service': 'https',
'user': '******'},
{'port': '3128',
'server': '192.168.0.1',
'service': 'ftp',
'user': '******'},
{'bypass_domains': ['salt.com', 'test.com']}]
},
'comment': 'http proxy settings updated correctly\nhttps proxy settings updated correctly\nftp proxy '
'settings updated correctly\nProxy bypass domains updated correctly\n',
'name': '192.168.0.1',
'result': True}
set_proxy_mock = MagicMock(return_value=True)
patches = {
'proxy.get_http_proxy': MagicMock(return_value={}),
'proxy.get_https_proxy': MagicMock(return_value={}),
'proxy.get_ftp_proxy': MagicMock(return_value={}),
'proxy.get_proxy_bypass': MagicMock(return_value=[]),
'proxy.set_http_proxy': set_proxy_mock,
'proxy.set_https_proxy': set_proxy_mock,
'proxy.set_ftp_proxy': set_proxy_mock,
'proxy.set_proxy_bypass': set_proxy_mock,
}
with patch.dict(proxy.__salt__, patches):
out = proxy.managed('192.168.0.1', '3128', user='******', password='******',
bypass_domains=['salt.com', 'test.com'])
calls = [
call('192.168.0.1', '3128', 'frank', 'passw0rd', 'Ethernet'),
call('192.168.0.1', '3128', 'frank', 'passw0rd', 'Ethernet'),
call('192.168.0.1', '3128', 'frank', 'passw0rd', 'Ethernet'),
call(['salt.com', 'test.com'], 'Ethernet')
]
set_proxy_mock.assert_has_calls(calls)
self.assertEqual(out, expected)
def test_set_special(self, write_cron_lines_mock):
expected_write_call = call('DUMMY_USER',
['5 0 * * * /tmp/no_script.sh\n',
'# Lines below here are managed by Salt, do not edit\n',
'@hourly echo Hi!\n'])
ret = cron.set_special('DUMMY_USER', '@hourly', 'echo Hi!')
write_cron_lines_mock.assert_has_calls(expected_write_call)
def test_list_attrs_hex(self):
'''
Test listing all of the extended attributes of a file with hex
'''
expected = {'com.test': 'first', 'com.other': 'second'}
mock = MagicMock(side_effect=['com.test\ncom.other', 'first', 'second'])
with patch.dict(xattr.__salt__, {'cmd.run': mock}):
out = xattr.list('/path/to/file', True)
calls = [
call('xattr "/path/to/file"'),
call('xattr -p -x "com.test" "/path/to/file"'),
call('xattr -p -x "com.other" "/path/to/file"')
]
mock.assert_has_calls(calls)
self.assertEqual(out, expected)
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_set_special(self, write_cron_lines_mock):
expected_write_call = call('DUMMY_USER',
['5 0 * * * /tmp/no_script.sh\n',
'# Lines below here are managed by Salt, do not edit\n',
'@hourly echo Hi!\n'])
ret = cron.set_special('DUMMY_USER', '@hourly', 'echo Hi!')
write_cron_lines_mock.assert_has_calls((expected_write_call,), any_order=True)
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_get_disk_timeout(self):
'''
Test to make sure we can get the disk timeout value
'''
mock = MagicMock()
mock.side_effect = ["Power Scheme GUID: 381b4222-f694-41f0-9685-ff5bb260df2e (Balanced)", self.query_ouput]
with patch.dict(powercfg.__salt__, {'cmd.run': mock}):
ret = powercfg.get_disk_timeout()
calls = [
call('powercfg /getactivescheme', python_shell=False),
call('powercfg /q 381b4222-f694-41f0-9685-ff5bb260df2e SUB_DISK DISKIDLE', python_shell=False)
]
mock.assert_has_calls(calls)
self.assertEqual({'ac': 30, 'dc': 15}, ret)
def test_load_name(self):
valid_eauth_load = {
'username': '******',
'show_timeout': False,
'test_password': '',
'eauth': 'pam'
}
# Test a case where the loader auth doesn't have the auth type
without_auth_type = dict(valid_eauth_load)
without_auth_type.pop('eauth')
ret = self.lauth.load_name(without_auth_type)
self.assertEqual(
ret, '',
"Did not bail when the auth loader didn't have the auth type.")
# Test a case with valid params
with patch('salt.utils.format_call') as format_call_mock:
expected_ret = call('fake_func_str', {
'username': '******',
'test_password': '',
'show_timeout': False,
'eauth': 'pam'
},
expected_extra_kws=auth.AUTH_INTERNAL_KEYWORDS)
ret = self.lauth.load_name(valid_eauth_load)
format_call_mock.assert_has_calls(expected_ret)
def test_get_rule(self):
'''
Test if it get firewall rule(s) info
'''
val = 'No rules match the specified criteria.'
mock_cmd = MagicMock(side_effect=['salt', val])
with patch.dict(win_firewall.__salt__, {'cmd.run': mock_cmd}):
self.assertDictEqual(win_firewall.get_rule(), {'all': 'salt'})
self.assertFalse(win_firewall.get_rule())
calls = [
call(['netsh', 'advfirewall', 'firewall', 'show', 'rule', 'name=all'], python_shell=False),
call(['netsh', 'advfirewall', 'firewall', 'show', 'rule', 'name=all'], python_shell=False)
]
mock_cmd.assert_has_calls(calls)
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'
}
assert zypper.mod_repo.call_count == 2
assert zypper.mod_repo.mock_calls[1] == call(
name, **expected_params)
def test_windows_7(self):
'''
Test to make sure we can get the hibernate timeout value on windows 7
'''
mock = MagicMock()
mock.side_effect = ["Power Scheme GUID: 381b4222-f694-41f0-9685-ff5bb260df2e (Balanced)", self.query_ouput]
with patch.dict(powercfg.__salt__, {'cmd.run': mock}):
with patch.dict(powercfg.__grains__, {'osrelease': '7'}):
ret = powercfg.get_hibernate_timeout()
calls = [
call('powercfg /getactivescheme', python_shell=False),
call('powercfg /q 381b4222-f694-41f0-9685-ff5bb260df2e SUB_SLEEP', python_shell=False)
]
mock.assert_has_calls(calls)
self.assertEqual({'ac': 30, 'dc': 15}, ret)
def _runner(self, expected_ret, test=False, check=False, delete=False,
delete_assertion=False):
mock_check = MagicMock(return_value=check)
mock_delete = MagicMock(return_value=delete)
with patch.dict(ipset.__opts__, {'test': test}):
with patch.dict(ipset.__salt__, {'ipset.check': mock_check,
'ipset.delete': mock_delete}):
actual_ret = ipset.absent(self.fake_name, self.fake_entries, set_name=self.fake_name)
mock_check.assert_has_calls([call(self.fake_name, e, 'ipv4') for e in self.fake_entries], any_order=True)
if delete_assertion:
expected_calls = [call(self.fake_name, e, 'ipv4', set_name=self.fake_name) for e in self.fake_entries]
if delete is not True:
expected_calls = expected_calls[:1]
mock_delete.assert_has_calls(expected_calls, any_order=True)
else:
mock_delete.assert_not_called()
self.assertDictEqual(actual_ret, expected_ret)
def test_list_attrs_hex(self):
'''
Test listing all of the extended attributes of a file with hex
'''
expected = {'com.test': 'first', 'com.other': 'second'}
mock = MagicMock(
side_effect=['com.test\ncom.other', 'first', 'second'])
with patch.dict(xattr.__salt__, {'cmd.run': mock}):
out = xattr.list('/path/to/file', True)
calls = [
call('xattr "/path/to/file"'),
call('xattr -p -x "com.test" "/path/to/file"'),
call('xattr -p -x "com.other" "/path/to/file"')
]
mock.assert_has_calls(calls)
self.assertEqual(out, expected)
def test_traversal_spec_init(self):
mock_dc_name = MagicMock()
mock_traversal_spec = MagicMock()
mock_traversal_spec_ini = MagicMock(return_value=mock_traversal_spec)
mock_get_service_instance_from_managed_object = MagicMock()
patch_traversal_spec_str = \
'salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec'
with patch(patch_traversal_spec_str, mock_traversal_spec_ini):
vmware.get_cluster(self.mock_dc, 'fake_cluster')
mock_traversal_spec_ini.assert_has_calls([
call(path='childEntity', skip=False, type=vim.Folder),
call(path='hostFolder',
skip=True,
type=vim.Datacenter,
selectSet=[mock_traversal_spec])
])
def test_user_chpass(self):
"""
Test changing a MySQL user password in mysql exec module
"""
connect_mock = MagicMock()
mysql._connect = connect_mock
with patch.dict(mysql.__salt__, {"config.option": MagicMock()}):
mysql.user_chpass("testuser", password="******")
calls = (
call()
.cursor()
.execute(
"UPDATE mysql.user SET password=PASSWORD(%(password)s) WHERE User=%(user)s AND Host = %(host)s;",
{"password": "******", "user": "******", "host": "localhost"},
),
call().cursor().execute("FLUSH PRIVILEGES;"),
)
connect_mock.assert_has_calls(calls, any_order=True)
def test_traversal_spec_init(self):
mock_dc_name = MagicMock()
mock_traversal_spec = MagicMock()
mock_traversal_spec_ini = MagicMock(return_value=mock_traversal_spec)
mock_get_service_instance_from_managed_object = MagicMock()
patch_traversal_spec_str = \
'salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec'
with patch(patch_traversal_spec_str, mock_traversal_spec_ini):
vmware.get_cluster(self.mock_dc, 'fake_cluster')
mock_traversal_spec_ini.assert_has_calls(
[call(path='childEntity',
skip=False,
type=vim.Folder),
call(path='hostFolder',
skip=True,
type=vim.Datacenter,
selectSet=[mock_traversal_spec])])
def test_get_all_proxies_windows(self):
'''
Test to make sure that we correctly get the current proxy info
on Windows
'''
proxy.__grains__['os'] = 'Windows'
results = [
{
'vdata': 'http=192.168.0.1:3128;https=192.168.0.2:3128;ftp=192.168.0.3:3128'
},
{
'vdata': 1
}
]
mock = MagicMock(side_effect=results)
expected = {
'enabled': True,
'http': {
'server': '192.168.0.1',
'port': '3128'
},
'https': {
'server': '192.168.0.2',
'port': '3128'
},
'ftp': {
'server': '192.168.0.3',
'port': '3128'
}
}
with patch.dict(proxy.__salt__, {'reg.read_value': mock}):
out = proxy.get_proxy_win()
calls = [
call('HKEY_CURRENT_USER',
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Internet Settings',
'ProxyServer'),
call('HKEY_CURRENT_USER',
'SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Internet Settings',
'ProxyEnable'),
]
mock.assert_has_calls(calls)
self.assertEqual(expected, out)
def test_user_chpass(self):
'''
Test changing a MySQL user password in mysql exec module
'''
connect_mock = MagicMock()
mysql._connect = connect_mock
with patch.dict(mysql.__salt__, {'config.option': MagicMock()}):
mysql.user_chpass('testuser', password='******')
calls = (
call().cursor().execute(
'UPDATE mysql.user SET password=PASSWORD(%(password)s) WHERE User=%(user)s AND Host = %(host)s;',
{
'password': '******',
'user': '******',
'host': 'localhost',
}),
call().cursor().execute('FLUSH PRIVILEGES;'),
)
connect_mock.assert_has_calls(calls, any_order=True)
def test_get_mors_with_properties_calls(self):
mock_get_mors_with_properties = MagicMock(return_value=[MagicMock()])
with patch(
'salt.utils.vmware.get_service_instance_from_managed_object',
MagicMock(return_value=self.mock_si)):
with patch('salt.utils.vmware.get_mors_with_properties',
mock_get_mors_with_properties):
salt.utils.vmware.get_properties_of_managed_object(
self.fake_mo_ref, self.mock_props)
mock_get_mors_with_properties.assert_has_calls(
[call(self.mock_si, vim.ManagedEntity,
container_ref=self.fake_mo_ref,
property_list=['name'],
local_properties=True),
call(self.mock_si, vim.ManagedEntity,
container_ref=self.fake_mo_ref,
property_list=self.mock_props,
local_properties=True)])
def test_set_hibernate_timeout(self):
'''
Test to make sure we can set the hibernate timeout value
'''
mock = MagicMock()
mock.side_effect = [
"Power Scheme GUID: 381b4222-f694-41f0-9685-ff5bb260df2e (Balanced)",
self.query_ouput
]
with patch.dict(powercfg.__salt__, {'cmd.run': mock}):
powercfg.set_hibernate_timeout(0, "dc")
calls = [
call('powercfg /getactivescheme', python_shell=False),
call(
'powercfg /setdcvalueindex 381b4222-f694-41f0-9685-ff5bb260df2e SUB_SLEEP HIBERNATEIDLE 0',
python_shell=False)
]
mock.assert_has_calls(calls)
def test_get_slave_status_bad_server(self):
'''
Test get_slave_status in the mysql execution module, simulating a broken server
'''
connect_mock = MagicMock(return_value=None)
mysql._connect = connect_mock
with patch.dict(mysql.__salt__, {'config.option': MagicMock()}):
rslt = mysql.get_slave_status()
connect_mock.assert_has_calls([call()])
self.assertEqual(rslt, [])
def test_get_mpkg_ids(self, get_pkg_id_mock):
'''
Test getting the ids of a mpkg file
'''
expected = ['com.apple.this', 'com.salt.other']
mock = MagicMock(
return_value='/tmp/dmg-X/file.pkg\n/tmp/dmg-X/other.pkg')
get_pkg_id_mock.side_effect = [['com.apple.this'], ['com.salt.other']]
with patch.dict(macpackage.__salt__, {'cmd.run': mock}):
out = macpackage.get_mpkg_ids('/path/to/file.mpkg')
mock.assert_called_once_with('find /path/to -name *.pkg',
python_shell=True)
calls = [call('/tmp/dmg-X/file.pkg'), call('/tmp/dmg-X/other.pkg')]
get_pkg_id_mock.assert_has_calls(calls)
self.assertEqual(out, expected)
def test_user_chpass(self):
'''
Test changing a MySQL user password in mysql exec module
'''
connect_mock = MagicMock()
mysql._connect = connect_mock
with patch.dict(mysql.__salt__, {'config.option': MagicMock()}):
mysql.user_chpass('testuser', password='******')
calls = (
call().cursor().execute(
'UPDATE mysql.user SET password=PASSWORD(%(password)s) WHERE User=%(user)s AND Host = %(host)s;',
{'password': '******',
'user': '******',
'host': 'localhost',
}
),
call().cursor().execute('FLUSH PRIVILEGES;'),
)
connect_mock.assert_has_calls(calls, any_order=True)
def _runner(self, expected_ret, test=False, check=False, add=False,
add_assertion=False):
mock_check = MagicMock(return_value=check)
mock_add = MagicMock(return_value=add)
with patch.dict(ipset.__opts__, {'test': test}):
with patch.dict(ipset.__salt__, {'ipset.check': mock_check,
'ipset.add': mock_add}):
actual_ret = ipset.present(self.fake_name, self.fake_entries, set_name=self.fake_name)
mock_check.assert_has_calls([call(self.fake_name, e, 'ipv4') for e in self.fake_entries], any_order=True)
if add_assertion:
expected_calls = [call(self.fake_name, e, 'ipv4', set_name=self.fake_name) for e in self.fake_entries]
if add is not True:
# if the add fails, then it will only get called once.
expected_calls = expected_calls[:1]
mock_add.assert_has_calls(expected_calls, any_order=True)
else:
mock_add.assert_not_called()
self.assertDictEqual(actual_ret, expected_ret)
def test_get_mors_with_properties_calls(self):
mock_get_mors_with_properties = MagicMock(return_value=[MagicMock()])
with patch(
'salt.utils.vmware.get_service_instance_from_managed_object',
MagicMock(return_value=self.mock_si)):
with patch('salt.utils.vmware.get_mors_with_properties',
mock_get_mors_with_properties):
salt.utils.vmware.get_properties_of_managed_object(
self.fake_mo_ref, self.mock_props)
mock_get_mors_with_properties.assert_has_calls(
[call(self.mock_si, vim.ManagedEntity,
container_ref=self.fake_mo_ref,
property_list=['name'],
local_properties=True),
call(self.mock_si, vim.ManagedEntity,
container_ref=self.fake_mo_ref,
property_list=self.mock_props,
local_properties=True)])
def test_get_slave_status_bad_server(self):
'''
Test get_slave_status in the mysql execution module, simulating a broken server
'''
connect_mock = MagicMock(return_value=None)
mysql._connect = connect_mock
with patch.dict(mysql.__salt__, {'config.option': MagicMock()}):
rslt = mysql.get_slave_status()
connect_mock.assert_has_calls([call()])
self.assertEqual(rslt, [])
def test_get_groups(self):
valid_eauth_load = {"username": "******", "show_timeout": False, "test_password": "", "eauth": "pam"}
with patch("salt.utils.format_call") as format_call_mock:
expected_ret = call(
"fake_groups_function_str",
{"username": "******", "test_password": "", "show_timeout": False, "eauth": "pam"},
expected_extra_kws=auth.AUTH_INTERNAL_KEYWORDS,
)
self.lauth.get_groups(valid_eauth_load)
format_call_mock.assert_has_calls((expected_ret,), any_order=True)
def test_get_mpkg_ids(self, get_pkg_id_mock):
'''
Test getting the ids of a mpkg file
'''
expected = ['com.apple.this', 'com.salt.other']
mock = MagicMock(return_value='/tmp/dmg-X/file.pkg\n/tmp/dmg-X/other.pkg')
get_pkg_id_mock.side_effect = [['com.apple.this'], ['com.salt.other']]
with patch.dict(macpackage.__salt__, {'cmd.run': mock}):
out = macpackage.get_mpkg_ids('/path/to/file.mpkg')
mock.assert_called_once_with('find /path/to -name *.pkg', python_shell=True)
calls = [
call('/tmp/dmg-X/file.pkg'),
call('/tmp/dmg-X/other.pkg')
]
get_pkg_id_mock.assert_has_calls(calls)
self.assertEqual(out, expected)
def test_get_hibernate_timeout(self):
'''
Test to make sure we can get the hibernate timeout value
'''
mock = MagicMock()
mock.side_effect = [
"Power Scheme GUID: 381b4222-f694-41f0-9685-ff5bb260df2e (Balanced)",
self.query_ouput
]
with patch.dict(powercfg.__salt__, {'cmd.run': mock}):
ret = powercfg.get_hibernate_timeout()
calls = [
call('powercfg /getactivescheme', python_shell=False),
call(
'powercfg /q 381b4222-f694-41f0-9685-ff5bb260df2e SUB_SLEEP HIBERNATEIDLE',
python_shell=False)
]
mock.assert_has_calls(calls)
self.assertEqual({'ac': 30, 'dc': 15}, ret)
def test_set_job(self):
cron.__grains__ = __grains__
with patch.dict(cron.__grains__, {'os': None}):
cron.set_job('DUMMY_USER', 1, 2, 3, 4, 5, '/bin/echo NOT A DROID',
'WERE YOU LOOKING FOR ME?')
expected_call = call('DUMMY_USER', [
'5 0 * * * /tmp/no_script.sh\n',
'# Lines below here are managed by Salt, do not edit\n',
'# WERE YOU LOOKING FOR ME?\n',
'1 2 3 4 5 /bin/echo NOT A DROID\n'
])
cron._write_cron_lines.call_args.assert_called_with(expected_call)
def test_set_job(self):
cron.__grains__ = __grains__
with patch.dict(cron.__grains__, {'os': None}):
cron.set_job('DUMMY_USER', 1, 2, 3, 4, 5,
'/bin/echo NOT A DROID',
'WERE YOU LOOKING FOR ME?')
expected_call = call('DUMMY_USER',
['5 0 * * * /tmp/no_script.sh\n',
'# Lines below here are managed by Salt, do not edit\n',
'# WERE YOU LOOKING FOR ME?\n',
'1 2 3 4 5 /bin/echo NOT A DROID\n'])
cron._write_cron_lines.call_args.assert_called_with(expected_call)
def test_get_groups(self):
valid_eauth_load = {'username': '******',
'show_timeout': False,
'test_password': '',
'eauth': 'pam'}
with patch('salt.utils.format_call') as format_call_mock:
expected_ret = call('fake_groups_function_str', {
'username': '******',
'test_password': '',
'show_timeout': False,
'eauth': 'pam'
})
self.lauth.get_groups(valid_eauth_load)
format_call_mock.assert_has_calls(expected_ret)
def test_get_groups(self):
valid_eauth_load = {'username': '******',
'show_timeout': False,
'test_password': '',
'eauth': 'pam'}
with patch('salt.utils.format_call') as format_call_mock:
expected_ret = call('fake_groups_function_str', {
'username': '******',
'test_password': '',
'show_timeout': False,
'eauth': 'pam'
}, expected_extra_kws=auth.AUTH_INTERNAL_KEYWORDS)
self.lauth.get_groups(valid_eauth_load)
format_call_mock.assert_has_calls((expected_ret,), any_order=True)
def test_get_groups(self):
valid_eauth_load = {'username': '******',
'show_timeout': False,
'test_password': '',
'eauth': 'pam'}
with patch('salt.utils.format_call') as format_call_mock:
expected_ret = call('fake_groups_function_str', {
'username': '******',
'test_password': '',
'show_timeout': False,
'eauth': 'pam'
}, expected_extra_kws=auth.AUTH_INTERNAL_KEYWORDS)
self.lauth.get_groups(valid_eauth_load)
format_call_mock.assert_has_calls((expected_ret,), any_order=True)
def test_set_hibernate_timeout_scheme(self):
'''
Test to make sure we can set the hibernate timeout value
'''
mock = MagicMock()
mock.side_effect = [self.query_ouput]
with patch.dict(powercfg.__salt__, {'cmd.run': mock}):
powercfg.set_hibernate_timeout(0, "dc", scheme="SCHEME_MIN")
calls = [
call(
'powercfg /setdcvalueindex SCHEME_MIN SUB_SLEEP HIBERNATEIDLE 0',
python_shell=False)
]
mock.assert_has_calls(calls)
