desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'publish.publish'
| def test_publish(self):
| ret = self.run_function('publish.publish', ['minion', 'test.ping'], f_timeout=50)
self.assertEqual(ret, {'minion': True})
ret = self.run_function('publish.publish', ['minion', 'test.kwarg'], f_arg='cheese=spam', f_timeout=50)
ret = ret['minion']
check_true = ('cheese', '__pub_arg', '__pub_fun', '__pub_id', '__pub_jid', '__pub_ret', '__pub_tgt', '__pub_tgt_type')
for name in check_true:
if (name not in ret):
print(name)
self.assertTrue((name in ret))
self.assertEqual(ret['cheese'], 'spam')
self.assertEqual(ret['__pub_arg'], [{'cheese': 'spam'}])
self.assertEqual(ret['__pub_id'], 'minion')
self.assertEqual(ret['__pub_fun'], 'test.kwarg')
|
'test publish.publish yaml args formatting'
| def test_publish_yaml_args(self):
| ret = self.run_function('publish.publish', ['minion', 'test.ping'], f_timeout=50)
self.assertEqual(ret, {'minion': True})
test_args_list = ['saltines, si', 'crackers, nein', 'cheese, indeed']
test_args = '["{args[0]}", "{args[1]}", "{args[2]}"]'.format(args=test_args_list)
ret = self.run_function('publish.publish', ['minion', 'test.arg', test_args], f_timeout=50)
ret = ret['minion']
check_true = ('__pub_arg', '__pub_fun', '__pub_id', '__pub_jid', '__pub_ret', '__pub_tgt', '__pub_tgt_type')
for name in check_true:
if (name not in ret['kwargs']):
print(name)
self.assertTrue((name in ret['kwargs']))
self.assertEqual(ret['args'], test_args_list)
self.assertEqual(ret['kwargs']['__pub_id'], 'minion')
self.assertEqual(ret['kwargs']['__pub_fun'], 'test.arg')
|
'publish.full_data'
| def test_full_data(self):
| ret = self.run_function('publish.full_data', ['minion', 'test.fib', 20], f_timeout=50)
self.assertTrue(ret)
self.assertEqual(ret['minion']['ret'][0], 6765)
|
'Verify that the pub data is making it to the minion functions'
| def test_kwarg(self):
| ret = self.run_function('publish.full_data', ['minion', 'test.kwarg'], f_arg='cheese=spam', f_timeout=50)
ret = ret['minion']['ret']
check_true = ('cheese', '__pub_arg', '__pub_fun', '__pub_id', '__pub_jid', '__pub_ret', '__pub_tgt', '__pub_tgt_type')
for name in check_true:
if (name not in ret):
print(name)
self.assertTrue((name in ret))
self.assertEqual(ret['cheese'], 'spam')
self.assertEqual(ret['__pub_arg'], [{'cheese': 'spam'}])
self.assertEqual(ret['__pub_id'], 'minion')
self.assertEqual(ret['__pub_fun'], 'test.kwarg')
ret = self.run_function('publish.full_data', ['minion', 'test.kwarg'], cheese='spam', f_timeout=50)
self.assertIn('The following keyword arguments are not valid', ret)
|
'Test bad authentication'
| def test_reject_minion(self):
| ret = self.run_function('publish.publish', ['minion', 'cmd.run', ['echo foo']], f_timeout=50)
self.assertEqual(ret, {})
|
'aliases.set_target and aliases.get_target'
| def test_set_target(self):
| set_ret = self.run_function('aliases.set_target', alias='fred', target='bob')
self.assertTrue(set_ret)
tgt_ret = self.run_function('aliases.get_target', alias='fred')
self.assertEqual(tgt_ret, 'bob')
|
'aliases.set_target and aliases.has_target'
| def test_has_target(self):
| set_ret = self.run_function('aliases.set_target', alias='fred', target='bob')
self.assertTrue(set_ret)
tgt_ret = self.run_function('aliases.has_target', alias='fred', target='bob')
self.assertTrue(tgt_ret)
|
'aliases.list_aliases'
| def test_list_aliases(self):
| set_ret = self.run_function('aliases.set_target', alias='fred', target='bob')
self.assertTrue(set_ret)
tgt_ret = self.run_function('aliases.list_aliases')
self.assertIsInstance(tgt_ret, dict)
self.assertIn('fred', tgt_ret)
|
'aliases.rm_alias'
| def test_rm_alias(self):
| set_ret = self.run_function('aliases.set_target', alias='frank', target='greg')
self.assertTrue(set_ret)
self.run_function('aliases.rm_alias', alias='frank')
tgt_ret = self.run_function('aliases.list_aliases')
self.assertIsInstance(tgt_ret, dict)
self.assertNotIn('alias=frank', tgt_ret)
|
'test.ping'
| def test_ping(self):
| self.assertTrue(self.run_function('test.ping'))
|
'test.echo'
| def test_echo(self):
| self.assertEqual(self.run_function('test.echo', ['text']), 'text')
|
'test.version'
| def test_version(self):
| self.assertEqual(self.run_function('test.version'), salt.version.__saltstack_version__.string)
|
'test.conf_test'
| def test_conf_test(self):
| self.assertEqual(self.run_function('test.conf_test'), 'baz')
|
'test.get_opts'
| def test_get_opts(self):
| opts = salt.config.minion_config(self.get_config_file_path('minion'))
self.assertEqual(self.run_function('test.get_opts')['cachedir'], opts['cachedir'])
|
'test.cross_test'
| def test_cross_test(self):
| self.assertTrue(self.run_function('test.cross_test', ['test.ping']))
|
'test.fib'
| def test_fib(self):
| self.assertEqual(self.run_function('test.fib', ['20'])[0], 6765)
|
'test.collatz'
| def test_collatz(self):
| self.assertEqual(self.run_function('test.collatz', ['40'])[0][(-1)], 2)
|
'test.outputter'
| def test_outputter(self):
| self.assertEqual(self.run_function('test.outputter', ['text']), 'text')
|
'Get current settings'
| def setUp(self):
| if (not salt.utils.platform.is_darwin()):
self.skipTest('Test only available on macOS')
if (not salt.utils.path.which('pkgutil')):
self.skipTest('Test requires pkgutil binary')
|
'Reset to original settings'
| def tearDown(self):
| self.run_function('pkgutil.forget', ['org.macports.MacPorts'])
self.run_function('file.remove', ['/opt/local'])
|
'Test pkgutil.list'
| def test_list(self):
| self.assertIsInstance(self.run_function('pkgutil.list'), list)
self.assertIn('com.apple.pkg.BaseSystemResources', self.run_function('pkgutil.list'))
|
'Test pkgutil.is_installed'
| def test_is_installed(self):
| self.assertTrue(self.run_function('pkgutil.is_installed', ['com.apple.pkg.BaseSystemResources']))
self.assertFalse(self.run_function('pkgutil.is_installed', ['spongebob']))
|
'Test pkgutil.install
Test pkgutil.forget'
| @destructiveTest
def test_install_forget(self):
| self.assertFalse(self.run_function('pkgutil.is_installed', [TEST_PKG_NAME]))
self.run_function('cp.get_url', [TEST_PKG_URL, TEST_PKG])
self.assertTrue(self.run_function('pkgutil.install', [TEST_PKG, TEST_PKG_NAME]))
self.assertIn('Unsupported scheme', self.run_function('pkgutil.install', ['ftp://test', 'spongebob']))
self.assertTrue(self.run_function('pkgutil.forget', [TEST_PKG_NAME]))
|
'Clear out the database'
| def _clear_db(self):
| self.run_function('data.clear')
|
'data.load
data.dump'
| def test_load_dump(self):
| self._clear_db()
self.assertTrue(self.run_function('data.dump', ['{"foo": "bar"}']))
self.assertEqual(self.run_function('data.load'), {'foo': 'bar'})
self._clear_db()
|
'data.get
data.update'
| def test_get_update(self):
| self._clear_db()
self.assertTrue(self.run_function('data.update', ['spam', 'eggs']))
self.assertEqual(self.run_function('data.get', ['spam']), 'eggs')
self.assertTrue(self.run_function('data.update', ['unladen', 'swallow']))
self.assertEqual(self.run_function('data.get', ['["spam", "unladen"]']), ['eggs', 'swallow'])
self._clear_db()
|
'data.update
data.cas
data.get'
| def test_cas_update(self):
| self._clear_db()
self.assertTrue(self.run_function('data.update', ['spam', 'eggs']))
self.assertTrue(self.run_function('data.cas', ['spam', 'green', 'eggs']))
self.assertEqual(self.run_function('data.get', ['spam']), 'green')
|
'Tests the installation of packages'
| def test_brew_install(self):
| try:
self.run_function('pkg.install', [ADD_PKG])
pkg_list = self.run_function('pkg.list_pkgs')
try:
self.assertIn(ADD_PKG, pkg_list)
except AssertionError:
self.run_function('pkg.remove', [ADD_PKG])
raise
except CommandExecutionError:
self.run_function('pkg.remove', [ADD_PKG])
raise
|
'Tests the removal of packages'
| def test_remove(self):
| try:
self.run_function('pkg.install', [DEL_PKG])
pkg_list = self.run_function('pkg.list_pkgs')
if (DEL_PKG not in pkg_list):
self.run_function('pkg.install', [DEL_PKG])
self.skipTest('Failed to install a package to delete')
self.run_function('pkg.remove', [DEL_PKG])
del_list = self.run_function('pkg.list_pkgs')
try:
self.assertNotIn(DEL_PKG, del_list)
except AssertionError:
raise
except CommandExecutionError:
self.run_function('pkg.remove', [DEL_PKG])
raise
|
'Test pkg.version for mac. Installs a package and then checks we can get
a version for the installed package.'
| def test_version(self):
| try:
self.run_function('pkg.install', [ADD_PKG])
pkg_list = self.run_function('pkg.list_pkgs')
version = self.run_function('pkg.version', [ADD_PKG])
try:
self.assertTrue(version, msg='version: {0} is empty, or other issue is present'.format(version))
self.assertIn(ADD_PKG, pkg_list, msg='package: {0} is not in the list of installed packages: {1}'.format(ADD_PKG, pkg_list))
self.assertIn(version, str(pkg_list[ADD_PKG]), msg='The {0} version: {1} is not listed in the pkg_list: {2}'.format(ADD_PKG, version, pkg_list[ADD_PKG]))
except AssertionError:
self.run_function('pkg.remove', [ADD_PKG])
raise
except CommandExecutionError:
self.run_function('pkg.remove', [ADD_PKG])
raise
|
'Test pkg.latest_version:
- get the latest version available
- install the package
- get the latest version available
- check that the latest version is empty after installing it'
| def test_latest_version(self):
| try:
self.run_function('pkg.remove', [ADD_PKG])
uninstalled_latest = self.run_function('pkg.latest_version', [ADD_PKG])
self.run_function('pkg.install', [ADD_PKG])
installed_latest = self.run_function('pkg.latest_version', [ADD_PKG])
version = self.run_function('pkg.version', [ADD_PKG])
try:
self.assertTrue(isinstance(uninstalled_latest, six.string_types))
self.assertEqual(installed_latest, version)
except AssertionError:
self.run_function('pkg.remove', [ADD_PKG])
raise
except CommandExecutionError:
self.run_function('pkg.remove', [ADD_PKG])
raise
|
'Integration test to ensure pkg.refresh_db works with brew'
| def test_refresh_db(self):
| refresh_brew = self.run_function('pkg.refresh_db')
self.assertTrue(refresh_brew)
|
'Test pkg.list_upgrades: data is in the form {\'name1\': \'version1\',
\'name2\': \'version2\', ... }'
| def test_list_upgrades(self):
| try:
upgrades = self.run_function('pkg.list_upgrades')
try:
self.assertTrue(isinstance(upgrades, dict))
if len(upgrades):
for name in upgrades:
self.assertTrue(isinstance(name, six.string_types))
self.assertTrue(isinstance(upgrades[name], six.string_types))
except AssertionError:
self.run_function('pkg.remove', [ADD_PKG])
raise
except CommandExecutionError:
self.run_function('pkg.remove', [ADD_PKG])
raise
|
'Test pkg.info_installed: info returned has certain fields used by
mac_brew.latest_version'
| def test_info_installed(self):
| try:
self.run_function('pkg.install', [ADD_PKG])
info = self.run_function('pkg.info_installed', [ADD_PKG])
try:
self.assertTrue((ADD_PKG in info))
self.assertTrue(('versions' in info[ADD_PKG]))
self.assertTrue(('revision' in info[ADD_PKG]))
self.assertTrue(('stable' in info[ADD_PKG]['versions']))
except AssertionError:
self.run_function('pkg.remove', [ADD_PKG])
raise
except CommandExecutionError:
self.run_function('pkg.remove', [ADD_PKG])
raise
|
'Clean up after tests'
| def tearDown(self):
| pkg_list = self.run_function('pkg.list_pkgs')
if (ADD_PKG in pkg_list):
self.run_function('pkg.remove', [ADD_PKG])
if (DEL_PKG in pkg_list):
self.run_function('pkg.remove', [DEL_PKG])
|
'Set up the ssh module tests'
| def setUp(self):
| if (not check_status()):
self.skipTest('External source, github.com is down')
super(SSHModuleTest, self).setUp()
if (not os.path.isdir(SUBSALT_DIR)):
os.makedirs(SUBSALT_DIR)
ssh_raw_path = os.path.join(FILES, 'ssh', 'raw')
with salt.utils.files.fopen(ssh_raw_path) as fd:
self.key = fd.read().strip()
|
'Tear down the ssh module tests'
| def tearDown(self):
| if os.path.isdir(SUBSALT_DIR):
shutil.rmtree(SUBSALT_DIR)
super(SSHModuleTest, self).tearDown()
del self.key
|
'test ssh.auth_keys'
| def test_auth_keys(self):
| shutil.copyfile(os.path.join(FILES, 'ssh', 'authorized_keys'), AUTHORIZED_KEYS)
ret = self.run_function('ssh.auth_keys', ['root', AUTHORIZED_KEYS])
self.assertEqual(len(list(ret.items())), 1)
key_data = list(ret.items())[0][1]
try:
self.assertEqual(key_data['comment'], 'github.com')
self.assertEqual(key_data['enc'], 'ssh-rsa')
self.assertEqual(key_data['options'], ['command="/usr/local/lib/ssh-helper"'])
self.assertEqual(key_data['fingerprint'], GITHUB_FINGERPRINT)
except AssertionError as exc:
raise AssertionError('AssertionError: {0}. Function returned: {1}'.format(exc, ret))
|
'test to make sure that bad key encoding types don\'t generate an
invalid key entry in authorized_keys'
| def test_bad_enctype(self):
| shutil.copyfile(os.path.join(FILES, 'ssh', 'authorized_badkeys'), AUTHORIZED_KEYS)
ret = self.run_function('ssh.auth_keys', ['root', AUTHORIZED_KEYS])
self.assertEqual(len(list(ret.items())), 0)
|
'Check that known host information is returned from ~/.ssh/config'
| def test_get_known_host(self):
| shutil.copyfile(os.path.join(FILES, 'ssh', 'known_hosts'), KNOWN_HOSTS)
arg = ['root', 'github.com']
kwargs = {'config': KNOWN_HOSTS}
ret = self.run_function('ssh.get_known_host', arg, **kwargs)
try:
self.assertEqual(ret['enc'], 'ssh-rsa')
self.assertEqual(ret['key'], self.key)
self.assertEqual(ret['fingerprint'], GITHUB_FINGERPRINT)
except AssertionError as exc:
raise AssertionError('AssertionError: {0}. Function returned: {1}'.format(exc, ret))
|
'Check that known host information is returned from remote host'
| def test_recv_known_host(self):
| ret = self.run_function('ssh.recv_known_host', ['github.com'])
try:
self.assertNotEqual(ret, None)
self.assertEqual(ret['enc'], 'ssh-rsa')
self.assertEqual(ret['key'], self.key)
self.assertEqual(ret['fingerprint'], GITHUB_FINGERPRINT)
except AssertionError as exc:
raise AssertionError('AssertionError: {0}. Function returned: {1}'.format(exc, ret))
|
'Check known hosts by its fingerprint. File needs to be updated'
| def test_check_known_host_add(self):
| arg = ['root', 'github.com']
kwargs = {'fingerprint': GITHUB_FINGERPRINT, 'config': KNOWN_HOSTS}
ret = self.run_function('ssh.check_known_host', arg, **kwargs)
self.assertEqual(ret, 'add')
|
'ssh.check_known_host update verification'
| def test_check_known_host_update(self):
| shutil.copyfile(os.path.join(FILES, 'ssh', 'known_hosts'), KNOWN_HOSTS)
arg = ['root', 'github.com']
kwargs = {'config': KNOWN_HOSTS}
ret = self.run_function('ssh.check_known_host', arg, **dict(kwargs, fingerprint='aa:bb:cc:dd'))
self.assertEqual(ret, 'update')
ret = self.run_function('ssh.check_known_host', arg, **dict(kwargs, key='YQ=='))
self.assertEqual(ret, 'update')
|
'Verify check_known_host_exists'
| def test_check_known_host_exists(self):
| shutil.copyfile(os.path.join(FILES, 'ssh', 'known_hosts'), KNOWN_HOSTS)
arg = ['root', 'github.com']
kwargs = {'config': KNOWN_HOSTS}
ret = self.run_function('ssh.check_known_host', arg, **dict(kwargs, fingerprint=GITHUB_FINGERPRINT))
self.assertEqual(ret, 'exists')
ret = self.run_function('ssh.check_known_host', arg, **dict(kwargs, key=self.key))
self.assertEqual(ret, 'exists')
|
'ssh.rm_known_host'
| def test_rm_known_host(self):
| shutil.copyfile(os.path.join(FILES, 'ssh', 'known_hosts'), KNOWN_HOSTS)
arg = ['root', 'github.com']
kwargs = {'config': KNOWN_HOSTS, 'key': self.key}
ret = self.run_function('ssh.check_known_host', arg, **kwargs)
self.assertEqual(ret, 'exists')
self.run_function('ssh.rm_known_host', arg, config=KNOWN_HOSTS)
ret = self.run_function('ssh.check_known_host', arg, **kwargs)
self.assertEqual(ret, 'add')
|
'ssh.set_known_host'
| def test_set_known_host(self):
| ret = self.run_function('ssh.set_known_host', ['root', 'github.com'], config=KNOWN_HOSTS)
try:
self.assertEqual(ret['status'], 'updated')
self.assertEqual(ret['old'], None)
self.assertEqual(ret['new']['fingerprint'], GITHUB_FINGERPRINT)
except AssertionError as exc:
raise AssertionError('AssertionError: {0}. Function returned: {1}'.format(exc, ret))
ret = self.run_function('ssh.get_known_host', ['root', 'github.com'], config=KNOWN_HOSTS)
try:
self.assertEqual(ret['fingerprint'], GITHUB_FINGERPRINT)
except AssertionError as exc:
raise AssertionError('AssertionError: {0}. Function returned: {1}'.format(exc, ret))
ret = self.run_function('ssh.set_known_host', ['root', 'github.com'], config=KNOWN_HOSTS)
try:
self.assertEqual(ret['status'], 'exists')
except AssertionError as exc:
raise AssertionError('AssertionError: {0}. Function returned: {1}'.format(exc, ret))
|
'Find out whether a user exists.'
| def test_user_exists(self):
| ret = self.run_function('rabbitmq.user_exists', ['null_user'])
self.assertEqual(ret, False)
|
'Clean out the hosts file'
| def __clean_hosts(self):
| shutil.copyfile(os.path.join(FILES, 'hosts'), HFN)
|
'Delete the tmp hosts file'
| def __clear_hosts(self):
| if os.path.isfile(HFN):
os.remove(HFN)
|
'Make sure the tmp hosts file is gone'
| def tearDown(self):
| self.__clear_hosts()
|
'hosts.list_hosts'
| def test_list_hosts(self):
| self.__clean_hosts()
hosts = self.run_function('hosts.list_hosts')
self.assertEqual(len(hosts), 10)
self.assertEqual(hosts['::1'], ['ip6-localhost', 'ip6-loopback'])
self.assertEqual(hosts['127.0.0.1'], ['localhost', 'myname'])
|
'hosts.list_hosts
without a hosts file'
| def test_list_hosts_nofile(self):
| if os.path.isfile(HFN):
os.remove(HFN)
hosts = self.run_function('hosts.list_hosts')
self.assertEqual(hosts, {})
|
'hosts.get_ip'
| def test_get_ip(self):
| self.__clean_hosts()
self.assertEqual(self.run_function('hosts.get_ip', ['myname']), '127.0.0.1')
self.assertEqual(self.run_function('hosts.get_ip', ['othername']), '')
self.__clear_hosts()
self.assertEqual(self.run_function('hosts.get_ip', ['othername']), '')
|
'hosts.get_alias'
| def test_get_alias(self):
| self.__clean_hosts()
self.assertEqual(self.run_function('hosts.get_alias', ['127.0.0.1']), ['localhost', 'myname'])
self.assertEqual(self.run_function('hosts.get_alias', ['127.0.0.2']), [])
self.__clear_hosts()
self.assertEqual(self.run_function('hosts.get_alias', ['127.0.0.1']), [])
|
'hosts.has_pair'
| def test_has_pair(self):
| self.__clean_hosts()
self.assertTrue(self.run_function('hosts.has_pair', ['127.0.0.1', 'myname']))
self.assertFalse(self.run_function('hosts.has_pair', ['127.0.0.1', 'othername']))
|
'hosts.set_hosts'
| def test_set_host(self):
| self.__clean_hosts()
self.assertTrue(self.run_function('hosts.set_host', ['192.168.1.123', 'newip']))
self.assertTrue(self.run_function('hosts.has_pair', ['192.168.1.123', 'newip']))
self.assertTrue(self.run_function('hosts.set_host', ['127.0.0.1', 'localhost']))
self.assertEqual(len(self.run_function('hosts.list_hosts')), 11)
self.assertFalse(self.run_function('hosts.has_pair', ['127.0.0.1', 'myname']), 'should remove second entry')
|
'hosts.add_host'
| def test_add_host(self):
| self.__clean_hosts()
self.assertTrue(self.run_function('hosts.add_host', ['192.168.1.123', 'newip']))
self.assertTrue(self.run_function('hosts.has_pair', ['192.168.1.123', 'newip']))
self.assertEqual(len(self.run_function('hosts.list_hosts')), 11)
self.assertTrue(self.run_function('hosts.add_host', ['127.0.0.1', 'othernameip']))
self.assertEqual(len(self.run_function('hosts.list_hosts')), 11)
|
'Ensure that hosts.add_host isn\'t adding duplicates and that
it\'s formatting the output correctly'
| def test_add_host_formatting(self):
| self.__clear_hosts()
with salt.utils.files.fopen(HFN, 'w'):
pass
self.assertTrue(self.run_function('hosts.add_host', ['192.168.1.3', 'host3.fqdn.com']))
self.assertTrue(self.run_function('hosts.add_host', ['192.168.1.1', 'host1.fqdn.com']))
self.assertTrue(self.run_function('hosts.add_host', ['192.168.1.1', 'host1']))
self.assertTrue(self.run_function('hosts.add_host', ['192.168.1.2', 'host2.fqdn.com']))
self.assertTrue(self.run_function('hosts.add_host', ['192.168.1.2', 'host2']))
self.assertTrue(self.run_function('hosts.add_host', ['192.168.1.2', 'oldhost2']))
self.assertTrue(self.run_function('hosts.add_host', ['192.168.1.2', 'host2-reorder']))
self.assertTrue(self.run_function('hosts.add_host', ['192.168.1.1', 'host1-reorder']))
with salt.utils.files.fopen(HFN, 'r') as fp_:
lines = fp_.read().splitlines()
self.assertEqual(lines, ['192.168.1.3 DCTB DCTB host3.fqdn.com', '192.168.1.1 DCTB DCTB host1.fqdn.com host1 host1-reorder', '192.168.1.2 DCTB DCTB host2.fqdn.com host2 oldhost2 host2-reorder'])
|
'Get current state of the test service'
| def setUp(self):
| self.SERVICE_ENABLED = self.run_function('service.enabled', [self.SERVICE_NAME])
|
'Reset the test service to the original state'
| def tearDown(self):
| if self.SERVICE_ENABLED:
self.run_function('service.start', [self.SERVICE_NAME])
else:
self.run_function('service.stop', [self.SERVICE_NAME])
|
'Test service.show'
| def test_show(self):
| service_info = self.run_function('service.show', [self.SERVICE_NAME])
self.assertIsInstance(service_info, dict)
self.assertEqual(service_info['plist']['Label'], self.SERVICE_NAME)
self.assertIn('Service not found', self.run_function('service.show', ['spongebob']))
|
'Test service.launchctl'
| def test_launchctl(self):
| self.assertTrue(self.run_function('service.launchctl', ['error', 'bootstrap', 64]))
self.assertEqual(self.run_function('service.launchctl', ['error', 'bootstrap', 64], return_stdout=True), '64: unknown error code')
self.assertIn('Failed to error service', self.run_function('service.launchctl', ['error', 'bootstrap']))
|
'Test service.list'
| def test_list(self):
| self.assertIn('PID', self.run_function('service.list'))
self.assertIn('{', self.run_function('service.list', ['com.apple.coreservicesd']))
self.assertIn('Service not found', self.run_function('service.list', ['spongebob']))
|
'Test service.enable'
| @destructiveTest
def test_enable(self):
| self.assertTrue(self.run_function('service.enable', [self.SERVICE_NAME]))
self.assertIn('Service not found', self.run_function('service.enable', ['spongebob']))
|
'Test service.disable'
| @destructiveTest
def test_disable(self):
| self.assertTrue(self.run_function('service.disable', [self.SERVICE_NAME]))
self.assertIn('Service not found', self.run_function('service.disable', ['spongebob']))
|
'Test service.start
Test service.stop
Test service.status'
| @destructiveTest
def test_start(self):
| self.assertTrue(self.run_function('service.start', [self.SERVICE_NAME]))
self.assertIn('Service not found', self.run_function('service.start', ['spongebob']))
|
'Test service.stop'
| @destructiveTest
def test_stop(self):
| self.assertTrue(self.run_function('service.stop', [self.SERVICE_NAME]))
self.assertIn('Service not found', self.run_function('service.stop', ['spongebob']))
|
'Test service.status'
| @destructiveTest
def test_status(self):
| self.assertTrue(self.run_function('service.start', [self.SERVICE_NAME]))
self.assertTrue(self.run_function('service.status', [self.SERVICE_NAME]).isdigit())
self.assertTrue(self.run_function('service.stop', [self.SERVICE_NAME]))
self.assertEqual('', self.run_function('service.status', [self.SERVICE_NAME]))
self.assertEqual('', self.run_function('service.status', ['spongebob']))
|
'Test service.available'
| def test_available(self):
| self.assertTrue(self.run_function('service.available', [self.SERVICE_NAME]))
self.assertFalse(self.run_function('service.available', ['spongebob']))
|
'Test service.missing'
| def test_missing(self):
| self.assertFalse(self.run_function('service.missing', [self.SERVICE_NAME]))
self.assertTrue(self.run_function('service.missing', ['spongebob']))
|
'Test service.enabled'
| @destructiveTest
def test_enabled(self):
| self.assertTrue(self.run_function('service.start', [self.SERVICE_NAME]))
self.assertTrue(self.run_function('service.enabled', [self.SERVICE_NAME]))
self.assertTrue(self.run_function('service.stop', [self.SERVICE_NAME]))
self.assertFalse(self.run_function('service.enabled', [self.SERVICE_NAME]))
self.assertFalse(self.run_function('service.enabled', ['spongebob']))
|
'Test service.disabled'
| @destructiveTest
def test_disabled(self):
| SERVICE_NAME = 'com.apple.nfsd'
self.assertTrue(self.run_function('service.start', [SERVICE_NAME]))
self.assertFalse(self.run_function('service.disabled', [SERVICE_NAME]))
self.assertTrue(self.run_function('service.stop', [SERVICE_NAME]))
self.assertTrue(self.run_function('service.disabled', [SERVICE_NAME]))
self.assertTrue(self.run_function('service.disabled', ['spongebob']))
|
'Test service.get_all'
| def test_get_all(self):
| services = self.run_function('service.get_all')
self.assertIsInstance(services, list)
self.assertIn(self.SERVICE_NAME, services)
|
'Test service.get_enabled'
| def test_get_enabled(self):
| services = self.run_function('service.get_enabled')
self.assertIsInstance(services, list)
self.assertIn('com.apple.coreservicesd', services)
|
'test mine.get and mine.update'
| def test_get(self):
| self.assertTrue(self.run_function('mine.update', minion_tgt='minion'))
self.assertTrue(self.run_function('mine.update', minion_tgt='sub_minion'))
self.assertTrue(self.run_function('mine.get', ['minion', 'test.ping']))
|
'test mine.send'
| def test_send(self):
| self.assertFalse(self.run_function('mine.send', ['foo.__spam_and_cheese']))
self.assertTrue(self.run_function('mine.send', ['grains.items'], minion_tgt='minion'))
self.assertTrue(self.run_function('mine.send', ['grains.items'], minion_tgt='sub_minion'))
ret = self.run_function('mine.get', ['sub_minion', 'grains.items'])
self.assertEqual(ret['sub_minion']['id'], 'sub_minion')
ret = self.run_function('mine.get', ['minion', 'grains.items'], minion_tgt='sub_minion')
self.assertEqual(ret['minion']['id'], 'minion')
|
'Test mine.flush'
| def test_mine_flush(self):
| for minion_id in ('minion', 'sub_minion'):
self.assertTrue(self.run_function('mine.send', ['grains.items'], minion_tgt=minion_id))
time.sleep(1)
for minion_id in ('minion', 'sub_minion'):
ret = self.run_function('mine.get', [minion_id, 'grains.items'], minion_tgt=minion_id)
self.assertEqual(ret[minion_id]['id'], minion_id)
self.assertTrue(self.run_function('mine.flush', minion_tgt='minion'))
ret_flushed = self.run_function('mine.get', ['*', 'grains.items'])
self.assertEqual(ret_flushed.get('minion', None), None)
self.assertEqual(ret_flushed['sub_minion']['id'], 'sub_minion')
|
'Test mine.delete'
| def test_mine_delete(self):
| self.assertTrue(self.run_function('mine.send', ['grains.items']))
self.assertTrue(self.run_function('mine.send', ['test.echo', 'foo']))
ret_grains = self.run_function('mine.get', ['minion', 'grains.items'])
self.assertEqual(ret_grains['minion']['id'], 'minion')
ret_echo = self.run_function('mine.get', ['minion', 'test.echo'])
self.assertEqual(ret_echo['minion'], 'foo')
self.assertTrue(self.run_function('mine.delete', ['grains.items']))
ret_grains_deleted = self.run_function('mine.get', ['minion', 'grains.items'])
self.assertEqual(ret_grains_deleted.get('minion', None), None)
ret_echo_stays = self.run_function('mine.get', ['minion', 'test.echo'])
self.assertEqual(ret_echo_stays['minion'], 'foo')
|
'Create test file for testing extended attributes'
| def setUp(self):
| if (not salt.utils.platform.is_darwin()):
self.skipTest('Test only available on macOS')
if (not salt.utils.path.which('xattr')):
self.skipTest('Test requires xattr binary')
self.run_function('file.touch', [TEST_FILE])
|
'Clean up test file'
| def tearDown(self):
| if os.path.exists(TEST_FILE):
os.remove(TEST_FILE)
|
'Make sure there are no attributes'
| def test_list_no_xattr(self):
| self.assertTrue(self.run_function('xattr.clear', [TEST_FILE]))
self.assertEqual(self.run_function('xattr.list', [TEST_FILE]), {})
self.assertEqual(self.run_function('xattr.list', [NO_FILE]), 'ERROR: File not found: {0}'.format(NO_FILE))
|
'Write an attribute'
| def test_write(self):
| self.assertTrue(self.run_function('xattr.clear', [TEST_FILE]))
self.assertTrue(self.run_function('xattr.write', [TEST_FILE, 'spongebob', 'squarepants']))
self.assertTrue(self.run_function('xattr.write', [TEST_FILE, 'squidward', 'plankton']))
self.assertTrue(self.run_function('xattr.write', [TEST_FILE, 'crabby', 'patty']))
self.assertEqual(self.run_function('xattr.list', [TEST_FILE]), {'spongebob': 'squarepants', 'squidward': 'plankton', 'crabby': 'patty'})
self.assertEqual(self.run_function('xattr.write', [NO_FILE, 'patrick', 'jellyfish']), 'ERROR: File not found: {0}'.format(NO_FILE))
|
'Test xattr.read'
| def test_read(self):
| self.assertTrue(self.run_function('xattr.clear', [TEST_FILE]))
self.assertTrue(self.run_function('xattr.write', [TEST_FILE, 'spongebob', 'squarepants']))
self.assertEqual(self.run_function('xattr.read', [TEST_FILE, 'spongebob']), 'squarepants')
self.assertEqual(self.run_function('xattr.read', [NO_FILE, 'spongebob']), 'ERROR: File not found: {0}'.format(NO_FILE))
self.assertEqual(self.run_function('xattr.read', [TEST_FILE, 'patrick']), 'ERROR: Attribute not found: patrick')
|
'Test xattr.delete'
| def test_delete(self):
| self.assertTrue(self.run_function('xattr.clear', [TEST_FILE]))
self.assertTrue(self.run_function('xattr.write', [TEST_FILE, 'spongebob', 'squarepants']))
self.assertTrue(self.run_function('xattr.write', [TEST_FILE, 'squidward', 'plankton']))
self.assertTrue(self.run_function('xattr.write', [TEST_FILE, 'crabby', 'patty']))
self.assertTrue(self.run_function('xattr.delete', [TEST_FILE, 'squidward']))
self.assertEqual(self.run_function('xattr.list', [TEST_FILE]), {'spongebob': 'squarepants', 'crabby': 'patty'})
self.assertEqual(self.run_function('xattr.delete', [NO_FILE, 'spongebob']), 'ERROR: File not found: {0}'.format(NO_FILE))
self.assertEqual(self.run_function('xattr.delete', [TEST_FILE, 'patrick']), 'ERROR: Attribute not found: patrick')
|
'Test xattr.clear'
| def test_clear(self):
| self.assertTrue(self.run_function('xattr.clear', [TEST_FILE]))
self.assertTrue(self.run_function('xattr.write', [TEST_FILE, 'spongebob', 'squarepants']))
self.assertTrue(self.run_function('xattr.write', [TEST_FILE, 'squidward', 'plankton']))
self.assertTrue(self.run_function('xattr.write', [TEST_FILE, 'crabby', 'patty']))
self.assertTrue(self.run_function('xattr.clear', [TEST_FILE]))
self.assertEqual(self.run_function('xattr.clear', [NO_FILE]), 'ERROR: File not found: {0}'.format(NO_FILE))
|
'Test presence of MySQL server, enforce a root password'
| @destructiveTest
def setUp(self):
| super(MysqlModuleDbTest, self).setUp()
NO_MYSQL_SERVER = True
ret1 = self.run_state('cmd.run', name=(((('mysqladmin --host="localhost" -u ' + self.user) + ' flush-privileges password "') + self.password) + '"'))
ret2 = self.run_state('cmd.run', name=(((((('mysqladmin --host="localhost" -u ' + self.user) + ' --password="') + self.password) + '" flush-privileges password "') + self.password) + '"'))
(key, value) = ret2.popitem()
if value['result']:
NO_MYSQL_SERVER = False
else:
self.skipTest('No MySQL Server running, or no root access on it.')
|
'Used in db testCase, create, check exists, check in list and removes.'
| def _db_creation_loop(self, db_name, returning_name, test_conn=False, **kwargs):
| ret = self.run_function('mysql.db_create', name=db_name, **kwargs)
self.assertEqual(True, ret, "Problem while creating db for db name: '{0}'".format(db_name))
ret = self.run_function('mysql.db_exists', name=db_name, **kwargs)
self.assertEqual(True, ret, "Problem while testing db exists for db name: '{0}'".format(db_name))
ret = self.run_function('mysql.db_list', **kwargs)
if (not isinstance(ret, list)):
raise AssertionError("Unexpected query result while retrieving databases list '{0}' for '{1}' test".format(ret, db_name))
self.assertIn(returning_name, ret, "Problem while testing presence of db name in db lists for db name: '{0}' in list '{1}'".format(db_name, ret))
if test_conn:
ret = self.run_function('mysql.query', database=db_name, query='SELECT 1', **kwargs)
if ((not isinstance(ret, dict)) or ('results' not in ret)):
raise AssertionError('Unexpected result while testing connection on database : {0}'.format(repr(db_name)))
self.assertEqual([['1']], ret['results'])
ret = self.run_function('mysql.db_remove', name=db_name, **kwargs)
self.assertEqual(True, ret, "Problem while removing db for db name: '{0}'".format(db_name))
|
'Create database, test presence, then drop db. All theses with complex names.'
| @destructiveTest
def test_database_creation_level1(self):
| db_name = 'foo 1'
self._db_creation_loop(db_name=db_name, returning_name=db_name, test_conn=True, connection_user=self.user, connection_pass=self.password)
ret = self.run_function('mysql.db_create', name='foo`2', character_set='utf8', collate='utf8_general_ci', connection_user=self.user, connection_pass=self.password)
self.assertEqual(True, ret)
ret = self.run_function('mysql.db_exists', name='foo`2', connection_user=self.user, connection_pass=self.password)
self.assertEqual(True, ret)
ret = self.run_function('mysql.db_create', name='foo`2', character_set='utf8', collate='utf8_general_ci', connection_user=self.user, connection_pass=self.password)
self.assertEqual(False, ret)
ret = self.run_function('mysql.db_create', name='foo`2', character_set='utf8', collate='utf8_general_ci', connection_user=self.user, connection_pass=self.password)
self.assertEqual(False, ret)
ret = self.run_function('mysql.db_remove', name='foo`2', connection_user=self.user, connection_pass=self.password)
self.assertEqual(True, ret)
db_name = "foo'3"
self._db_creation_loop(db_name=db_name, returning_name=db_name, test_conn=True, character_set='utf8', connection_user=self.user, connection_pass=self.password)
db_name = 'foo"4'
self._db_creation_loop(db_name=db_name, returning_name=db_name, test_conn=True, collate='utf8_general_ci', connection_user=self.user, connection_pass=self.password)
db_name = '<foo` --"5>'
self._db_creation_loop(db_name=db_name, returning_name=db_name, test_conn=True, connection_user=self.user, connection_pass=self.password)
|
'Play with the \'%\' character problems
This character should be escaped in the form \'%%\' on queries, but only
when theses queries have arguments. It is also a special character
in LIKE SQL queries. Finally it is used to indicate query arguments.'
| @destructiveTest
def test_mysql_dbname_character_percent(self):
| db_name1 = 'foo%1_'
db_name2 = 'foo%12'
ret = self.run_function('mysql.db_create', name=db_name1, character_set='utf8', collate='utf8_general_ci', connection_user=self.user, connection_pass=self.password)
self.assertEqual(True, ret)
ret = self.run_function('mysql.db_create', name=db_name2, connection_user=self.user, connection_pass=self.password)
self.assertEqual(True, ret)
ret = self.run_function('mysql.db_remove', name=db_name1, connection_user=self.user, connection_pass=self.password)
self.assertEqual(True, ret)
ret = self.run_function('mysql.db_exists', name=db_name1, connection_user=self.user, connection_pass=self.password)
self.assertEqual(False, ret)
ret = self.run_function('mysql.db_exists', name=db_name2, connection_user=self.user, connection_pass=self.password)
self.assertEqual(True, ret)
ret = self.run_function('mysql.db_remove', name=db_name2, connection_user=self.user, connection_pass=self.password)
self.assertEqual(True, ret)
|
'Test support of utf8 in database names'
| @destructiveTest
def test_database_creation_utf8(self):
| db_name_unicode = u'notam\xe9rican'
db_name_utf8 = 'notam\xc3\xa9rican'
self._db_creation_loop(db_name=db_name_utf8, returning_name=db_name_utf8, test_conn=False, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self._db_creation_loop(db_name=db_name_unicode, returning_name=db_name_utf8, test_conn=False, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
db_name_unicode = u'\u6a19\u6e96\u8a9e'
db_name_utf8 = '\xe6\xa8\x99\xe6\xba\x96\xe8\xaa\x9e'
self._db_creation_loop(db_name=db_name_utf8, returning_name=db_name_utf8, test_conn=False, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self._db_creation_loop(db_name=db_name_unicode, returning_name=db_name_utf8, test_conn=False, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
|
'Test maintenance operations on a created database'
| @destructiveTest
def test_database_maintenance(self):
| dbname = u'foo%\'-- `"\''
ret = self.run_function('mysql.db_remove', name=dbname, connection_user=self.user, connection_pass=self.password)
ret = self.run_function('mysql.db_create', name=dbname, character_set='utf8', collate='utf8_general_ci', connection_user=self.user, connection_pass=self.password)
self.assertEqual(True, ret)
ret = self.run_function('mysql.db_exists', name=dbname, connection_user=self.user, connection_pass=self.password)
self.assertEqual(True, ret)
tablenames = {'A%table "`1': 'MYISAM', "B%table '`2": 'InnoDB', 'Ctable --`3': 'MEMORY'}
for (tablename, engine) in sorted(six.iteritems(tablenames)):
create_query = 'CREATE TABLE {tblname} ( id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, data VARCHAR(100)) ENGINE={engine};'.format(tblname=mysqlmod.quote_identifier(tablename), engine=engine)
insert_query = 'INSERT INTO {tblname} (data) VALUES '.format(tblname=mysqlmod.quote_identifier(tablename))
delete_query = 'DELETE from {tblname} order by rand() limit 50;'.format(tblname=mysqlmod.quote_identifier(tablename))
for x in range(100):
insert_query += (("('foo" + str(x)) + "'),")
insert_query += "('bar');"
log.info("Adding table '{0}'".format(tablename))
ret = self.run_function('mysql.query', database=dbname, query=create_query, connection_user=self.user, connection_pass=self.password)
if ((not isinstance(ret, dict)) or ('rows affected' not in ret)):
raise AssertionError("Unexpected query result while populating test table '{0}' : '{1}'".format(tablename, ret))
self.assertEqual(ret['rows affected'], 0)
log.info("Populating table '{0}'".format(tablename))
ret = self.run_function('mysql.query', database=dbname, query=insert_query, connection_user=self.user, connection_pass=self.password)
if ((not isinstance(ret, dict)) or ('rows affected' not in ret)):
raise AssertionError("Unexpected query result while populating test table '{0}' : '{1}'".format(tablename, ret))
self.assertEqual(ret['rows affected'], 101)
log.info("Removing some rows on table'{0}'".format(tablename))
ret = self.run_function('mysql.query', database=dbname, query=delete_query, connection_user=self.user, connection_pass=self.password)
if ((not isinstance(ret, dict)) or ('rows affected' not in ret)):
raise AssertionError("Unexpected query result while removing rows on test table '{0}' : '{1}'".format(tablename, ret))
self.assertEqual(ret['rows affected'], 50)
tablename = 'A%table "`1'
ret = self.run_function('mysql.db_check', name=dbname, table=tablename, connection_user=self.user, connection_pass=self.password)
self.assertEqual(ret, [{'Table': ((dbname + '.') + tablename), 'Msg_text': 'OK', 'Msg_type': 'status', 'Op': 'check'}])
ret = self.run_function('mysql.db_repair', name=dbname, table=tablename, connection_user=self.user, connection_pass=self.password)
self.assertEqual(ret, [{'Table': ((dbname + '.') + tablename), 'Msg_text': 'OK', 'Msg_type': 'status', 'Op': 'repair'}])
ret = self.run_function('mysql.db_optimize', name=dbname, table=tablename, connection_user=self.user, connection_pass=self.password)
self.assertEqual(ret, [{'Table': ((dbname + '.') + tablename), 'Msg_text': 'OK', 'Msg_type': 'status', 'Op': 'optimize'}])
ret = self.run_function('mysql.db_check', name=dbname, connection_user=self.user, connection_pass=self.password)
expected = []
for (tablename, engine) in sorted(six.iteritems(tablenames)):
if (engine is 'MEMORY'):
expected.append([{'Table': ((dbname + '.') + tablename), 'Msg_text': "The storage engine for the table doesn't support check", 'Msg_type': 'note', 'Op': 'check'}])
else:
expected.append([{'Table': ((dbname + '.') + tablename), 'Msg_text': 'OK', 'Msg_type': 'status', 'Op': 'check'}])
self.assertEqual(ret, expected)
ret = self.run_function('mysql.db_repair', name=dbname, connection_user=self.user, connection_pass=self.password)
expected = []
for (tablename, engine) in sorted(six.iteritems(tablenames)):
if (engine is 'MYISAM'):
expected.append([{'Table': ((dbname + '.') + tablename), 'Msg_text': 'OK', 'Msg_type': 'status', 'Op': 'repair'}])
else:
expected.append([{'Table': ((dbname + '.') + tablename), 'Msg_text': "The storage engine for the table doesn't support repair", 'Msg_type': 'note', 'Op': 'repair'}])
self.assertEqual(ret, expected)
ret = self.run_function('mysql.db_optimize', name=dbname, connection_user=self.user, connection_pass=self.password)
expected = []
for (tablename, engine) in sorted(six.iteritems(tablenames)):
if (engine is 'MYISAM'):
expected.append([{'Table': ((dbname + '.') + tablename), 'Msg_text': 'OK', 'Msg_type': 'status', 'Op': 'optimize'}])
elif (engine is 'InnoDB'):
expected.append([{'Table': ((dbname + '.') + tablename), 'Msg_text': 'Table does not support optimize, doing recreate + analyze instead', 'Msg_type': 'note', 'Op': 'optimize'}, {'Table': ((dbname + '.') + tablename), 'Msg_text': 'OK', 'Msg_type': 'status', 'Op': 'optimize'}])
elif (engine is 'MEMORY'):
expected.append([{'Table': ((dbname + '.') + tablename), 'Msg_text': "The storage engine for the table doesn't support optimize", 'Msg_type': 'note', 'Op': 'optimize'}])
self.assertEqual(ret, expected)
ret = self.run_function('mysql.db_remove', name=dbname, connection_user=self.user, connection_pass=self.password)
self.assertEqual(True, ret)
|
'Test presence of MySQL server, enforce a root password'
| @destructiveTest
def setUp(self):
| super(MysqlModuleUserTest, self).setUp()
NO_MYSQL_SERVER = True
ret1 = self.run_state('cmd.run', name=(((('mysqladmin --host="localhost" -u ' + self.user) + ' flush-privileges password "') + self.password) + '"'))
ret2 = self.run_state('cmd.run', name=(((((('mysqladmin --host="localhost" -u ' + self.user) + ' --password="') + self.password) + '" flush-privileges password "') + self.password) + '"'))
(key, value) = ret2.popitem()
if value['result']:
NO_MYSQL_SERVER = False
else:
self.skipTest('No MySQL Server running, or no root access on it.')
|
'Perform some tests around creation of the given user'
| def _userCreationLoop(self, uname, host, password=None, new_password=None, new_password_hash=None, **kwargs):
| ret = self.run_function('mysql.user_remove', user=uname, host=host, **kwargs)
ret = self.run_function('mysql.user_create', user=uname, host=host, password=password, **kwargs)
self.assertEqual(True, ret, "Calling user_create on user '{0}' did not return True: {1}".format(uname, repr(ret)))
ret = self.run_function('mysql.user_create', user=uname, host=host, password=password, **kwargs)
self.assertEqual(False, ret, "Calling user_create a second time on user '{0}' did not return False: {1}".format(uname, repr(ret)))
if ((new_password is not None) or (new_password_hash is not None)):
ret = self.run_function('mysql.user_chpass', user=uname, host=host, password=new_password, password_hash=new_password_hash, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self.assertEqual(True, ret, "Calling user_chpass on user '{0}' did not return True: {1}".format(uname, repr(ret)))
|
'Internal routine to check user_info returned results'
| def _chck_userinfo(self, user, host, check_user, check_hash):
| ret = self.run_function('mysql.user_info', user=user, host=host, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
if (not isinstance(ret, dict)):
raise AssertionError("Unexpected result while retrieving user_info for '{0}'".format(user))
self.assertEqual(ret['Host'], host)
self.assertEqual(ret['Password'], check_hash)
self.assertEqual(ret['User'], check_user)
|
'Internal routine to check user_remove'
| def _chk_remove_user(self, user, host, **kwargs):
| ret = self.run_function('mysql.user_remove', user=user, host=host, **kwargs)
self.assertEqual(True, ret, "Assertion failed while removing user '{0}' on host '{1}': {2}".format(user, host, repr(ret)))
|
'Test various users creation settings'
| @destructiveTest
def test_user_management(self):
| user1 = "user '1"
user1_pwd = 'pwd`\'"1b'
user1_pwd_hash = '*4DF33B3B12E43384677050A818327877FAB2F4BA'
user2 = 'user "2\'\xe6\xa8\x99'
user2_pwd = 'user "2\'\xe6\xa8\x99b'
user2_pwd_hash = '*3A38A7B94B024B983687BB9B44FB60B7AA38FE61'
user3 = 'user "3;,?:@=&/'
user3_pwd = 'user "3;,?:@=&/'
user3_pwd_hash = '*AA3B1D4105A45D381C23A5C221C47EA349E1FD7D'
user4 = u'user":;,?:@=&/4\u6a19'
user4_utf8 = 'user":;,?:@=&/4\xe6\xa8\x99'
user4_pwd = 'user "4;,?:@=&/'
user4_pwd_hash = '*FC8EF8DBF27628E4E113359F8E7478D5CF3DD57C'
user5 = u'user ``"5'
user5_utf8 = 'user ``"5'
user5_pwd = '\xe6\xa8\x99\xe6\xa8\x99\\'
user5_pwd_hash = '*3752E65CDD8751AF8D889C62CFFC6C998B12C376'
user6 = u'user %--"6'
user6_utf8 = 'user %--"6'
user6_pwd_u = u' --\'"% SIX\u6a19b'
user6_pwd_utf8 = ' --\'"% SIX\xe6\xa8\x99b'
user6_pwd_hash = '*90AE800593E2D407CD9E28CCAFBE42D17EEA5369'
self._userCreationLoop(uname=user1, host='localhost', password='pwd`\'"1', new_password='pwd`\'"1b', connection_user=self.user, connection_pass=self.password)
ret = self.run_function('mysql.user_exists', user=user1, host='localhost', password=user1_pwd, password_hash=None, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self.assertEqual(True, ret, "Testing final user '{0}' on host '{1}' existence failed".format(user1, 'localhost'))
self._userCreationLoop(uname=user2, host='localhost', password=None, password_hash='*EEF6F854748ACF841226BB1C2422BEC70AE7F1FF', new_password_hash=user2_pwd_hash, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self._userCreationLoop(uname=user2, host='10.0.0.1', allow_passwordless=True, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self._userCreationLoop(uname=user2, host='10.0.0.2', allow_passwordless=True, unix_socket=True, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
ret = self.run_function('mysql.user_exists', user=user2, host='localhost', password=None, password_hash=user2_pwd_hash, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self.assertEqual(True, ret, "Testing final user '{0}' on host '{1}' failed".format(user2, 'localhost'))
ret = self.run_function('mysql.user_exists', user=user2, host='10.0.0.1', allow_passwordless=True, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self.assertEqual(True, ret, "Testing final user '{0}' on host '{1}' without password failed".format(user2, '10.0.0.1'))
ret = self.run_function('mysql.user_exists', user=user2, host='10.0.0.2', allow_passwordless=True, unix_socket=True, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self.assertEqual(True, ret, "Testing final user '{0}' on host '{1}' without password failed".format(user2, '10.0.0.2'))
self._userCreationLoop(uname=user3, host='localhost', password='', connection_user=self.user, connection_pass=self.password)
self._userCreationLoop(uname=user3, host='%', password='foo', new_password=user3_pwd, connection_user=self.user, connection_pass=self.password)
ret = self.run_function('mysql.user_exists', user=user3, host='localhost', password='', connection_user=self.user, connection_pass=self.password)
self.assertEqual(True, ret, "Testing final user '{0}' on host '{1}' without empty password failed".format(user3, 'localhost'))
ret = self.run_function('mysql.user_exists', user=user3, host='%', password=user3_pwd, connection_user=self.user, connection_pass=self.password)
self.assertEqual(True, ret, "Testing final user '{0}' on host '{1}' with password failed".format(user3, '%'))
self._userCreationLoop(uname=user4, host='%', password=user4_pwd, password_hash='*F3A2A51A9B0F2BE2468926B4132313728C250DBF', connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
ret = self.run_function('mysql.user_exists', user=user4_utf8, host='%', password=user4_pwd, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self.assertEqual(True, ret, "Testing final user '{0}' on host '{1}' with password take from password and not password_hash failed".format(user4_utf8, '%'))
self._userCreationLoop(uname=user5, host='localhost', password='\xe6\xa8\x99\xe6\xa8\x99', new_password=user5_pwd, unix_socket=True, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
ret = self.run_function('mysql.user_exists', user=user5_utf8, host='localhost', password=user5_pwd, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self.assertEqual(True, ret, "Testing final user '{0}' on host '{1}' with utf8 password failed".format(user5_utf8, 'localhost'))
self._userCreationLoop(uname=user6, host='10.0.0.1', password=' foobar', new_password=user6_pwd_u, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
ret = self.run_function('mysql.user_exists', user=user6_utf8, host='10.0.0.1', password=user6_pwd_utf8, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self.assertEqual(True, ret, "Testing final user '{0}' on host '{1}' with unicode password failed".format(user6_utf8, '10.0.0.1'))
self._chck_userinfo(user=user2, host='10.0.0.1', check_user=user2, check_hash='')
self._chck_userinfo(user=user2, host='10.0.0.2', check_user=user2, check_hash='')
self._chck_userinfo(user=user2, host='localhost', check_user=user2, check_hash=user2_pwd_hash)
self._chck_userinfo(user=user3, host='%', check_user=user3, check_hash=user3_pwd_hash)
self._chck_userinfo(user=user3, host='localhost', check_user=user3, check_hash='')
self._chck_userinfo(user=user4, host='%', check_user=user4_utf8, check_hash=user4_pwd_hash)
self._chck_userinfo(user=user6, host='10.0.0.1', check_user=user6_utf8, check_hash=user6_pwd_hash)
self._chck_userinfo(user=user1, host='localhost', check_user=user1, check_hash=user1_pwd_hash)
self._chck_userinfo(user=user5, host='localhost', check_user=user5_utf8, check_hash=user5_pwd_hash)
ret = self.run_function('mysql.user_list', connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self.assertIn({'Host': 'localhost', 'User': user1}, ret)
self.assertIn({'Host': 'localhost', 'User': user2}, ret)
self.assertIn({'Host': '10.0.0.1', 'User': user2}, ret)
self.assertIn({'Host': '10.0.0.2', 'User': user2}, ret)
self.assertIn({'Host': '%', 'User': user3}, ret)
self.assertIn({'Host': 'localhost', 'User': user3}, ret)
self.assertIn({'Host': '%', 'User': user4_utf8}, ret)
self.assertIn({'Host': 'localhost', 'User': user5_utf8}, ret)
self.assertIn({'Host': '10.0.0.1', 'User': user6_utf8}, ret)
ret = self.run_function('mysql.query', database='information_schema', query='SELECT 1', connection_user=user1, connection_pass='pwd`\'"1b', connection_host='localhost')
if ((not isinstance(ret, dict)) or ('results' not in ret)):
raise AssertionError("Unexpected result while testing connection with user '{0}': {1}".format(user1, repr(ret)))
self.assertEqual([['1']], ret['results'])
ret = self.run_function('mysql.query', database='information_schema', query='SELECT 1', connection_user=user3, connection_pass='', connection_host='localhost')
if ((not isinstance(ret, dict)) or ('results' not in ret)):
raise AssertionError("Unexpected result while testing connection with user '{0}': {1}".format(user3, repr(ret)))
self.assertEqual([['1']], ret['results'])
ret = self.run_function('mysql.query', database='information_schema', query='SELECT 1', connection_user=user5_utf8, connection_pass=user5_pwd, connection_host='localhost', connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
if ((not isinstance(ret, dict)) or ('results' not in ret)):
raise AssertionError("Unexpected result while testing connection with user '{0}': {1}".format(user5_utf8, repr(ret)))
self.assertEqual([['1']], ret['results'])
self._chk_remove_user(user=user2, host='10.0.0.1', connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self._chk_remove_user(user=user2, host='10.0.0.2', connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self._chk_remove_user(user=user2, host='localhost', connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self._chk_remove_user(user=user3, host='%', connection_user=self.user, connection_pass=self.password)
self._chk_remove_user(user=user3, host='localhost', connection_user=self.user, connection_pass=self.password)
self._chk_remove_user(user=user4, host='%', connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self._chk_remove_user(user=user6, host='10.0.0.1', connection_user=self.user, connection_pass=self.password)
self._chk_remove_user(user=user1, host='localhost', connection_user=self.user, connection_pass=self.password)
self._chk_remove_user(user=user5, host='localhost', connection_user=self.user, connection_pass=self.password)
ret = self.run_function('mysql.user_list', connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
self.assertNotIn({'Host': 'localhost', 'User': user1}, ret)
self.assertNotIn({'Host': 'localhost', 'User': user2}, ret)
self.assertNotIn({'Host': '10.0.0.1', 'User': user2}, ret)
self.assertNotIn({'Host': '10.0.0.2', 'User': user2}, ret)
self.assertNotIn({'Host': '%', 'User': user3}, ret)
self.assertNotIn({'Host': 'localhost', 'User': user3}, ret)
self.assertNotIn({'Host': '%', 'User': user4_utf8}, ret)
self.assertNotIn({'Host': 'localhost', 'User': user5_utf8}, ret)
self.assertNotIn({'Host': '10.0.0.1', 'User': user6_utf8}, ret)
|
'Test presence of MySQL server, enforce a root password, create users'
| @destructiveTest
def setUp(self):
| super(MysqlModuleUserGrantTest, self).setUp()
NO_MYSQL_SERVER = True
ret1 = self.run_state('cmd.run', name=(((('mysqladmin --host="localhost" -u ' + self.user) + ' flush-privileges password "') + self.password) + '"'))
ret2 = self.run_state('cmd.run', name=(((((('mysqladmin --host="localhost" -u ' + self.user) + ' --password="') + self.password) + '" flush-privileges password "') + self.password) + '"'))
(key, value) = ret2.popitem()
if value['result']:
NO_MYSQL_SERVER = False
else:
self.skipTest('No MySQL Server running, or no root access on it.')
for (user, userdef) in six.iteritems(self.users):
self._userCreation(uname=userdef['name'], password=userdef['pwd'])
self.run_function('mysql.db_create', name=self.testdb1, connection_user=self.user, connection_pass=self.password)
self.run_function('mysql.db_create', name=self.testdb2, connection_user=self.user, connection_pass=self.password)
create_query = 'CREATE TABLE {tblname} ( id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, data VARCHAR(100)) ENGINE={engine};'.format(tblname=mysqlmod.quote_identifier(self.table1), engine='MYISAM')
log.info("Adding table '{0}'".format(self.table1))
self.run_function('mysql.query', database=self.testdb2, query=create_query, connection_user=self.user, connection_pass=self.password)
create_query = 'CREATE TABLE {tblname} ( id INT NOT NULL AUTO_INCREMENT PRIMARY KEY, data VARCHAR(100)) ENGINE={engine};'.format(tblname=mysqlmod.quote_identifier(self.table2), engine='MYISAM')
log.info("Adding table '{0}'".format(self.table2))
self.run_function('mysql.query', database=self.testdb2, query=create_query, connection_user=self.user, connection_pass=self.password)
|
'Removes created users and db'
| @destructiveTest
def tearDown(self):
| for (user, userdef) in six.iteritems(self.users):
self._userRemoval(uname=userdef['name'], password=userdef['pwd'])
self.run_function('mysql.db_remove', name=self.testdb1, connection_user=self.user, connection_pass=self.password)
self.run_function('mysql.db_remove', name=self.testdb2, connection_user=self.user, connection_pass=self.password)
|
'Create a test user'
| def _userCreation(self, uname, password=None):
| self.run_function('mysql.user_create', user=uname, host='localhost', password=password, connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
|
'Removes a test user'
| def _userRemoval(self, uname, password=None):
| self.run_function('mysql.user_remove', user=uname, host='localhost', connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.