desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Test - Create an IIS virtual directory.'
| def test_create_vdir(self):
| kwargs = {'name': 'TestVdir', 'site': 'MyTestSite', 'sourcepath': 'C:\\inetpub\\vdirs\\TestVdir'}
with patch.dict(win_iis.__salt__):
with patch('os.path.isdir', MagicMock(return_value=True)):
with patch('salt.modules.win_iis._srvmgr', MagicMock(return_value={'retcode': 0})):
with patch('salt.modules.win_iis.list_vdirs', MagicMock(return_value=VDIR_LIST)):
self.assertTrue(win_iis.create_vdir(**kwargs))
|
'Test - Get configured IIS virtual directories.'
| def test_list_vdirs(self):
| vdirs = {'TestVdir': {'sourcepath': 'C:\\inetpub\\vdirs\\TestVdir'}}
with patch.dict(win_iis.__salt__):
with patch('salt.modules.win_iis._srvmgr', MagicMock(return_value=LIST_VDIRS_SRVMGR)):
self.assertEqual(win_iis.list_vdirs('MyTestSite'), vdirs)
|
'Test - Remove an IIS virtual directory.'
| def test_remove_vdir(self):
| kwargs = {'name': 'TestOtherVdir', 'site': 'MyTestSite'}
with patch.dict(win_iis.__salt__):
with patch('salt.modules.win_iis._srvmgr', MagicMock(return_value={'retcode': 0})):
with patch('salt.modules.win_iis.list_vdirs', MagicMock(return_value=VDIR_LIST)):
self.assertTrue(win_iis.remove_vdir(**kwargs))
|
'Test - Assign a certificate to an IIS binding.'
| def test_create_cert_binding(self):
| kwargs = {'name': '9988776655443322111000AAABBBCCCDDDEEEFFF', 'site': 'MyTestSite', 'hostheader': 'mytestsite.local', 'ipaddress': '*', 'port': 443}
with patch.dict(win_iis.__salt__):
with patch('salt.modules.win_iis._list_certs', MagicMock(return_value={'9988776655443322111000AAABBBCCCDDDEEEFFF': None})):
with patch('salt.modules.win_iis._srvmgr', MagicMock(return_value={'retcode': 0, 'stdout': 10})):
with patch('json.loads', MagicMock(return_value=[{'MajorVersion': 10, 'MinorVersion': 0}])):
with patch('salt.modules.win_iis.list_bindings', MagicMock(return_value=BINDING_LIST)):
with patch('salt.modules.win_iis.list_cert_bindings', MagicMock(return_value={CERT_BINDING_INFO: BINDING_LIST[CERT_BINDING_INFO]})):
self.assertTrue(win_iis.create_cert_binding(**kwargs))
|
'Test - List certificate bindings for an IIS site.'
| def test_list_cert_bindings(self):
| key = '*:443:mytestsite.local'
with patch.dict(win_iis.__salt__):
with patch('salt.modules.win_iis.list_sites', MagicMock(return_value=SITE_LIST)):
self.assertEqual(win_iis.list_cert_bindings('MyTestSite'), {key: BINDING_LIST[key]})
|
'Test - Remove a certificate from an IIS binding.'
| def test_remove_cert_binding(self):
| kwargs = {'name': 'FFFEEEDDDCCCBBBAAA0001112233445566778899', 'site': 'MyOtherTestSite', 'hostheader': 'myothertestsite.local', 'ipaddress': '*', 'port': 443}
with patch.dict(win_iis.__salt__):
with patch('salt.modules.win_iis._srvmgr', MagicMock(return_value={'retcode': 0})):
with patch('salt.modules.win_iis.list_cert_bindings', MagicMock(return_value={CERT_BINDING_INFO: BINDING_LIST[CERT_BINDING_INFO]})):
self.assertTrue(win_iis.remove_cert_binding(**kwargs))
|
'Test - Get the value of the setting for the IIS container.'
| def test_get_container_setting(self):
| kwargs = {'name': 'MyTestSite', 'container': 'AppPools', 'settings': ['managedPipelineMode']}
with patch.dict(win_iis.__salt__):
with patch('salt.modules.win_iis._srvmgr', MagicMock(return_value=CONTAINER_SETTING)):
self.assertEqual(win_iis.get_container_setting(**kwargs), {'managedPipelineMode': 'Integrated'})
|
'Test - Set the value of the setting for an IIS container.'
| def test_set_container_setting(self):
| kwargs = {'name': 'MyTestSite', 'container': 'AppPools', 'settings': {'managedPipelineMode': 'Integrated'}}
with patch.dict(win_iis.__salt__):
with patch('salt.modules.win_iis._srvmgr', MagicMock(return_value={'retcode': 0})):
with patch('salt.modules.win_iis.get_container_setting', MagicMock(return_value={'managedPipelineMode': 'Integrated'})):
self.assertTrue(win_iis.set_container_setting(**kwargs))
|
'List package upgrades
:return:'
| def test_list_upgrades(self):
| ref_out = {'stdout': get_test_data('zypper-updates.xml'), 'stderr': None, 'retcode': 0}
with patch.dict(zypper.__salt__, {'cmd.run_all': MagicMock(return_value=ref_out)}):
upgrades = zypper.list_upgrades(refresh=False)
self.assertEqual(len(upgrades), 3)
for (pkg, version) in {'SUSEConnect': '0.2.33-7.1', 'bind-utils': '9.9.6P1-35.1', 'bind-libs': '9.9.6P1-35.1'}.items():
self.assertIn(pkg, upgrades)
self.assertEqual(upgrades[pkg], version)
|
'Test Zypper caller.
:return:'
| def test_zypper_caller(self):
| class RunSniffer(object, ):
def __init__(self, stdout=None, stderr=None, retcode=None):
self.calls = list()
self._stdout = (stdout or '')
self._stderr = (stderr or '')
self._retcode = (retcode or 0)
def __call__(self, *args, **kwargs):
self.calls.append({'args': args, 'kwargs': kwargs})
return {'stdout': self._stdout, 'stderr': self._stderr, 'retcode': self._retcode}
stdout_xml_snippet = '<?xml version="1.0"?><test foo="bar"/>'
sniffer = RunSniffer(stdout=stdout_xml_snippet)
with patch.dict('salt.modules.zypper.__salt__', {'cmd.run_all': sniffer}):
self.assertEqual(zypper.__zypper__.call('foo'), stdout_xml_snippet)
self.assertEqual(len(sniffer.calls), 1)
zypper.__zypper__.call('bar')
self.assertEqual(len(sniffer.calls), 2)
self.assertEqual(sniffer.calls[0]['args'][0], ['zypper', '--non-interactive', '--no-refresh', 'foo'])
self.assertEqual(sniffer.calls[1]['args'][0], ['zypper', '--non-interactive', '--no-refresh', 'bar'])
dom = zypper.__zypper__.xml.call('xml-test')
self.assertEqual(sniffer.calls[2]['args'][0], ['zypper', '--non-interactive', '--xmlout', '--no-refresh', 'xml-test'])
self.assertEqual(dom.getElementsByTagName('test')[0].getAttribute('foo'), 'bar')
zypper.__zypper__.refreshable.call('refresh-test')
self.assertEqual(sniffer.calls[3]['args'][0], ['zypper', '--non-interactive', 'refresh-test'])
zypper.__zypper__.nolock.call('no-locking-test')
self.assertEqual(sniffer.calls[4].get('kwargs', {}).get('env', {}).get('ZYPP_READONLY_HACK'), '1')
self.assertEqual(sniffer.calls[4].get('kwargs', {}).get('env', {}).get('SALT_RUNNING'), '1')
zypper.__zypper__.call('locking-test')
self.assertEqual(sniffer.calls[5].get('kwargs', {}).get('env', {}).get('ZYPP_READONLY_HACK'), None)
self.assertEqual(sniffer.calls[5].get('kwargs', {}).get('env', {}).get('SALT_RUNNING'), '1')
stdout_xml_snippet = '<?xml version="1.0"?><stream><message type="error">Booya!</message></stream>'
sniffer = RunSniffer(stdout=stdout_xml_snippet, retcode=1)
with patch.dict('salt.modules.zypper.__salt__', {'cmd.run_all': sniffer}):
with self.assertRaisesRegex(CommandExecutionError, '^Zypper command failure: Booya!$'):
zypper.__zypper__.xml.call('crashme')
with self.assertRaisesRegex(CommandExecutionError, "^Zypper command failure: Check Zypper's logs.$"):
zypper.__zypper__.call('crashme again')
zypper.__zypper__.noraise.call('stay quiet')
self.assertEqual(zypper.__zypper__.error_msg, "Check Zypper's logs.")
|
'Test error handling in the list package upgrades.
:return:'
| def test_list_upgrades_error_handling(self):
| ref_out = {'stdout': '<?xml version=\'1.0\'?>\n<stream>\n <message type="info">Refreshing service 'container-suseconnect'.</message>\n <message type="error">Some handled zypper internal error</message>\n <message type="error">Another zypper internal error</message>\n</stream>\n ', 'stderr': '', 'retcode': 1}
with patch.dict('salt.modules.zypper.__salt__', {'cmd.run_all': MagicMock(return_value=ref_out)}):
with self.assertRaisesRegex(CommandExecutionError, '^Zypper command failure: Some handled zypper internal error\nAnother zypper internal error$'):
zypper.list_upgrades(refresh=False)
ref_out = {'retcode': 1, 'stdout': '', 'stderr': ''}
with patch.dict('salt.modules.zypper.__salt__', {'cmd.run_all': MagicMock(return_value=ref_out)}):
with self.assertRaisesRegex(CommandExecutionError, "^Zypper command failure: Check Zypper's logs.$"):
zypper.list_upgrades(refresh=False)
|
'List products test.'
| def test_list_products(self):
| for (filename, test_data) in {'zypper-products-sle12sp1.xml': {'name': ['SLES', 'SLES', 'SUSE-Manager-Proxy', 'SUSE-Manager-Server', 'sle-manager-tools-beta', 'sle-manager-tools-beta-broken-eol', 'sle-manager-tools-beta-no-eol'], 'vendor': 'SUSE LLC <https://www.suse.com/>', 'release': ['0', '0', '0', '0', '0', '0', '0'], 'productline': [None, None, None, None, None, None, 'sles'], 'eol_t': [None, 0, 1509408000, 1522454400, 1522454400, 1730332800, 1730332800], 'isbase': [False, False, False, False, False, False, True], 'installed': [False, False, False, False, False, False, True], 'registerrelease': [None, None, None, None, None, None, '123']}, 'zypper-products-sle11sp3.xml': {'name': ['SUSE-Manager-Server', 'SUSE-Manager-Server', 'SUSE-Manager-Server-Broken-EOL', 'SUSE_SLES', 'SUSE_SLES', 'SUSE_SLES', 'SUSE_SLES-SP4-migration'], 'vendor': 'SUSE LINUX Products GmbH, Nuernberg, Germany', 'release': ['1.138', '1.2', '1.2', '1.2', '1.201', '1.201', '1.4'], 'productline': [None, None, None, None, None, 'manager', 'manager'], 'eol_t': [None, 0, 0, 0, 0, 0, 0], 'isbase': [False, False, False, False, False, True, True], 'installed': [False, False, False, False, False, True, True], 'registerrelease': [None, None, None, None, None, None, '42']}}.items():
ref_out = {'retcode': 0, 'stdout': get_test_data(filename)}
with patch.dict(zypper.__salt__, {'cmd.run_all': MagicMock(return_value=ref_out)}):
products = zypper.list_products()
self.assertEqual(len(products), 7)
self.assertIn(test_data['vendor'], [product['vendor'] for product in products])
for kwd in ['name', 'isbase', 'installed', 'release', 'productline', 'eol_t', 'registerrelease']:
if six.PY3:
self.assertCountEqual(test_data[kwd], [prod.get(kwd) for prod in products])
else:
self.assertEqual(test_data[kwd], sorted([prod.get(kwd) for prod in products]))
|
'Test if refresh DB handled correctly'
| def test_refresh_db(self):
| ref_out = ["Repository 'openSUSE-Leap-42.1-LATEST' is up to date.", "Repository 'openSUSE-Leap-42.1-Update' is up to date.", "Retrieving repository 'openSUSE-Leap-42.1-Update-Non-Oss' metadata", 'Forcing building of repository cache', "Building repository 'openSUSE-Leap-42.1-Update-Non-Oss' cache ..........[done]", "Building repository 'salt-dev' cache", 'All repositories have been refreshed.']
run_out = {'stderr': '', 'stdout': '\n'.join(ref_out), 'retcode': 0}
with patch.dict(zypper.__salt__, {'cmd.run_all': MagicMock(return_value=run_out)}):
with patch.object(salt.utils.pkg, 'clear_rtag', Mock()):
result = zypper.refresh_db()
self.assertEqual(result.get('openSUSE-Leap-42.1-LATEST'), False)
self.assertEqual(result.get('openSUSE-Leap-42.1-Update'), False)
self.assertEqual(result.get('openSUSE-Leap-42.1-Update-Non-Oss'), True)
|
'Test the return information of the named package(s), installed on the system.
:return:'
| def test_info_installed(self):
| run_out = {'virgo-dummy': {'build_date': '2015-07-09T10:55:19Z', 'vendor': 'openSUSE Build Service', 'description': 'This is the Virgo dummy package used for testing SUSE Manager', 'license': 'GPL-2.0', 'build_host': 'sheep05', 'url': 'http://www.suse.com', 'build_date_time_t': 1436432119, 'relocations': '(not relocatable)', 'source_rpm': 'virgo-dummy-1.0-1.1.src.rpm', 'install_date': '2016-02-23T16:31:57Z', 'install_date_time_t': 1456241517, 'summary': 'Virgo dummy package', 'version': '1.0', 'signature': 'DSA/SHA1, Thu Jul 9 08:55:33 2015, Key ID 27fa41bd8a7c64f9', 'release': '1.1', 'group': 'Applications/System', 'arch': 'noarch', 'size': '17992'}, 'libopenssl1_0_0': {'build_date': '2015-11-04T23:20:34Z', 'vendor': 'SUSE LLC <https://www.suse.com/>', 'description': 'The OpenSSL Project is a collaborative effort.', 'license': 'OpenSSL', 'build_host': 'sheep11', 'url': 'https://www.openssl.org/', 'build_date_time_t': 1446675634, 'relocations': '(not relocatable)', 'source_rpm': 'openssl-1.0.1i-34.1.src.rpm', 'install_date': '2016-02-23T16:31:35Z', 'install_date_time_t': 1456241495, 'summary': 'Secure Sockets and Transport Layer Security', 'version': '1.0.1i', 'signature': 'RSA/SHA256, Wed Nov 4 22:21:34 2015, Key ID 70af9e8139db7c82', 'release': '34.1', 'group': 'Productivity/Networking/Security', 'packager': 'https://www.suse.com/', 'arch': 'x86_64', 'size': '2576912'}}
with patch.dict(zypper.__salt__, {'lowpkg.info': MagicMock(return_value=run_out)}):
installed = zypper.info_installed()
self.assertEqual(len(installed), 2)
for (pkg_name, pkg_info) in installed.items():
self.assertEqual(installed[pkg_name].get('source'), run_out[pkg_name]['source_rpm'])
for (pn_key, pn_val) in run_out['virgo-dummy'].items():
if (pn_key == 'source_rpm'):
continue
self.assertEqual(installed['virgo-dummy'][pn_key], pn_val)
|
'Test the return information of the named package(s), installed on the system whith non-ascii chars
:return:'
| def test_info_installed_with_non_ascii_char(self):
| run_out = {'v\xc4\xabrg\xc3\xb4': {'description': 'v\xc4\xabrg\xc3\xb4 d\xe2\x82\xac\xc5\xa1\xc3\xa7rip\xc5\xa3i\xc7\xab\xc3\xb1'}}
with patch.dict(zypper.__salt__, {'lowpkg.info': MagicMock(return_value=run_out)}):
installed = zypper.info_installed()
self.assertEqual(installed['v\xc4\xabrg\xc3\xb4']['description'], 'v\xc4\xabrg\xc3\xb4 d\xe2\x82\xac\xc5\xa1\xc3\xa7rip\xc5\xa3i\xc7\xab\xc3\xb1')
|
'Test return the information of the named package available for the system.
:return:'
| def test_info_available(self):
| test_pkgs = ['vim', 'emacs', 'python']
with patch('salt.modules.zypper.__zypper__', ZyppCallMock(return_value=get_test_data('zypper-available.txt'))):
available = zypper.info_available(refresh=False, *test_pkgs)
self.assertEqual(len(available), 3)
for (pkg_name, pkg_info) in available.items():
self.assertIn(pkg_name, test_pkgs)
self.assertEqual(available['emacs']['status'], 'up-to-date')
self.assertTrue(available['emacs']['installed'])
self.assertEqual(available['emacs']['support level'], 'Level 3')
self.assertEqual(available['emacs']['vendor'], 'SUSE LLC <https://www.suse.com/>')
self.assertEqual(available['emacs']['summary'], 'GNU Emacs Base Package')
self.assertEqual(available['vim']['status'], 'not installed')
self.assertFalse(available['vim']['installed'])
self.assertEqual(available['vim']['support level'], 'Level 3')
self.assertEqual(available['vim']['vendor'], 'SUSE LLC <https://www.suse.com/>')
self.assertEqual(available['vim']['summary'], 'Vi IMproved')
|
'Test the latest version of the named package available for upgrade or installation.
:return:'
| def test_latest_version(self):
| with patch('salt.modules.zypper.__zypper__', ZyppCallMock(return_value=get_test_data('zypper-available.txt'))):
with patch('salt.modules.zypper.refresh_db', MagicMock(return_value=True)):
self.assertEqual(zypper.latest_version('vim'), '7.4.326-2.62')
|
'Test system upgrade and dist-upgrade success.
:return:'
| def test_upgrade_success(self):
| with patch.dict(zypper.__grains__, {'osrelease_info': [12, 1]}):
with patch('salt.modules.zypper.refresh_db', MagicMock(return_value=True)):
with patch('salt.modules.zypper._systemd_scope', MagicMock(return_value=False)):
with patch('salt.modules.zypper.__zypper__.noraise.call', MagicMock()) as zypper_mock:
with patch('salt.modules.zypper.list_pkgs', MagicMock(side_effect=[{'vim': '1.1'}, {'vim': '1.2'}])):
ret = zypper.upgrade()
self.assertDictEqual(ret, {'vim': {'old': '1.1', 'new': '1.2'}})
zypper_mock.assert_any_call('update', '--auto-agree-with-licenses')
with patch('salt.modules.zypper.list_pkgs', MagicMock(side_effect=[{'vim': '1.1'}, {'vim': '1.1,1.2'}])):
ret = zypper.upgrade()
self.assertDictEqual(ret, {'vim': {'old': '1.1', 'new': '1.2'}})
zypper_mock.assert_any_call('update', '--auto-agree-with-licenses')
with patch('salt.modules.zypper.list_pkgs', MagicMock(side_effect=[{'vim': '1.1'}, {'vim': '1.2'}])):
ret = zypper.upgrade(dist_upgrade=True)
self.assertDictEqual(ret, {'vim': {'old': '1.1', 'new': '1.2'}})
zypper_mock.assert_any_call('dist-upgrade', '--auto-agree-with-licenses')
with patch('salt.modules.zypper.list_pkgs', MagicMock(side_effect=[{'vim': '1.1'}, {'vim': '1.1'}])):
ret = zypper.upgrade(dist_upgrade=True, dryrun=True)
zypper_mock.assert_any_call('dist-upgrade', '--auto-agree-with-licenses', '--dry-run')
zypper_mock.assert_any_call('dist-upgrade', '--auto-agree-with-licenses', '--dry-run', '--debug-solver')
with patch('salt.modules.zypper.list_pkgs', MagicMock(side_effect=[{'vim': '1.1'}, {'vim': '1.1'}])):
ret = zypper.upgrade(dist_upgrade=True, dryrun=True, fromrepo=['Dummy', 'Dummy2'], novendorchange=True)
zypper_mock.assert_any_call('dist-upgrade', '--auto-agree-with-licenses', '--dry-run', '--from', 'Dummy', '--from', 'Dummy2', '--no-allow-vendor-change')
zypper_mock.assert_any_call('dist-upgrade', '--auto-agree-with-licenses', '--dry-run', '--from', 'Dummy', '--from', 'Dummy2', '--no-allow-vendor-change', '--debug-solver')
with patch('salt.modules.zypper.list_pkgs', MagicMock(side_effect=[{'vim': '1.1'}, {'vim': '1.2'}])):
ret = zypper.upgrade(dist_upgrade=True, fromrepo=['Dummy', 'Dummy2'], novendorchange=True)
self.assertDictEqual(ret, {'vim': {'old': '1.1', 'new': '1.2'}})
zypper_mock.assert_any_call('dist-upgrade', '--auto-agree-with-licenses', '--from', 'Dummy', '--from', 'Dummy2', '--no-allow-vendor-change')
|
'Test kernel package upgrade success.
:return:'
| def test_upgrade_kernel(self):
| with patch.dict(zypper.__grains__, {'osrelease_info': [12, 1]}):
with patch('salt.modules.zypper.refresh_db', MagicMock(return_value=True)):
with patch('salt.modules.zypper._systemd_scope', MagicMock(return_value=False)):
with patch.dict(zypper.__salt__, {'pkg_resource.parse_targets': MagicMock(return_value=(['kernel-default'], None))}):
with patch('salt.modules.zypper.__zypper__.noraise.call', MagicMock()):
with patch('salt.modules.zypper.list_pkgs', MagicMock(side_effect=[{'kernel-default': '3.12.49-11.1'}, {'kernel-default': '3.12.49-11.1,3.12.51-60.20.2'}])):
ret = zypper.install('kernel-default', '--auto-agree-with-licenses')
self.assertDictEqual(ret, {'kernel-default': {'old': '3.12.49-11.1', 'new': '3.12.51-60.20.2'}})
|
'Test system upgrade failure.
:return:'
| def test_upgrade_failure(self):
| zypper_out = "\nLoading repository data...\nReading installed packages...\nComputing distribution upgrade...\nUse 'zypper repos' to get the list of defined repositories.\nRepository 'DUMMY' not found by its alias, number, or URI.\n"
class FailingZypperDummy(object, ):
def __init__(self):
self.stdout = zypper_out
self.stderr = ''
self.pid = 1234
self.exit_code = 555
self.noraise = MagicMock()
self.SUCCESS_EXIT_CODES = [0]
def __call__(self, *args, **kwargs):
return self
with patch.dict(zypper.__grains__, {'osrelease_info': [12, 1]}):
with patch('salt.modules.zypper.__zypper__', FailingZypperDummy()) as zypper_mock:
with patch('salt.modules.zypper.refresh_db', MagicMock(return_value=True)):
with patch('salt.modules.zypper._systemd_scope', MagicMock(return_value=False)):
zypper_mock.noraise.call = MagicMock()
with patch('salt.modules.zypper.list_pkgs', MagicMock(side_effect=[{'vim': '1.1'}, {'vim': '1.1'}])):
with self.assertRaises(CommandExecutionError) as cmd_exc:
ret = zypper.upgrade(dist_upgrade=True, fromrepo=['DUMMY'])
self.assertEqual(cmd_exc.exception.info['changes'], {})
self.assertEqual(cmd_exc.exception.info['result']['stdout'], zypper_out)
zypper_mock.noraise.call.assert_called_with('dist-upgrade', '--auto-agree-with-licenses', '--from', 'DUMMY')
|
'Test whether or not an upgrade is available for a given package.
:return:'
| def test_upgrade_available(self):
| ref_out = get_test_data('zypper-available.txt')
with patch('salt.modules.zypper.__zypper__', ZyppCallMock(return_value=get_test_data('zypper-available.txt'))):
with patch('salt.modules.zypper.refresh_db', MagicMock(return_value=True)):
for pkg_name in ['emacs', 'python']:
self.assertFalse(zypper.upgrade_available(pkg_name))
self.assertTrue(zypper.upgrade_available('vim'))
|
'Test packages listing.
:return:'
| def test_list_pkgs(self):
| def _add_data(data, key, value):
data.setdefault(key, []).append(value)
rpm_out = ['protobuf-java_|-2.6.1_|-3.1.develHead_|-noarch_|-_|-1499257756', 'yast2-ftp-server_|-3.1.8_|-8.1_|-x86_64_|-_|-1499257798', 'jose4j_|-0.4.4_|-2.1.develHead_|-noarch_|-_|-1499257756', 'apache-commons-cli_|-1.2_|-1.233_|-noarch_|-_|-1498636510', 'jakarta-commons-discovery_|-0.4_|-129.686_|-noarch_|-_|-1498636511', 'susemanager-build-keys-web_|-12.0_|-5.1.develHead_|-noarch_|-_|-1498636510']
with patch.dict(zypper.__salt__, {'cmd.run': MagicMock(return_value=os.linesep.join(rpm_out))}):
with patch.dict(zypper.__salt__, {'pkg_resource.add_pkg': _add_data}):
with patch.dict(zypper.__salt__, {'pkg_resource.format_pkg_list': pkg_resource.format_pkg_list}):
with patch.dict(zypper.__salt__, {'pkg_resource.stringify': MagicMock()}):
pkgs = zypper.list_pkgs(versions_as_list=True)
for (pkg_name, pkg_version) in {'jakarta-commons-discovery': '0.4-129.686', 'yast2-ftp-server': '3.1.8-8.1', 'protobuf-java': '2.6.1-3.1.develHead', 'susemanager-build-keys-web': '12.0-5.1.develHead', 'apache-commons-cli': '1.2-1.233', 'jose4j': '0.4.4-2.1.develHead'}.items():
self.assertTrue(pkgs.get(pkg_name))
self.assertEqual(pkgs[pkg_name], [pkg_version])
|
'Test packages listing with the attr parameter
:return:'
| def test_list_pkgs_with_attr(self):
| def _add_data(data, key, value):
data.setdefault(key, []).append(value)
rpm_out = ['protobuf-java_|-2.6.1_|-3.1.develHead_|-noarch_|-_|-1499257756', 'yast2-ftp-server_|-3.1.8_|-8.1_|-x86_64_|-_|-1499257798', 'jose4j_|-0.4.4_|-2.1.develHead_|-noarch_|-_|-1499257756', 'apache-commons-cli_|-1.2_|-1.233_|-noarch_|-_|-1498636510', 'jakarta-commons-discovery_|-0.4_|-129.686_|-noarch_|-_|-1498636511', 'susemanager-build-keys-web_|-12.0_|-5.1.develHead_|-noarch_|-_|-1498636510']
with patch.dict(zypper.__salt__, {'cmd.run': MagicMock(return_value=os.linesep.join(rpm_out))}):
with patch.dict(zypper.__salt__, {'pkg_resource.add_pkg': _add_data}):
with patch.dict(zypper.__salt__, {'pkg_resource.format_pkg_list': pkg_resource.format_pkg_list}):
with patch.dict(zypper.__salt__, {'pkg_resource.stringify': MagicMock()}):
pkgs = zypper.list_pkgs(attr=['arch', 'install_date_time_t'])
for (pkg_name, pkg_attr) in {'jakarta-commons-discovery': {'version': '0.4-129.686', 'arch': 'noarch', 'install_date_time_t': 1498636511}, 'yast2-ftp-server': {'version': '3.1.8-8.1', 'arch': 'x86_64', 'install_date_time_t': 1499257798}, 'protobuf-java': {'version': '2.6.1-3.1.develHead', 'arch': 'noarch', 'install_date_time_t': 1499257756}, 'susemanager-build-keys-web': {'version': '12.0-5.1.develHead', 'arch': 'noarch', 'install_date_time_t': 1498636510}, 'apache-commons-cli': {'version': '1.2-1.233', 'arch': 'noarch', 'install_date_time_t': 1498636510}, 'jose4j': {'version': '0.4.4-2.1.develHead', 'arch': 'noarch', 'install_date_time_t': 1499257756}}.items():
self.assertTrue(pkgs.get(pkg_name))
self.assertEqual(pkgs[pkg_name], [pkg_attr])
|
'Test advisory patches listing.
:return:'
| def test_list_patches(self):
| ref_out = {'stdout': get_test_data('zypper-patches.xml'), 'stderr': None, 'retcode': 0}
PATCHES_RET = {'SUSE-SLE-SERVER-12-SP2-2017-97': {'installed': False, 'summary': 'Recommended update for ovmf'}, 'SUSE-SLE-SERVER-12-SP2-2017-98': {'installed': True, 'summary': 'Recommended update for kmod'}, 'SUSE-SLE-SERVER-12-SP2-2017-99': {'installed': False, 'summary': 'Security update for apache2'}}
with patch.dict(zypper.__salt__, {'cmd.run_all': MagicMock(return_value=ref_out)}):
list_patches = zypper.list_patches(refresh=False)
self.assertEqual(len(list_patches), 3)
self.assertDictEqual(list_patches, PATCHES_RET)
|
'Test downloaded packages listing.
:return:'
| @patch('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/zypper/packages/foo/bar/test_package.rpm']))
def test_list_downloaded(self):
| DOWNLOADED_RET = {'test-package': {'1.0': {'path': '/var/cache/zypper/packages/foo/bar/test_package.rpm', 'size': 123456, 'creation_date_time_t': 1234567890, 'creation_date_time': '2009-02-13T23:31:30'}}}
with patch.dict(zypper.__salt__, {'lowpkg.bin_pkg_info': MagicMock(return_value={'name': 'test-package', 'version': '1.0'})}):
list_downloaded = zypper.list_downloaded()
self.assertEqual(len(list_downloaded), 1)
self.assertDictEqual(list_downloaded, DOWNLOADED_RET)
|
'Test package download
:return:'
| def test_download(self):
| download_out = {'stdout': get_test_data('zypper-download.xml'), 'stderr': None, 'retcode': 0}
test_out = {'nmap': {'path': u'/var/cache/zypp/packages/SLE-12-x86_64-Pool/x86_64/nmap-6.46-1.72.x86_64.rpm', 'repository-alias': u'SLE-12-x86_64-Pool', 'repository-name': u'SLE-12-x86_64-Pool'}}
with patch.dict(zypper.__salt__, {'cmd.run_all': MagicMock(return_value=download_out)}):
with patch.dict(zypper.__salt__, {'lowpkg.checksum': MagicMock(return_value=True)}):
self.assertEqual(zypper.download('nmap'), test_out)
test_out['_error'] = 'The following package(s) failed to download: foo'
self.assertEqual(zypper.download('nmap', 'foo'), test_out)
|
'Test a package installation with downloadonly=True.
:return:'
| @patch('salt.modules.zypper._systemd_scope', MagicMock(return_value=False))
@patch('salt.modules.zypper.list_downloaded', MagicMock(side_effect=[{}, {'vim': {'1.1': {'path': '/foo/bar/test.rpm', 'size': 1234, 'creation_date_time_t': 1234567890, 'creation_date_time': '2009-02-13T23:31:30'}}}]))
def test_install_with_downloadonly(self):
| with patch.dict(zypper.__salt__, {'pkg_resource.parse_targets': MagicMock(return_value=({'vim': None}, 'repository'))}):
with patch('salt.modules.zypper.__zypper__.noraise.call', MagicMock()) as zypper_mock:
ret = zypper.install(pkgs=['vim'], downloadonly=True)
zypper_mock.assert_called_once_with('--no-refresh', 'install', '--name', '--auto-agree-with-licenses', '--download-only', 'vim')
self.assertDictEqual(ret, {'vim': {'new': {'1.1': {'path': '/foo/bar/test.rpm', 'size': 1234, 'creation_date_time_t': 1234567890, 'creation_date_time': '2009-02-13T23:31:30'}}, 'old': ''}})
|
'Test a package installation with downloadonly=True when package is already downloaded.
:return:'
| @patch('salt.modules.zypper._systemd_scope', MagicMock(return_value=False))
@patch('salt.modules.zypper.list_downloaded', MagicMock(return_value={'vim': {'1.1': {'path': '/foo/bar/test.rpm', 'size': 1234, 'creation_date_time_t': 1234567890, 'creation_date_time': '2017-01-01T11:00:00'}}}))
def test_install_with_downloadonly_already_downloaded(self):
| with patch.dict(zypper.__salt__, {'pkg_resource.parse_targets': MagicMock(return_value=({'vim': None}, 'repository'))}):
with patch('salt.modules.zypper.__zypper__.noraise.call', MagicMock()) as zypper_mock:
ret = zypper.install(pkgs=['vim'], downloadonly=True)
zypper_mock.assert_called_once_with('--no-refresh', 'install', '--name', '--auto-agree-with-licenses', '--download-only', 'vim')
self.assertDictEqual(ret, {})
|
'Test successfully advisory patch installation.
:return:'
| @patch('salt.modules.zypper._systemd_scope', MagicMock(return_value=False))
@patch('salt.modules.zypper._get_patches', MagicMock(return_value={'SUSE-PATCH-1234': {'installed': False, 'summary': 'test'}}))
@patch('salt.modules.zypper.list_pkgs', MagicMock(side_effect=[{'vim': '1.1'}, {'vim': '1.2'}]))
def test_install_advisory_patch_ok(self):
| with patch.dict(zypper.__salt__, {'pkg_resource.parse_targets': MagicMock(return_value=({'SUSE-PATCH-1234': None}, 'advisory'))}):
with patch('salt.modules.zypper.__zypper__.noraise.call', MagicMock()) as zypper_mock:
ret = zypper.install(advisory_ids=['SUSE-PATCH-1234'])
zypper_mock.assert_called_once_with('--no-refresh', 'install', '--name', '--auto-agree-with-licenses', 'patch:SUSE-PATCH-1234')
self.assertDictEqual(ret, {'vim': {'old': '1.1', 'new': '1.2'}})
|
'Test failing advisory patch installation because patch does not exist.
:return:'
| @patch('salt.modules.zypper._systemd_scope', MagicMock(return_value=False))
@patch('salt.modules.zypper._get_patches', MagicMock(return_value={'SUSE-PATCH-1234': {'installed': False, 'summary': 'test'}}))
@patch('salt.modules.zypper.list_pkgs', MagicMock(return_value={'vim': '1.1'}))
def test_install_advisory_patch_failure(self):
| with patch.dict(zypper.__salt__, {'pkg_resource.parse_targets': MagicMock(return_value=({'SUSE-PATCH-XXX': None}, 'advisory'))}):
with patch('salt.modules.zypper.__zypper__.noraise.call', MagicMock()) as zypper_mock:
with self.assertRaisesRegex(CommandExecutionError, '^Advisory id "SUSE-PATCH-XXX" not found$'):
zypper.install(advisory_ids=['SUSE-PATCH-XXX'])
|
'Test package removal
:return:'
| def test_remove_purge(self):
| class ListPackages(object, ):
def __init__(self):
self._packages = ['vim', 'pico']
self._pkgs = {'vim': '0.18.0', 'emacs': '24.0.1', 'pico': '0.1.1'}
def __call__(self):
pkgs = self._pkgs.copy()
for target in self._packages:
if self._pkgs.get(target):
del self._pkgs[target]
return pkgs
parsed_targets = [{'vim': None, 'pico': None}, None]
cmd_out = {'retcode': 0, 'stdout': '', 'stderr': ''}
patches = {'cmd.run_all': MagicMock(return_value=cmd_out), 'pkg_resource.parse_targets': MagicMock(return_value=parsed_targets), 'pkg_resource.stringify': MagicMock(), 'config.get': MagicMock(return_value=True)}
with patch.dict(zypper.__salt__, patches):
with patch('salt.modules.zypper.list_pkgs', ListPackages()):
diff = zypper.remove(name='vim,pico')
for pkg_name in ['vim', 'pico']:
self.assertTrue(diff.get(pkg_name))
self.assertTrue(diff[pkg_name]['old'])
self.assertFalse(diff[pkg_name]['new'])
|
'Tests if repo info is properly parsed.
:return:'
| def test_repo_value_info(self):
| repos_cfg = configparser.ConfigParser()
for cfg in ['zypper-repo-1.cfg', 'zypper-repo-2.cfg']:
repos_cfg.readfp(six.moves.StringIO(get_test_data(cfg)))
for alias in repos_cfg.sections():
r_info = zypper._get_repo_info(alias, repos_cfg=repos_cfg)
self.assertEqual(type(r_info['type']), type(None))
self.assertEqual(type(r_info['enabled']), bool)
self.assertEqual(type(r_info['autorefresh']), bool)
self.assertEqual(type(r_info['baseurl']), str)
self.assertEqual(r_info['type'], None)
self.assertEqual(r_info['enabled'], (alias == 'SLE12-SP1-x86_64-Update'))
self.assertEqual(r_info['autorefresh'], (alias == 'SLE12-SP1-x86_64-Update'))
|
'Test mod_repo adds the new repo and nothing else
:return:'
| def test_repo_add_nomod_noref(self):
| 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})
self.assertEqual(zypper.__zypper__.xml.call.call_args_list, [call('ar', url, name)])
self.assertTrue((zypper.__zypper__.refreshable.xml.call.call_count == 0))
|
'Test mod_repo detects the repo already exists,
no modification was requested and no refresh requested either
:return:'
| def test_repo_noadd_nomod_noref(self):
| 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:
out = zypper.mod_repo(name, alias='new-alias')
self.assertEqual(out['comment'], 'Specified arguments did not result in modification of repo')
self.assertTrue((zypper.__zypper__.xml.call.call_count == 0))
self.assertTrue((zypper.__zypper__.refreshable.xml.call.call_count == 0))
|
'Test mod_repo detects the repo already exists,
no modification was requested and no refresh requested either
:return:'
| def test_repo_noadd_modbaseurl_ref(self):
| 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)))
|
'Test mod_repo adds the new repo and call modify to update autorefresh
:return:'
| def test_repo_add_mod_noref(self):
| 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})
self.assertEqual(zypper.__zypper__.xml.call.call_args_list, [call('ar', url, name)])
zypper.__zypper__.refreshable.xml.call.assert_called_once_with('mr', '--refresh', name)
|
'Test mod_repo detects the repository exists,
calls modify to update \'autorefresh\' but does not call refresh
:return:'
| def test_repo_noadd_mod_noref(self):
| 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})
self.assertTrue((zypper.__zypper__.xml.call.call_count == 0))
zypper.__zypper__.refreshable.xml.call.assert_called_once_with('mr', '--refresh', name)
|
'Test mod_repo adds the new repo and refreshes the repo with
`zypper --gpg-auto-import-keys refresh <repo-name>`
:return:'
| def test_repo_add_nomod_ref(self):
| 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, 'gpgautoimport': True})
self.assertEqual(zypper.__zypper__.xml.call.call_args_list, [call('ar', url, name), call('--gpg-auto-import-keys', 'refresh', name)])
self.assertTrue((zypper.__zypper__.refreshable.xml.call.call_count == 0))
|
'Test mod_repo detects the repo already exists,
has nothing to modify and refreshes the repo with
`zypper --gpg-auto-import-keys refresh <repo-name>`
:return:'
| def test_repo_noadd_nomod_ref(self):
| 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, 'gpgautoimport': True})
self.assertEqual(zypper.__zypper__.xml.call.call_args_list, [call('--gpg-auto-import-keys', 'refresh', name)])
self.assertTrue((zypper.__zypper__.refreshable.xml.call.call_count == 0))
|
'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:'
| def test_repo_add_mod_ref(self):
| 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)
|
'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:'
| def test_repo_noadd_mod_ref(self):
| 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)
|
'Test wildcard to query match all pattern
:return:'
| def test_wildcard_to_query_match_all(self):
| xmldoc = '<?xml version=\'1.0\'?><stream>\n <search-result version="0.0"><solvable-list>\n <solvable status="installed" name="libzypp" kind="package" edition="16.2.4-19.5" arch="x86_64" repository="SLE-12-SP2-x86_64-Pool"/>\n <solvable status="not-installed" name="libzypp" kind="srcpackage" edition="16.3.2-25.1" arch="noarch" repository="SLE-12-SP2-x86_64-Update"/>\n <solvable status="not-installed" name="libzypp" kind="srcpackage" edition="16.5.2-27.9.1" arch="noarch" repository="SLE-12-SP2-x86_64-Update"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="16.3.2-25.1" arch="x86_64" repository="SLE-12-SP2-x86_64-Update"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="16.5.2-27.9.1" arch="x86_64" repository="SLE-12-SP2-x86_64-Update"/>\n <solvable status="installed" name="libzypp" kind="package" edition="16.2.4-19.5" arch="x86_64" repository="(System Packages)"/>\n </solvable-list></search-result></stream>\n '
_zpr = MagicMock()
_zpr.nolock.xml.call = MagicMock(return_value=minidom.parseString(xmldoc))
wcard = zypper.Wildcard(_zpr)
(wcard.name, wcard.version) = ('libzypp', '*')
assert (wcard._get_scope_versions(wcard._get_available_versions()) == [u'16.2.4-19.5', u'16.3.2-25.1', u'16.5.2-27.9.1'])
|
'Test wildcard to query match multiple asterisk
:return:'
| def test_wildcard_to_query_multiple_asterisk(self):
| xmldoc = '<?xml version=\'1.0\'?><stream>\n <search-result version="0.0"><solvable-list>\n <solvable status="installed" name="libzypp" kind="package" edition="16.2.4-19.5" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="16.2.5-25.1" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="16.2.6-27.9.1" arch="x86_64" repository="foo"/>\n </solvable-list></search-result></stream>\n '
_zpr = MagicMock()
_zpr.nolock.xml.call = MagicMock(return_value=minidom.parseString(xmldoc))
wcard = zypper.Wildcard(_zpr)
(wcard.name, wcard.version) = ('libzypp', '16.2.*-2*')
assert (wcard._get_scope_versions(wcard._get_available_versions()) == [u'16.2.5-25.1', u'16.2.6-27.9.1'])
|
'Test wildcard to query match exact pattern at the end
:return:'
| def test_wildcard_to_query_exact_match_at_end(self):
| xmldoc = '<?xml version=\'1.0\'?><stream>\n <search-result version="0.0"><solvable-list>\n <solvable status="installed" name="libzypp" kind="package" edition="16.2.4-19.5" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="16.2.5-25.1" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="16.2.6-27.9.1" arch="x86_64" repository="foo"/>\n </solvable-list></search-result></stream>\n '
_zpr = MagicMock()
_zpr.nolock.xml.call = MagicMock(return_value=minidom.parseString(xmldoc))
wcard = zypper.Wildcard(_zpr)
(wcard.name, wcard.version) = ('libzypp', '16.2.5*')
assert (wcard._get_scope_versions(wcard._get_available_versions()) == [u'16.2.5-25.1'])
|
'Test wildcard to query match exact pattern at the beginning
:return:'
| def test_wildcard_to_query_exact_match_at_beginning(self):
| xmldoc = '<?xml version=\'1.0\'?><stream>\n <search-result version="0.0"><solvable-list>\n <solvable status="installed" name="libzypp" kind="package" edition="16.2.4-19.5" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="16.2.5-25.1" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="17.2.6-27.9.1" arch="x86_64" repository="foo"/>\n </solvable-list></search-result></stream>\n '
_zpr = MagicMock()
_zpr.nolock.xml.call = MagicMock(return_value=minidom.parseString(xmldoc))
wcard = zypper.Wildcard(_zpr)
(wcard.name, wcard.version) = ('libzypp', '*.1')
assert (wcard._get_scope_versions(wcard._get_available_versions()) == [u'16.2.5-25.1', u'17.2.6-27.9.1'])
|
'Test wildcard to query usage.
:return:'
| def test_wildcard_to_query_usage(self):
| xmldoc = '<?xml version=\'1.0\'?><stream>\n <search-result version="0.0"><solvable-list>\n <solvable status="installed" name="libzypp" kind="package" edition="16.2.4-19.5" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="16.2.5-25.1" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="17.2.6-27.9.1" arch="x86_64" repository="foo"/>\n </solvable-list></search-result></stream>\n '
_zpr = MagicMock()
_zpr.nolock.xml.call = MagicMock(return_value=minidom.parseString(xmldoc))
assert (zypper.Wildcard(_zpr)('libzypp', '16.2.4*') == '16.2.4-19.5')
assert (zypper.Wildcard(_zpr)('libzypp', '16.2*') == '16.2.5-25.1')
assert (zypper.Wildcard(_zpr)('libzypp', '*6-*') == '17.2.6-27.9.1')
assert (zypper.Wildcard(_zpr)('libzypp', '*.1') == '17.2.6-27.9.1')
|
'Test wildcard to query when no version has been passed on.
:return:'
| def test_wildcard_to_query_noversion(self):
| xmldoc = '<?xml version=\'1.0\'?><stream>\n <search-result version="0.0"><solvable-list>\n <solvable status="installed" name="libzypp" kind="package" edition="16.2.4-19.5" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="16.2.5-25.1" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="17.2.6-27.9.1" arch="x86_64" repository="foo"/>\n </solvable-list></search-result></stream>\n '
_zpr = MagicMock()
_zpr.nolock.xml.call = MagicMock(return_value=minidom.parseString(xmldoc))
assert (zypper.Wildcard(_zpr)('libzypp', None) is None)
|
'Test wildcard to query typecheck.
:return:'
| def test_wildcard_to_query_typecheck(self):
| xmldoc = '<?xml version=\'1.0\'?><stream>\n <search-result version="0.0"><solvable-list>\n <solvable status="installed" name="libzypp" kind="package" edition="16.2.4-19.5" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="16.2.5-25.1" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="17.2.6-27.9.1" arch="x86_64" repository="foo"/>\n </solvable-list></search-result></stream>\n '
_zpr = MagicMock()
_zpr.nolock.xml.call = MagicMock(return_value=minidom.parseString(xmldoc))
assert isinstance(zypper.Wildcard(_zpr)('libzypp', '*.1'), six.string_types)
|
'Test wildcard to query Zypper condition preservation.
:return:'
| def test_wildcard_to_query_condition_preservation(self):
| xmldoc = '<?xml version=\'1.0\'?><stream>\n <search-result version="0.0"><solvable-list>\n <solvable status="installed" name="libzypp" kind="package" edition="16.2.4-19.5" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="16.2.5-25.1" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="17.2.6-27.9.1" arch="x86_64" repository="foo"/>\n </solvable-list></search-result></stream>\n '
_zpr = MagicMock()
_zpr.nolock.xml.call = MagicMock(return_value=minidom.parseString(xmldoc))
for op in zypper.Wildcard.Z_OP:
assert (zypper.Wildcard(_zpr)('libzypp', '{0}*.1'.format(op)) == '{0}17.2.6-27.9.1'.format(op))
for op in zypper.Wildcard.Z_OP:
assert (zypper.Wildcard(_zpr)('libzypp', '16*{0}'.format(op)) == '{0}16.2.5-25.1'.format(op))
|
'Test wildcard to query unsupported operators.
:return:'
| def test_wildcard_to_query_unsupported_operators(self):
| xmldoc = '<?xml version=\'1.0\'?><stream>\n <search-result version="0.0"><solvable-list>\n <solvable status="installed" name="libzypp" kind="package" edition="16.2.4-19.5" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="16.2.5-25.1" arch="x86_64" repository="foo"/>\n <solvable status="other-version" name="libzypp" kind="package" edition="17.2.6-27.9.1" arch="x86_64" repository="foo"/>\n </solvable-list></search-result></stream>\n '
_zpr = MagicMock()
_zpr.nolock.xml.call = MagicMock(return_value=minidom.parseString(xmldoc))
with self.assertRaises(CommandExecutionError):
for op in ['>>', '==', '<<', '+']:
zypper.Wildcard(_zpr)('libzypp', '{0}*.1'.format(op))
|
'Test - Get the sysServices types that can be configured.'
| def test_get_agent_service_types(self):
| with patch.dict(win_snmp.__salt__):
self.assertIsInstance(win_snmp.get_agent_service_types(), list)
|
'Test - Get the permission types that can be configured for communities.'
| def test_get_permission_types(self):
| with patch.dict(win_snmp.__salt__):
self.assertIsInstance(win_snmp.get_permission_types(), list)
|
'Test - Determine whether the host is configured to send authentication traps.'
| def test_get_auth_traps_enabled(self):
| mock_value = MagicMock(return_value={'vdata': 1})
with patch.dict(win_snmp.__salt__, {'reg.read_value': mock_value}):
self.assertTrue(win_snmp.get_auth_traps_enabled())
|
'Test - Manage the sending of authentication traps.'
| def test_set_auth_traps_enabled(self):
| mock_value = MagicMock(return_value=True)
kwargs = {'status': True}
with patch.dict(win_snmp.__salt__, {'reg.set_value': mock_value}):
with patch('salt.modules.win_snmp.get_auth_traps_enabled', MagicMock(return_value=True)):
self.assertTrue(win_snmp.set_auth_traps_enabled(**kwargs))
|
'Test - Get the current accepted SNMP community names and their permissions.'
| def test_get_community_names(self):
| mock_value = MagicMock(return_value=[{'vdata': 16, 'vname': 'TestCommunity'}])
with patch.dict(win_snmp.__salt__, {'reg.list_values': mock_value}):
self.assertEqual(win_snmp.get_community_names(), COMMUNITY_NAMES)
|
'Test - Manage the SNMP accepted community names and their permissions.'
| def test_set_community_names(self):
| mock_value = MagicMock(return_value=True)
kwargs = {'communities': COMMUNITY_NAMES}
with patch.dict(win_snmp.__salt__, {'reg.set_value': mock_value}):
with patch('salt.modules.win_snmp.get_community_names', MagicMock(return_value=COMMUNITY_NAMES)):
self.assertTrue(win_snmp.set_community_names(**kwargs))
|
'Test for Starts service via daemontools'
| def test_start(self):
| mock = MagicMock(return_value=None)
with patch.dict(daemontools.__salt__, {'file.remove': mock}):
mock = MagicMock(return_value='')
with patch.object(daemontools, '_service_path', mock):
mock = MagicMock(return_value=False)
with patch.dict(daemontools.__salt__, {'cmd.retcode': mock}):
self.assertTrue(daemontools.start('name'))
|
'Test for Stops service via daemontools'
| def test_stop(self):
| mock = MagicMock(return_value=None)
with patch.dict(daemontools.__salt__, {'file.touch': mock}):
mock = MagicMock(return_value='')
with patch.object(daemontools, '_service_path', mock):
mock = MagicMock(return_value=False)
with patch.dict(daemontools.__salt__, {'cmd.retcode': mock}):
self.assertTrue(daemontools.stop('name'))
|
'Test for Send a TERM to service via daemontools'
| def test_term(self):
| mock = MagicMock(return_value='')
with patch.object(daemontools, '_service_path', mock):
mock = MagicMock(return_value=False)
with patch.dict(daemontools.__salt__, {'cmd.retcode': mock}):
self.assertTrue(daemontools.term('name'))
|
'Test for Wrapper for term()'
| def test_reload_(self):
| mock = MagicMock(return_value=None)
with patch.object(daemontools, 'term', mock):
self.assertEqual(daemontools.reload_('name'), None)
|
'Test for Restart service via daemontools. This will stop/start service'
| def test_restart(self):
| mock = MagicMock(return_value=False)
with patch.object(daemontools, 'stop', mock):
self.assertEqual(daemontools.restart('name'), 'restart False')
|
'Test for Calls daemontools.restart() function'
| def test_full_restart(self):
| mock = MagicMock(return_value=None)
with patch.object(daemontools, 'restart', mock):
self.assertEqual(daemontools.restart('name'), None)
|
'Test for Return the status for a service via
daemontools, return pid if running'
| def test_status(self):
| with patch('re.search', MagicMock(return_value=1)):
mock = MagicMock(return_value='')
with patch.object(daemontools, '_service_path', mock):
mock = MagicMock(return_value='name')
with patch.dict(daemontools.__salt__, {'cmd.run_stdout': mock}):
self.assertEqual(daemontools.status('name'), '')
|
'Test for Returns ``True`` if the specified service
is available, otherwise returns``False``.'
| def test_available(self):
| mock = MagicMock(return_value=[])
with patch.object(daemontools, 'get_all', mock):
self.assertFalse(daemontools.available('name'))
|
'Test for The inverse of daemontools.available.'
| def test_missing(self):
| mock = MagicMock(return_value=[])
with patch.object(daemontools, 'get_all', mock):
self.assertTrue(daemontools.missing('name'))
|
'Test for Return a list of all available services'
| def test_get_all(self):
| self.assertRaises(CommandExecutionError, daemontools.get_all)
with patch.object(daemontools, 'SERVICE_DIR', 'A'):
mock = MagicMock(return_value='A')
with patch.object(os, 'listdir', mock):
self.assertEqual(daemontools.get_all(), ['A'])
|
'Test getting the serial number from a certificate'
| def test_get_serial(self):
| expected = '180720d39cd2db3244ba037417241e90'
mock = MagicMock(return_value='CertInfo\r\nCert Serial Number: 180720d39cd2db3244ba037417241e90\r\n\r\nOtherStuff')
with patch.dict(certutil.__salt__, {'cmd.run': mock}):
out = certutil.get_cert_serial('/path/to/cert.cer')
mock.assert_called_once_with('certutil.exe -silent -verify /path/to/cert.cer')
self.assertEqual(expected, out)
|
'Test getting all the serial numbers from a store'
| def test_get_serials(self):
| expected = ['180720d39cd2db3244ba037417241e90', '1768ac4e5b72bf1d0df0df118b34b959']
mock = MagicMock(return_value='CertInfo\r\n================ Certificate 0 ================\r\nSerial Number: 180720d39cd2db3244ba037417241e90\r\nOtherStuff\r\n\r\n================ Certificate 1 ================\r\nSerial Number: 1768ac4e5b72bf1d0df0df118b34b959\r\nOtherStuff')
with patch.dict(certutil.__salt__, {'cmd.run': mock}):
out = certutil.get_stored_cert_serials('TrustedPublisher')
mock.assert_called_once_with('certutil.exe -store TrustedPublisher')
self.assertEqual(expected, out)
|
'Test adding a certificate to a specific store'
| def test_add_store(self):
| cmd_mock = MagicMock(return_value='CertInfo\r\n================ Certificate 0 ================\r\nSerial Number: 180720d39cd2db3244ba037417241e90\r\nOtherStuff')
cache_mock = MagicMock(return_value='/tmp/cert.cer')
with patch.dict(certutil.__salt__, {'cmd.run': cmd_mock, 'cp.cache_file': cache_mock}):
certutil.add_store('salt://path/to/file', 'TrustedPublisher')
cmd_mock.assert_called_once_with('certutil.exe -addstore TrustedPublisher /tmp/cert.cer')
cache_mock.assert_called_once_with('salt://path/to/file', 'base')
|
'Test removing a certificate to a specific store'
| def test_del_store(self):
| with patch('salt.modules.win_certutil.get_cert_serial') as cert_serial_mock:
cmd_mock = MagicMock(return_value='CertInfo\r\n================ Certificate 0 ================\r\nSerial Number: 180720d39cd2db3244ba037417241e90\r\nOtherStuff')
cache_mock = MagicMock(return_value='/tmp/cert.cer')
cert_serial_mock.return_value = 'ABCDEF'
with patch.dict(certutil.__salt__, {'cmd.run': cmd_mock, 'cp.cache_file': cache_mock}):
certutil.del_store('salt://path/to/file', 'TrustedPublisher')
cmd_mock.assert_called_once_with('certutil.exe -delstore TrustedPublisher ABCDEF')
cache_mock.assert_called_once_with('salt://path/to/file', 'base')
|
'Test if it set Windows to use a list of NTP servers'
| def test_set_servers(self):
| mock_service = MagicMock(return_value=False)
mock_cmd = MagicMock(return_value='Failure')
with patch.dict(win_ntp.__salt__, {'service.status': mock_service, 'service.start': mock_service, 'cmd.run': mock_cmd}):
self.assertFalse(win_ntp.set_servers('pool.ntp.org'))
mock_service = MagicMock(return_value=True)
mock_cmd = MagicMock(return_value='Failure')
with patch.dict(win_ntp.__salt__, {'service.status': mock_service, 'service.start': mock_service, 'cmd.run': mock_cmd}):
self.assertFalse(win_ntp.set_servers('pool.ntp.org'))
mock_cmd = MagicMock(return_value='command completed successfully')
with patch.dict(win_ntp.__salt__, {'service.status': mock_service, 'service.start': mock_service, 'service.restart': mock_service, 'cmd.run': mock_cmd}):
self.assertTrue(win_ntp.set_servers('pool.ntp.org'))
|
'Test if it get list of configured NTP servers'
| def test_get_servers(self):
| mock_cmd = MagicMock(side_effect=['', 'NtpServer: SALT', 'NtpServer'])
with patch.dict(win_ntp.__salt__, {'cmd.run': mock_cmd}):
self.assertFalse(win_ntp.get_servers())
self.assertListEqual(win_ntp.get_servers(), ['SALT'])
self.assertFalse(win_ntp.get_servers())
|
'Mock method to return all Discoverable devices'
| @staticmethod
def discover_devices(lookup_names):
| return [['a', 'b', 'c'], ['d', 'e', 'f']]
|
'Test if return bluetooth version'
| def test_version(self):
| mock = MagicMock(return_value='5.7')
with patch.dict(bluez.__salt__, {'cmd.run': mock}):
self.assertDictEqual(bluez.version(), {'PyBluez': '<= 0.18 (Unknown, but installed)', 'Bluez': '5.7'})
|
'Test of getting address of bluetooth adapter'
| def test_address_(self):
| mock = MagicMock(return_value='hci : hci0')
with patch.dict(bluez.__salt__, {'cmd.run': mock}):
self.assertDictEqual(bluez.address_(), {'hci ': {'device': 'hci ', 'path': '/sys/class/bluetooth/hci '}})
|
'Test of getting address of bluetooth adapter'
| def test_power(self):
| mock = MagicMock(return_value={})
with patch.object(bluez, 'address_', mock):
self.assertRaises(CommandExecutionError, bluez.power, 'hci0', 'on')
mock = MagicMock(return_value={'hci0': {'device': 'hci0', 'power': 'on'}})
with patch.object(bluez, 'address_', mock):
mock = MagicMock(return_value='')
with patch.dict(bluez.__salt__, {'cmd.run': mock}):
self.assertTrue(bluez.power('hci0', 'on'))
mock = MagicMock(return_value={'hci0': {'device': 'hci0', 'power': 'on'}})
with patch.object(bluez, 'address_', mock):
mock = MagicMock(return_value='')
with patch.dict(bluez.__salt__, {'cmd.run': mock}):
self.assertFalse(bluez.power('hci0', 'off'))
|
'Test of enabling bluetooth device'
| def test_discoverable(self):
| mock = MagicMock(side_effect=[{}, {'hci0': {'device': 'hci0', 'power': 'on'}}, {'hci0': {'device': 'hci0', 'power': 'on'}}])
with patch.object(bluez, 'address_', mock):
self.assertRaises(CommandExecutionError, bluez.discoverable, 'hci0')
mock = MagicMock(return_value='UP RUNNING ISCAN')
with patch.dict(bluez.__salt__, {'cmd.run': mock}):
self.assertTrue(bluez.discoverable('hci0'))
mock = MagicMock(return_value='')
with patch.dict(bluez.__salt__, {'cmd.run': mock}):
self.assertFalse(bluez.discoverable('hci0'))
|
'Test of turning off of scanning modes'
| def test_noscan(self):
| mock = MagicMock(side_effect=[{}, {'hci0': {'device': 'hci0', 'power': 'on'}}, {'hci0': {'device': 'hci0', 'power': 'on'}}])
with patch.object(bluez, 'address_', mock):
self.assertRaises(CommandExecutionError, bluez.noscan, 'hci0')
mock = MagicMock(return_value='SCAN')
with patch.dict(bluez.__salt__, {'cmd.run': mock}):
self.assertFalse(bluez.noscan('hci0'))
mock = MagicMock(return_value='')
with patch.dict(bluez.__salt__, {'cmd.run': mock}):
self.assertTrue(bluez.noscan('hci0'))
|
'Test of scanning of bluetooth devices'
| def test_scan(self):
| self.assertListEqual(bluez.scan(), [{'a': 'b'}, {'d': 'e'}])
|
'Test of blocking specific bluetooth device'
| def test_block(self):
| mock = MagicMock(side_effect=[False, True])
with patch.object(salt.utils.validate.net, 'mac', mock):
self.assertRaises(CommandExecutionError, bluez.block, 'DE:AD:BE:EF:CA:ZE')
mock = MagicMock(return_value='')
with patch.dict(bluez.__salt__, {'cmd.run': mock}):
self.assertIsNone(bluez.block('DE:AD:BE:EF:CA:FE'))
|
'Test to unblock specific bluetooth device'
| def test_unblock(self):
| mock = MagicMock(side_effect=[False, True])
with patch.object(salt.utils.validate.net, 'mac', mock):
self.assertRaises(CommandExecutionError, bluez.block, 'DE:AD:BE:EF:CA:ZE')
mock = MagicMock(return_value='')
with patch.dict(bluez.__salt__, {'cmd.run': mock}):
self.assertIsNone(bluez.unblock('DE:AD:BE:EF:CA:FE'))
|
'Test to pair bluetooth adapter with a device'
| def test_pair(self):
| mock = MagicMock(side_effect=[False, True, True])
with patch.object(salt.utils.validate.net, 'mac', mock):
self.assertRaises(CommandExecutionError, bluez.pair, 'DE:AD:BE:EF:CA:FE', '1234')
self.assertRaises(CommandExecutionError, bluez.pair, 'DE:AD:BE:EF:CA:FE', 'abcd')
mock = MagicMock(return_value={'device': 'hci0'})
with patch.object(bluez, 'address_', mock):
mock = MagicMock(return_value='Ok')
with patch.dict(bluez.__salt__, {'cmd.run': mock}):
self.assertListEqual(bluez.pair('DE:AD:BE:EF:CA:FE', '1234'), ['Ok'])
|
'Test to unpair bluetooth adaptor with a device'
| def test_unpair(self):
| mock = MagicMock(side_effect=[False, True])
with patch.object(salt.utils.validate.net, 'mac', mock):
self.assertRaises(CommandExecutionError, bluez.unpair, 'DE:AD:BE:EF:CA:FE')
mock = MagicMock(return_value='Ok')
with patch.dict(bluez.__salt__, {'cmd.run': mock}):
self.assertListEqual(bluez.unpair('DE:AD:BE:EF:CA:FE'), ['Ok'])
|
'Test to start bluetooth service'
| def test_start(self):
| mock = MagicMock(return_value='Ok')
with patch.dict(bluez.__salt__, {'service.start': mock}):
self.assertEqual(bluez.start(), 'Ok')
|
'Test to stop bluetooth service'
| def test_stop(self):
| mock = MagicMock(return_value='Ok')
with patch.dict(bluez.__salt__, {'service.stop': mock}):
self.assertEqual(bluez.stop(), 'Ok')
|
'Mock GetLogicalDrives method'
| @staticmethod
def GetLogicalDrives():
| return 1
|
'Test if it return usage information for volumes mounted on this minion.'
| def test_usage(self):
| self.assertDictEqual(win_disk.usage(), {'A:\\': {'available': None, '1K-blocks': None, 'used': None, 'capacity': None, 'filesystem': 'A:\\'}})
|
'scenario of creating upgrading extensions with possible schema and
version specifications'
| def test_create_extension_newerthan(self):
| with patch('salt.modules.postgres.create_metadata', Mock(side_effect=[[postgres._EXTENSION_NOT_INSTALLED], [postgres._EXTENSION_INSTALLED], [postgres._EXTENSION_NOT_INSTALLED], [postgres._EXTENSION_INSTALLED], [postgres._EXTENSION_NOT_INSTALLED], [postgres._EXTENSION_NOT_INSTALLED], [postgres._EXTENSION_TO_MOVE, postgres._EXTENSION_TO_UPGRADE, postgres._EXTENSION_INSTALLED], [postgres._EXTENSION_INSTALLED], [postgres._EXTENSION_TO_MOVE, postgres._EXTENSION_INSTALLED], [postgres._EXTENSION_INSTALLED], [postgres._EXTENSION_TO_UPGRADE, postgres._EXTENSION_INSTALLED], [postgres._EXTENSION_INSTALLED], [postgres._EXTENSION_TO_UPGRADE, postgres._EXTENSION_INSTALLED], [postgres._EXTENSION_TO_UPGRADE, postgres._EXTENSION_INSTALLED], [postgres._EXTENSION_TO_MOVE, postgres._EXTENSION_INSTALLED], [postgres._EXTENSION_TO_MOVE, postgres._EXTENSION_INSTALLED]])):
with patch('salt.modules.postgres._psql_prepare_and_run', Mock(return_value=None)):
with patch('salt.modules.postgres.available_extensions', Mock(return_value={'foo': {'default_version': '1.4', 'name': 'foo'}})):
self.assertTrue(postgres.create_extension('foo'))
self.assertTrue(re.match('CREATE EXTENSION IF NOT EXISTS "foo" ;', postgres._psql_prepare_and_run.call_args[0][0][1]))
self.assertTrue(postgres.create_extension('foo', schema='a', ext_version='b', from_version='c'))
self.assertTrue(re.match('CREATE EXTENSION IF NOT EXISTS "foo" WITH SCHEMA "a" VERSION b FROM c ;', postgres._psql_prepare_and_run.call_args[0][0][1]))
self.assertFalse(postgres.create_extension('foo'))
ret = postgres.create_extension('foo', ext_version='a', schema='b')
self.assertTrue(ret)
self.assertTrue(re.match('ALTER EXTENSION "foo" SET SCHEMA "b"; ALTER EXTENSION "foo" UPDATE TO a;', postgres._psql_prepare_and_run.call_args[0][0][1]))
ret = postgres.create_extension('foo', ext_version='a', schema='b')
self.assertTrue(ret)
self.assertTrue(re.match('ALTER EXTENSION "foo" SET SCHEMA "b";', postgres._psql_prepare_and_run.call_args[0][0][1]))
ret = postgres.create_extension('foo', ext_version='a', schema='b')
self.assertTrue(ret)
self.assertTrue(re.match('ALTER EXTENSION "foo" UPDATE TO a;', postgres._psql_prepare_and_run.call_args[0][0][1]))
self.assertFalse(postgres.create_extension('foo', ext_version='a', schema='b'))
self.assertFalse(postgres.create_extension('foo', ext_version='a', schema='b'))
|
'Test language listing'
| def test_language_list(self):
| with patch('salt.modules.postgres._run_psql', Mock(return_value={'retcode': 0, 'stdout': test_list_language_csv})):
ret = postgres.language_list('testdb', user='testuser', host='testhost', port='testport', password='foo')
self.assertDictEqual(ret, {'c': 'c', 'internal': 'internal', 'plpgsql': 'plpgsql', 'sql': 'sql'})
|
'Test language existence check'
| def test_language_exists(self):
| with patch('salt.modules.postgres._run_psql', Mock(return_value={'retcode': 0})):
with patch('salt.modules.postgres.psql_query', Mock(return_value=[{'Name': 'internal'}, {'Name': 'c'}, {'Name': 'sql'}, {'Name': 'plpgsql'}])):
with patch('salt.modules.postgres.language_exists', Mock(return_value=True)):
ret = postgres.language_exists('sql', 'testdb')
self.assertTrue(ret)
|
'Test language creation - does not exist in db'
| def test_language_create(self):
| with patch('salt.modules.postgres._run_psql', Mock(return_value={'retcode': 0})):
with patch('salt.modules.postgres.language_exists', Mock(return_value=False)):
postgres.language_create('plpythonu', 'testdb', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
postgres._run_psql.assert_called_once_with(['/usr/bin/pgsql', '--no-align', '--no-readline', '--no-psqlrc', '--no-password', '--username', 'testuser', '--host', 'testhost', '--port', 'testport', '--dbname', 'testdb', '-c', 'CREATE LANGUAGE plpythonu'], host='testhost', port='testport', password='testpassword', user='testuser', runas='user')
|
'Test language creation - already exists in db'
| def test_language_create_exists(self):
| with patch('salt.modules.postgres.language_exists', Mock(return_value=True)):
ret = postgres.language_create('plpythonu', 'testdb', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
self.assertFalse(ret)
|
'Test language removal - exists in db'
| def test_language_remove(self):
| with patch('salt.modules.postgres._run_psql', Mock(return_value={'retcode': 0})):
with patch('salt.modules.postgres.language_exists', Mock(return_value=True)):
postgres.language_remove('plpgsql', 'testdb', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
postgres._run_psql.assert_called_once_with(['/usr/bin/pgsql', '--no-align', '--no-readline', '--no-psqlrc', '--no-password', '--username', 'testuser', '--host', 'testhost', '--port', 'testport', '--dbname', 'testdb', '-c', 'DROP LANGUAGE plpgsql'], host='testhost', port='testport', password='testpassword', user='testuser', runas='user')
|
'Test language removal - does not exist in db'
| def test_language_remove_non_exist(self):
| with patch('salt.modules.postgres.language_exists', Mock(return_value=False)):
ret = postgres.language_remove('plpgsql', 'testdb', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
self.assertFalse(ret)
|
'Test privilege listing on a table'
| def test_privileges_list_table(self):
| with patch('salt.modules.postgres._run_psql', Mock(return_value={'retcode': 0, 'stdout': test_privileges_list_table_csv})):
ret = postgres.privileges_list('awl', 'table', maintenance_db='db_name', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
expected = {'bayestest': {'INSERT': False, 'UPDATE': False, 'SELECT': False, 'DELETE': False}, 'baruwa': {'INSERT': True, 'TRUNCATE': True, 'UPDATE': True, 'TRIGGER': True, 'REFERENCES': True, 'SELECT': True, 'DELETE': True}, 'baruwatest': {'INSERT': False, 'TRUNCATE': False, 'UPDATE': False, 'TRIGGER': False, 'REFERENCES': False, 'SELECT': False, 'DELETE': False}}
self.assertDictEqual(ret, expected)
query = "COPY (SELECT relacl AS name FROM pg_catalog.pg_class c JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace WHERE nspname = 'public' AND relname = 'awl' AND relkind = 'r' ORDER BY relname) TO STDOUT WITH CSV HEADER"
postgres._run_psql.assert_called_once_with(['/usr/bin/pgsql', '--no-align', '--no-readline', '--no-psqlrc', '--no-password', '--username', 'testuser', '--host', 'testhost', '--port', 'testport', '--dbname', 'db_name', '-v', 'datestyle=ISO,MDY', '-c', query], host='testhost', port='testport', password='testpassword', user='testuser', runas='user')
|
'Test privilege listing on a group'
| def test_privileges_list_group(self):
| with patch('salt.modules.postgres._run_psql', Mock(return_value={'retcode': 0, 'stdout': test_privileges_list_group_csv})):
ret = postgres.privileges_list('admin', 'group', maintenance_db='db_name', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
expected = {'baruwa': False, 'baruwatest': False, 'baruwatest2': True}
self.assertDictEqual(ret, expected)
query = "COPY (SELECT rolname, admin_option FROM pg_catalog.pg_auth_members m JOIN pg_catalog.pg_roles r ON m.member=r.oid WHERE m.roleid IN (SELECT oid FROM pg_catalog.pg_roles WHERE rolname='admin') ORDER BY rolname) TO STDOUT WITH CSV HEADER"
postgres._run_psql.assert_called_once_with(['/usr/bin/pgsql', '--no-align', '--no-readline', '--no-psqlrc', '--no-password', '--username', 'testuser', '--host', 'testhost', '--port', 'testport', '--dbname', 'db_name', '-v', 'datestyle=ISO,MDY', '-c', query], host='testhost', port='testport', password='testpassword', user='testuser', runas='user')
|
'Test privilege checks on table'
| def test_has_privileges_on_table(self):
| with patch('salt.modules.postgres._run_psql', Mock(return_value={'retcode': 0, 'stdout': test_privileges_list_table_csv})):
ret = postgres.has_privileges('baruwa', 'awl', 'table', 'SELECT,INSERT', grant_option=True, maintenance_db='db_name', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
self.assertTrue(ret)
ret = postgres.has_privileges('baruwa', 'awl', 'table', 'ALL', grant_option=True, maintenance_db='db_name', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
self.assertTrue(ret)
ret = postgres.has_privileges('bayestest', 'awl', 'table', 'SELECT,INSERT,TRUNCATE', maintenance_db='db_name', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
self.assertFalse(ret)
ret = postgres.has_privileges('bayestest', 'awl', 'table', 'SELECT,INSERT', maintenance_db='db_name', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
self.assertTrue(ret)
|
'Test privilege checks on group'
| def test_has_privileges_on_group(self):
| with patch('salt.modules.postgres._run_psql', Mock(return_value={'retcode': 0, 'stdout': test_privileges_list_group_csv})):
ret = postgres.has_privileges('baruwa', 'admin', 'group', maintenance_db='db_name', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
self.assertTrue(ret)
ret = postgres.has_privileges('baruwa', 'admin', 'group', grant_option=True, maintenance_db='db_name', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
self.assertFalse(ret)
ret = postgres.has_privileges('tony', 'admin', 'group', maintenance_db='db_name', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
self.assertFalse(ret)
|
'Test granting privileges on table'
| def test_privileges_grant_table(self):
| with patch('salt.modules.postgres._run_psql', Mock(return_value={'retcode': 0})):
with patch('salt.modules.postgres.has_privileges', Mock(return_value=False)):
ret = postgres.privileges_grant('baruwa', 'awl', 'table', 'ALL', grant_option=True, maintenance_db='db_name', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
query = 'GRANT ALL ON TABLE public."awl" TO "baruwa" WITH GRANT OPTION'
postgres._run_psql.assert_called_once_with(['/usr/bin/pgsql', '--no-align', '--no-readline', '--no-psqlrc', '--no-password', '--username', 'testuser', '--host', 'testhost', '--port', 'testport', '--dbname', 'db_name', '-c', query], host='testhost', port='testport', password='testpassword', user='testuser', runas='user')
with patch('salt.modules.postgres._run_psql', Mock(return_value={'retcode': 0})):
with patch('salt.modules.postgres.has_privileges', Mock(return_value=False)):
ret = postgres.privileges_grant('baruwa', 'awl', 'table', 'ALL', maintenance_db='db_name', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
query = 'GRANT ALL ON TABLE public."awl" TO "baruwa"'
postgres._run_psql.assert_called_once_with(['/usr/bin/pgsql', '--no-align', '--no-readline', '--no-psqlrc', '--no-password', '--username', 'testuser', '--host', 'testhost', '--port', 'testport', '--dbname', 'db_name', '-c', query], host='testhost', port='testport', password='testpassword', user='testuser', runas='user')
with patch('salt.modules.postgres._run_psql', Mock(return_value={'retcode': 0})):
with patch('salt.modules.postgres.has_privileges', Mock(return_value=False)):
ret = postgres.privileges_grant('baruwa', 'ALL', 'table', 'SELECT', maintenance_db='db_name', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
query = 'GRANT SELECT ON ALL TABLES IN SCHEMA public TO "baruwa"'
postgres._run_psql.assert_called_once_with(['/usr/bin/pgsql', '--no-align', '--no-readline', '--no-psqlrc', '--no-password', '--username', 'testuser', '--host', 'testhost', '--port', 'testport', '--dbname', 'db_name', '-c', query], host='testhost', port='testport', password='testpassword', user='testuser', runas='user')
|
'Test granting privileges on group'
| def test_privileges_grant_group(self):
| with patch('salt.modules.postgres._run_psql', Mock(return_value={'retcode': 0})):
with patch('salt.modules.postgres.has_privileges', Mock(return_value=False)):
ret = postgres.privileges_grant('baruwa', 'admins', 'group', grant_option=True, maintenance_db='db_name', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
query = 'GRANT admins TO "baruwa" WITH ADMIN OPTION'
postgres._run_psql.assert_called_once_with(['/usr/bin/pgsql', '--no-align', '--no-readline', '--no-psqlrc', '--no-password', '--username', 'testuser', '--host', 'testhost', '--port', 'testport', '--dbname', 'db_name', '-c', query], host='testhost', port='testport', password='testpassword', user='testuser', runas='user')
with patch('salt.modules.postgres._run_psql', Mock(return_value={'retcode': 0})):
with patch('salt.modules.postgres.has_privileges', Mock(return_value=False)):
ret = postgres.privileges_grant('baruwa', 'admins', 'group', maintenance_db='db_name', runas='user', host='testhost', port='testport', user='testuser', password='testpassword')
query = 'GRANT admins TO "baruwa"'
postgres._run_psql.assert_called_once_with(['/usr/bin/pgsql', '--no-align', '--no-readline', '--no-psqlrc', '--no-password', '--username', 'testuser', '--host', 'testhost', '--port', 'testport', '--dbname', 'db_name', '-c', query], host='testhost', port='testport', password='testpassword', user='testuser', runas='user')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.