desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'test query to /jobs returns job data'
| def test_all_jobs(self):
| self._add_job()
(request, response) = self.request('/jobs', method='GET', headers={'Accept': 'application/json', 'X-Auth-Token': self._token()})
resp = json.loads(salt.utils.stringutils.to_str(response.body[0]))
self.assertIn('test.ping', str(resp['return']))
self.assertEqual(response.status, '200 OK')
|
'Set up a NetapiClient instance'
| def setUp(self):
| opts = salt.config.client_config(os.path.join(TMP_CONF_DIR, 'master'))
self.netapi = salt.netapi.NetapiClient(opts)
|
'Test the root path which returns the list of clients we support'
| def test_root(self):
| response = self.fetch('/', connect_timeout=30, request_timeout=30)
self.assertEqual(response.code, 200)
response_obj = json_loads(response.body)
self.assertEqual(sorted(response_obj['clients']), ['local', 'local_async', 'runner', 'runner_async'])
self.assertEqual(response_obj['return'], 'Welcome')
|
'Test post with no auth token, should 401'
| def test_post_no_auth(self):
| low = [{'client': 'local', 'tgt': '*', 'fun': 'test.ping'}]
response = self.fetch('/', method='POST', body=json.dumps(low), headers={'Content-Type': self.content_type_map['json']}, follow_redirects=False, connect_timeout=30, request_timeout=30)
self.assertEqual(response.code, 302)
self.assertEqual(response.headers['Location'], '/login')
|
'Test a basic API of /'
| @skipIf(True, 'to be re-enabled when #23623 is merged')
def test_simple_local_post(self):
| low = [{'client': 'local', 'tgt': '*', 'fun': 'test.ping'}]
response = self.fetch('/', method='POST', body=json.dumps(low), headers={'Content-Type': self.content_type_map['json'], saltnado.AUTH_TOKEN_HEADER: self.token['token']}, connect_timeout=30, request_timeout=30)
response_obj = json_loads(response.body)
self.assertEqual(response_obj['return'], [{'minion': True, 'sub_minion': True}])
|
'POST job with invalid tgt'
| def test_simple_local_post_no_tgt(self):
| low = [{'client': 'local', 'tgt': 'minion_we_dont_have', 'fun': 'test.ping'}]
response = self.fetch('/', method='POST', body=json.dumps(low), headers={'Content-Type': self.content_type_map['json'], saltnado.AUTH_TOKEN_HEADER: self.token['token']}, connect_timeout=30, request_timeout=30)
response_obj = json_loads(response.body)
self.assertEqual(response_obj['return'], ['No minions matched the target. No command was sent, no jid was assigned.'])
|
'Test a basic API of /'
| @skipIf(True, 'Undetermined race condition in test. Temporarily disabled.')
def test_simple_local_post_only_dictionary_request(self):
| low = {'client': 'local', 'tgt': '*', 'fun': 'test.ping'}
response = self.fetch('/', method='POST', body=json.dumps(low), headers={'Content-Type': self.content_type_map['json'], saltnado.AUTH_TOKEN_HEADER: self.token['token']}, connect_timeout=30, request_timeout=30)
response_obj = json_loads(response.body)
self.assertEqual(response_obj['return'], [{'minion': True, 'sub_minion': True}])
|
'Test a basic API of /'
| def test_simple_local_post_invalid_request(self):
| low = ['invalid request']
response = self.fetch('/', method='POST', body=json.dumps(low), headers={'Content-Type': self.content_type_map['json'], saltnado.AUTH_TOKEN_HEADER: self.token['token']}, connect_timeout=30, request_timeout=30)
self.assertEqual(response.code, 400)
|
'The /minions endpoint is async only, so if you try something else
make sure you get an error'
| def test_post_with_incorrect_client(self):
| low = [{'client': 'local', 'tgt': '*', 'fun': 'test.ping'}]
response = self.fetch('/minions', method='POST', body=json.dumps(low), headers={'Content-Type': self.content_type_map['json'], saltnado.AUTH_TOKEN_HEADER: self.token['token']})
self.assertEqual(response.code, 400)
|
'Configure an eauth user to test with'
| def setUp(self):
| self.wheel = salt.wheel.Wheel(dict(self.get_config('client_config')))
|
'Test executing master_call with lowdata
The choice of using key.list_all for this is arbitrary and should be
changed to some mocked function that is more testing friendly.'
| def test_master_call(self):
| low = {'client': 'wheel', 'fun': 'key.list_all', 'print_event': False}
low.update(self.eauth_creds)
self.wheel.master_call(**low)
|
'Test executing master_call with lowdata
The choice of using key.list_all for this is arbitrary and should be
changed to some mocked function that is more testing friendly.'
| def test_token(self):
| auth = salt.auth.LoadAuth(dict(self.get_config('client_config')))
token = auth.mk_token(self.eauth_creds)
token = auth.mk_token({'username': 'saltdev_auto', 'password': 'saltdev', 'eauth': 'auto'})
self.wheel.master_call(**{'client': 'wheel', 'fun': 'key.list_all', 'token': token['token'], 'print_event': False})
|
'svn.latest'
| def test_latest(self):
| ret = self.run_state('svn.latest', name=self.name, rev=self.new_rev, target=self.target)
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isdir(os.path.join(self.target, '.svn')))
self.assertSaltStateChangesEqual(ret, self.name, keys=['new'])
self.assertSaltStateChangesEqual(ret, self.new_rev, keys=['revision'])
|
'svn.latest'
| def test_latest_failure(self):
| ret = self.run_state('svn.latest', name='https://youSpelledApacheWrong.com/repo/asf/httpd/trunk/', rev=self.new_rev, target=self.target)
self.assertSaltFalseReturn(ret)
self.assertFalse(os.path.isdir(os.path.join(self.target, '.svn')))
|
'svn.latest'
| def test_latest_empty_dir(self):
| if (not os.path.isdir(self.target)):
os.mkdir(self.target)
ret = self.run_state('svn.latest', name=self.name, rev=self.new_rev, target=self.target)
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isdir(os.path.join(self.target, '.svn')))
|
'svn.latest against existing repository'
| def no_test_latest_existing_repo(self):
| current_rev = '1442865'
(cwd, basename) = os.path.split(self.target)
opts = ('-r', current_rev)
out = self.run_function('svn.checkout', [cwd, self.name, basename, None, None, opts])
assert out
ret = self.run_state('svn.latest', name=self.name, rev=self.new_rev, target=self.target)
self.assertSaltTrueReturn(ret)
self.assertSaltStateChangesEqual(ret, '{0} => {1}'.format(current_rev, self.new_rev), keys=['revision'])
self.assertTrue(os.path.isdir(os.path.join(self.target, '.svn')))
|
'svn.latest against existing repository'
| def no_test_latest_existing_repo_no_rev_change(self):
| current_rev = self.new_rev
(cwd, basename) = os.path.split(self.target)
opts = ('-r', current_rev)
out = self.run_function('svn.checkout', [cwd, self.name, basename, None, None, opts])
assert out
ret = self.run_state('svn.latest', name=self.name, rev=self.new_rev, target=self.target)
self.assertSaltTrueReturn(ret)
self.assertSaltStateChangesEqual(ret, {})
self.assertTrue(os.path.isdir(os.path.join(self.target, '.svn')))
|
'Basic test to determine if Bower package was successfully installed and
removed.'
| @destructiveTest
def test_bower_installed_removed(self):
| ret = self.run_state('file.directory', name='/salt_test_bower_1', makedirs=True)
self.assertSaltTrueReturn(ret)
ret = self.run_state('bower.installed', name='underscore', dir='/salt_test_bower_1')
self.assertSaltTrueReturn(ret)
ret = self.run_state('bower.removed', name='underscore', dir='/salt_test_bower_1')
self.assertSaltTrueReturn(ret)
ret = self.run_state('file.absent', name='/salt_test_bower_1')
self.assertSaltTrueReturn(ret)
|
'Basic test to determine if Bower package successfully installs multiple
packages.'
| @destructiveTest
def test_bower_installed_pkgs(self):
| ret = self.run_state('file.directory', name='/salt_test_bower_2', makedirs=True)
self.assertSaltTrueReturn(ret)
ret = self.run_state('bower.installed', name='test', dir='/salt_test_bower_2', pkgs=['numeral', 'underscore'])
self.assertSaltTrueReturn(ret)
ret = self.run_state('file.absent', name='/salt_test_bower_2')
self.assertSaltTrueReturn(ret)
|
'host.present'
| def test_present(self):
| name = 'spam.bacon'
ip = '10.10.10.10'
ret = self.run_state('host.present', name=name, ip=ip)
self.assertSaltTrueReturn(ret)
with salt.utils.files.fopen(HFILE) as fp_:
output = fp_.read()
self.assertIn('{0} DCTB DCTB {1}'.format(ip, name), output)
|
'Ensure that we only refresh the first time we run a test'
| def setUp(self):
| super(PkgTest, self).setUp()
if ('refresh' not in __testcontext__):
self.run_function('pkg.refresh_db')
__testcontext__['refresh'] = True
|
'This is a destructive test as it installs and then removes a package'
| @skipIf(salt.utils.platform.is_windows(), 'minion is windows')
@requires_system_grains
def test_pkg_001_installed(self, grains=None):
| if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
os_family = grains.get('os_family', '')
pkg_targets = _PKG_TARGETS.get(os_family, [])
self.assertTrue(pkg_targets)
target = pkg_targets[0]
version = self.run_function('pkg.version', [target])
self.assertFalse(version)
ret = self.run_state('pkg.installed', name=target, refresh=False)
self.assertSaltTrueReturn(ret)
ret = self.run_state('pkg.removed', name=target)
self.assertSaltTrueReturn(ret)
|
'This is a destructive test as it installs and then removes a package'
| @skipIf(salt.utils.platform.is_windows(), 'minion is windows')
@requires_system_grains
def test_pkg_002_installed_with_version(self, grains=None):
| if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
os_family = grains.get('os_family', '')
pkg_targets = _PKG_TARGETS.get(os_family, [])
if (os_family == 'FreeBSD'):
return
self.assertTrue(pkg_targets)
if (os_family == 'Arch'):
for idx in range(13):
if (idx == 12):
raise Exception('Package database locked after 60 seconds, bailing out')
if (not os.path.isfile('/var/lib/pacman/db.lck')):
break
time.sleep(5)
target = pkg_targets[0]
version = latest_version(self.run_function, target)
self.assertTrue(version)
ret = self.run_state('pkg.installed', name=target, version=version, refresh=False)
self.assertSaltTrueReturn(ret)
ret = self.run_state('pkg.removed', name=target)
self.assertSaltTrueReturn(ret)
|
'This is a destructive test as it installs and then removes two packages'
| @skipIf(salt.utils.platform.is_windows(), 'minion is windows')
@requires_system_grains
def test_pkg_003_installed_multipkg(self, grains=None):
| if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
os_family = grains.get('os_family', '')
pkg_targets = _PKG_TARGETS.get(os_family, [])
self.assertTrue(pkg_targets)
version = self.run_function('pkg.version', pkg_targets)
self.assertFalse(any(version.values()))
ret = self.run_state('pkg.installed', name=None, pkgs=pkg_targets, refresh=False)
self.assertSaltTrueReturn(ret)
ret = self.run_state('pkg.removed', name=None, pkgs=pkg_targets)
self.assertSaltTrueReturn(ret)
|
'This is a destructive test as it installs and then removes two packages'
| @skipIf(salt.utils.platform.is_windows(), 'minion is windows')
@requires_system_grains
def test_pkg_004_installed_multipkg_with_version(self, grains=None):
| if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
os_family = grains.get('os_family', '')
pkg_targets = _PKG_TARGETS.get(os_family, [])
if (os_family == 'FreeBSD'):
return
self.assertTrue(bool(pkg_targets))
if (os_family == 'Arch'):
for idx in range(13):
if (idx == 12):
raise Exception('Package database locked after 60 seconds, bailing out')
if (not os.path.isfile('/var/lib/pacman/db.lck')):
break
time.sleep(5)
version = latest_version(self.run_function, pkg_targets[0])
self.assertTrue(bool(version))
pkgs = [{pkg_targets[0]: version}, pkg_targets[1]]
ret = self.run_state('pkg.installed', name=None, pkgs=pkgs, refresh=False)
self.assertSaltTrueReturn(ret)
ret = self.run_state('pkg.removed', name=None, pkgs=pkg_targets)
self.assertSaltTrueReturn(ret)
|
'This is a destructive test as it installs and then removes a package'
| @skipIf(salt.utils.platform.is_windows(), 'minion is windows')
@requires_system_grains
def test_pkg_005_installed_32bit(self, grains=None):
| if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
os_name = grains.get('os', '')
target = _PKG_TARGETS_32.get(os_name, '')
if target:
if ((os_name == 'CentOS') and grains['osrelease'].startswith('5.')):
target = target.replace('.i686', '.i386')
version = self.run_function('pkg.version', [target])
self.assertFalse(bool(version))
ret = self.run_state('pkg.installed', name=target, refresh=False)
self.assertSaltTrueReturn(ret)
ret = self.run_state('pkg.removed', name=target)
self.assertSaltTrueReturn(ret)
|
'This is a destructive test as it installs and then removes a package'
| @skipIf(salt.utils.platform.is_windows(), 'minion is windows')
@requires_system_grains
def test_pkg_006_installed_32bit_with_version(self, grains=None):
| if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
os_name = grains.get('os', '')
target = _PKG_TARGETS_32.get(os_name, '')
if (not target):
self.skipTest('No targets configured for this test')
if (grains.get('os_family', '') == 'Arch'):
for idx in range(13):
if (idx == 12):
raise Exception('Package database locked after 60 seconds, bailing out')
if (not os.path.isfile('/var/lib/pacman/db.lck')):
break
time.sleep(5)
if ((os_name == 'CentOS') and grains['osrelease'].startswith('5.')):
target = target.replace('.i686', '.i386')
version = latest_version(self.run_function, target)
self.assertTrue(bool(version))
ret = self.run_state('pkg.installed', name=target, version=version, refresh=False)
self.assertSaltTrueReturn(ret)
ret = self.run_state('pkg.removed', name=target)
self.assertSaltTrueReturn(ret)
|
'This tests for the regression found in the following issue:
https://github.com/saltstack/salt/issues/8614
This is a destructive test as it installs a package'
| @skipIf(salt.utils.platform.is_windows(), 'minion is windows')
@requires_system_grains
def test_pkg_007_with_dot_in_pkgname(self, grains=None):
| if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
os_family = grains.get('os_family', '')
os_version = grains.get('osmajorrelease')
target = _PKG_TARGETS_DOT.get(os_family, {}).get(os_version)
if (not target):
self.skipTest('No targets configured for this test')
version = latest_version(self.run_function, target)
self.assertTrue(bool(version))
ret = self.run_state('pkg.installed', name=target, refresh=False)
self.assertSaltTrueReturn(ret)
ret = self.run_state('pkg.removed', name=target)
self.assertSaltTrueReturn(ret)
|
'This tests for the regression found in the following issue:
https://github.com/saltstack/salt/issues/8614
This is a destructive test as it installs a package'
| @skipIf(salt.utils.platform.is_windows(), 'minion is windows')
@requires_system_grains
def test_pkg_008_epoch_in_version(self, grains=None):
| if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
os_family = grains.get('os_family', '')
os_version = grains.get('osmajorrelease')
target = _PKG_TARGETS_EPOCH.get(os_family, {}).get(os_version)
if (not target):
self.skipTest('No targets configured for this test')
version = latest_version(self.run_function, target)
self.assertTrue(bool(version))
ret = self.run_state('pkg.installed', name=target, version=version, refresh=False)
self.assertSaltTrueReturn(ret)
ret = self.run_state('pkg.removed', name=target)
self.assertSaltTrueReturn(ret)
|
'This tests for the following issue:
https://github.com/saltstack/salt/issues/31014
This is a destructive test as it installs a package'
| @skipIf(salt.utils.platform.is_windows(), 'minion is windows')
def test_pkg_009_latest_with_epoch(self):
| if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
ret = self.run_state('pkg.installed', name='bash-completion', refresh=False)
self.assertSaltTrueReturn(ret)
|
'Need to check to ensure the package has been
installed after the pkg_latest_epoch sls
file has been run. This needs to be broken up into
a separate method so I can add the requires_salt_modules
decorator to only the pkg.info_installed command.'
| @skipIf(salt.utils.platform.is_windows(), 'minion is windows')
@requires_salt_modules('pkg.info_installed')
def test_pkg_010_latest_with_epoch_and_info_installed(self):
| if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
package = 'bash-completion'
pkgquery = 'version'
ret = self.run_function('pkg.info_installed', [package])
self.assertTrue((pkgquery in str(ret)))
|
'This tests pkg.latest with a package that has no epoch (or a zero
epoch).'
| @skipIf(salt.utils.platform.is_windows(), 'minion is windows')
@requires_system_grains
def test_pkg_011_latest(self, grains=None):
| if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
os_family = grains.get('os_family', '')
pkg_targets = _PKG_TARGETS.get(os_family, [])
self.assertTrue(pkg_targets)
target = pkg_targets[0]
version = latest_version(self.run_function, target)
self.assertTrue(version)
ret = self.run_state('pkg.latest', name=target, refresh=False)
self.assertSaltTrueReturn(ret)
ret = self.run_state('pkg.removed', name=target)
self.assertSaltTrueReturn(ret)
|
'WARNING: This test will pick a package with an available upgrade (if
there is one) and upgrade it to the latest version.'
| @skipIf(salt.utils.platform.is_windows(), 'minion is windows')
@requires_system_grains
def test_pkg_012_latest_only_upgrade(self, grains=None):
| os_family = grains.get('os_family', '')
if (os_family != 'Debian'):
self.skipTest('Minion is not Debian/Ubuntu')
if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
pkg_targets = _PKG_TARGETS.get(os_family, [])
self.assertTrue(pkg_targets)
target = pkg_targets[0]
version = latest_version(self.run_function, target)
self.assertTrue(version)
ret = self.run_state('pkg.latest', name=target, refresh=False, only_upgrade=True)
self.assertSaltFalseReturn(ret)
installed_pkgs = self.run_function('pkg.list_pkgs')
updates = self.run_function('pkg.list_upgrades', refresh=False)
for pkgname in updates:
if (pkgname in installed_pkgs):
target = pkgname
break
else:
target = ''
log.warning('No available upgrades to installed packages, skipping only_upgrade=True test with already-installed package. For best results run this test on a machine with upgrades available.')
if target:
ret = self.run_state('pkg.latest', name=target, refresh=False, only_upgrade=True)
self.assertSaltTrueReturn(ret)
new_version = self.run_function('pkg.version', [target])
self.assertEqual(new_version, updates[target])
ret = self.run_state('pkg.latest', name=target, refresh=False, only_upgrade=True)
self.assertEqual(ret['pkg_|-{0}_|-{0}_|-latest'.format(target)]['comment'], 'Package {0} is already up-to-date'.format(target))
|
'This is a destructive test as it installs and then removes a package'
| @requires_system_grains
def test_pkg_013_installed_with_wildcard_version(self, grains=None):
| if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
os_family = grains.get('os_family', '')
if (os_family not in _WILDCARDS_SUPPORTED):
self.skipTest('Wildcards only supported on {0}'.format(', '.join(_WILDCARDS_SUPPORTED)))
pkg_targets = _PKG_TARGETS.get(os_family, [])
self.assertTrue(pkg_targets)
target = pkg_targets[0]
version = self.run_function('pkg.version', [target])
self.assertFalse(version)
ret = self.run_state('pkg.installed', name=target, version='*', refresh=False)
self.assertSaltTrueReturn(ret)
ret = self.run_state('pkg.installed', name=target, version='*', refresh=False)
expected_comment = 'All specified packages are already installed and are at the desired version'
self.assertSaltTrueReturn(ret)
self.assertEqual(ret[next(iter(ret))]['comment'], expected_comment)
ret = self.run_state('pkg.installed', name=target, version='93413*', refresh=False)
self.assertSaltFalseReturn(ret)
ret = self.run_state('pkg.removed', name=target)
self.assertSaltTrueReturn(ret)
|
'This is a destructive test as it installs and then removes a package'
| @requires_system_grains
def test_pkg_014_installed_with_comparison_operator(self, grains=None):
| if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
os_family = grains.get('os_family', '')
if (os_family not in ('Debian', 'RedHat')):
self.skipTest('Comparison operator not specially implemented')
pkg_targets = _PKG_TARGETS.get(os_family, [])
self.assertTrue(pkg_targets)
target = pkg_targets[0]
version = self.run_function('pkg.version', [target])
self.assertFalse(version)
latest_version = self.run_function('pkg.latest_version', [target], refresh=False)
try:
ret = self.run_state('pkg.installed', name=target, version='<9999999', refresh=False)
self.assertSaltTrueReturn(ret)
version = self.run_function('pkg.version', [target])
self.assertTrue(version, latest_version)
finally:
ret = self.run_state('pkg.removed', name=target)
self.assertSaltTrueReturn(ret)
|
'Tests that a CommandExecutionError is caught and the state returns False when
the package group is missing. Before this fix, the state would stacktrace.
See Issue #35819 for bug report.'
| @requires_salt_modules('pkg.group_install')
@requires_system_grains
def test_group_installed_handle_missing_package_group(self, grains=None):
| if (not pkgmgr_avail(self.run_function, self.run_function('grains.items'))):
self.skipTest('Package manager is not available')
grp_install_msg = 'pkg.group_install not available for this platform'
ret = self.run_state('pkg.group_installed', name='handle_missing_pkg_group', skip=['foo-bar-baz'])
ret_comment = ret['pkg_|-handle_missing_pkg_group_|-handle_missing_pkg_group_|-group_installed']['comment']
if (ret_comment == grp_install_msg):
self.skipTest(grp_install_msg)
self.assertSaltFalseReturn(ret)
self.assertEqual(ret_comment, "An error was encountered while installing/updating group 'handle_missing_pkg_group': Group 'handle_missing_pkg_group' not found.")
|
'This is a DESTRUCTIVE TEST it creates a new user on the minion.
And then destroys that user.
Assume that it will break any system you run it on.'
| def test_user_not_present(self):
| ret = self.run_state('user.present', name=self.user_name)
self.assertSaltTrueReturn(ret)
|
'This is a DESTRUCTIVE TEST it creates a new user on the minion.
And then destroys that user.
Assume that it will break any system you run it on.'
| def test_user_present_when_home_dir_does_not_18843(self):
| if salt.utils.platform.is_darwin():
HOMEDIR = ('/Users/home_of_' + self.user_name)
else:
HOMEDIR = ('/home/home_of_' + self.user_name)
ret = self.run_state('user.present', name=self.user_name, home=HOMEDIR)
self.assertSaltTrueReturn(ret)
self.run_function('file.absent', name=HOMEDIR)
ret = self.run_state('user.present', name=self.user_name, home=HOMEDIR)
self.assertSaltTrueReturn(ret)
|
'This is a DESTRUCTIVE TEST it creates a new user on the on the minion.'
| def test_user_present_nondefault(self):
| ret = self.run_state('user.present', name=self.user_name, home=self.user_home)
self.assertSaltTrueReturn(ret)
if (not salt.utils.platform.is_darwin()):
self.assertTrue(os.path.isdir(self.user_home))
|
'This is a DESTRUCTIVE TEST. It creates a new user on the on the minion.
This is an integration test. Not all systems will automatically create
a group of the same name as the user, but I don\'t have access to any.
If you run the test and it fails, please fix the code it\'s testing to
work on your operating system.'
| @requires_system_grains
def test_user_present_gid_from_name_default(self, grains=None):
| gid_from_name = (False if (grains['os_family'] == 'MacOS') else True)
ret = self.run_state('user.present', name=self.user_name, gid_from_name=gid_from_name, home=self.user_home)
self.assertSaltTrueReturn(ret)
ret = self.run_function('user.info', [self.user_name])
self.assertReturnNonEmptySaltType(ret)
group_name = grp.getgrgid(ret['gid']).gr_name
if (not salt.utils.platform.is_darwin()):
self.assertTrue(os.path.isdir(self.user_home))
if (grains['os_family'] in ('Suse',)):
self.assertEqual(group_name, 'users')
elif (grains['os_family'] == 'MacOS'):
self.assertEqual(group_name, 'staff')
else:
self.assertEqual(group_name, self.user_name)
|
'This is a DESTRUCTIVE TEST it creates a new user on the on the minion.
This is a unit test, NOT an integration test. We create a group of the
same name as the user beforehand, so it should all run smoothly.'
| def test_user_present_gid_from_name(self):
| ret = self.run_state('group.present', name=self.user_name)
self.assertSaltTrueReturn(ret)
ret = self.run_state('user.present', name=self.user_name, gid_from_name=True, home=self.user_home)
self.assertSaltTrueReturn(ret)
ret = self.run_function('user.info', [self.user_name])
self.assertReturnNonEmptySaltType(ret)
group_name = grp.getgrgid(ret['gid']).gr_name
if (not salt.utils.platform.is_darwin()):
self.assertTrue(os.path.isdir(self.user_home))
self.assertEqual(group_name, self.user_name)
ret = self.run_state('user.absent', name=self.user_name)
self.assertSaltTrueReturn(ret)
ret = self.run_state('group.absent', name=self.user_name)
self.assertSaltTrueReturn(ret)
|
'This is a DESTRUCTIVE TEST it creates a new user on the on the minion.
It ensures that unicode GECOS data will be properly handled, without
any encoding-related failures.'
| @skipIf(sys.getfilesystemencoding().startswith('ANSI'), "A system encoding which supports Unicode characters must be set. Current setting is: {0}. Try setting $LANG='en_US.UTF-8'".format(sys.getfilesystemencoding()))
def test_user_present_unicode(self):
| ret = self.run_state('user.present', name=self.user_name, fullname=u'S\xe5lt Test', roomnumber=u'\u2460\u2461\u2462', workphone=u'\u0661\u0662\u0663\u0664', homephone=u'\u096c\u096d\u096e')
self.assertSaltTrueReturn(ret)
ret = self.run_state('user.present', name=self.user_name, fullname=u'S\xf8lt Test', roomnumber=u'\u2460\u2462\u2461', workphone=u'\u0663\u0664\u0661\u0662', homephone=u'\u096c\u096e\u096d')
self.assertSaltTrueReturn(ret)
|
'This is a DESTRUCTIVE TEST it creates a new user on the on the minion.
It ensures that numeric GECOS data will be properly coerced to strings,
otherwise the state will fail because the GECOS fields are written as
strings (and show up in the user.info output as such). Thus the
comparison will fail, since \'12345\' != 12345.'
| def test_user_present_gecos(self):
| ret = self.run_state('user.present', name=self.user_name, fullname=12345, roomnumber=123, workphone=1234567890, homephone=1234567890)
self.assertSaltTrueReturn(ret)
|
'This is a DESTRUCTIVE TEST it creates a new user on the on the minion.
It ensures that if no GECOS data is supplied, the fields will be coerced
into empty strings as opposed to the string "None".'
| def test_user_present_gecos_none_fields(self):
| ret = self.run_state('user.present', name=self.user_name, fullname=None, roomnumber=None, workphone=None, homephone=None)
self.assertSaltTrueReturn(ret)
ret = self.run_function('user.info', [self.user_name])
self.assertReturnNonEmptySaltType(ret)
self.assertEqual('', ret['fullname'])
if (not salt.utils.platform.is_darwin()):
self.assertEqual('', ret['roomnumber'])
self.assertEqual('', ret['workphone'])
self.assertEqual('', ret['homephone'])
|
'This is a destructive test as it adds a repository.'
| @destructiveTest
@skipIf(salt.utils.platform.is_windows(), 'minion is windows')
@requires_system_grains
def test_pkgrepo_01_managed(self, grains):
| os_grain = self.run_function('grains.item', ['os'])['os']
os_release_info = tuple(self.run_function('grains.item', ['osrelease_info'])['osrelease_info'])
if ((os_grain == 'Ubuntu') and (os_release_info >= (15, 10))):
self.skipTest('The PPA used for this test does not exist for Ubuntu Wily (15.10) and later.')
if (grains['os_family'] == 'Debian'):
try:
from aptsources import sourceslist
except ImportError:
self.skipTest('aptsources.sourceslist python module not found')
ret = self.run_function('state.sls', mods='pkgrepo.managed', timeout=120)
self.assertReturnNonEmptySaltType(ret)
for (state_id, state_result) in six.iteritems(ret):
self.assertSaltTrueReturn(dict([(state_id, state_result)]))
|
'This is a destructive test as it removes the repository added in the
above test.'
| @destructiveTest
@skipIf(salt.utils.platform.is_windows(), 'minion is windows')
def test_pkgrepo_02_absent(self):
| os_grain = self.run_function('grains.item', ['os'])['os']
os_release_info = tuple(self.run_function('grains.item', ['osrelease_info'])['osrelease_info'])
if ((os_grain == 'Ubuntu') and (os_release_info >= (15, 10))):
self.skipTest('The PPA used for this test does not exist for Ubuntu Wily (15.10) and later.')
ret = self.run_function('state.sls', mods='pkgrepo.absent', timeout=120)
self.assertReturnNonEmptySaltType(ret)
for (state_id, state_result) in six.iteritems(ret):
self.assertSaltTrueReturn(dict([(state_id, state_result)]))
|
'Test the Jinja dot-notation syntax for calling execution modules'
| def test_dot_notation(self):
| ret = self.run_function('state.sls', ['jinja_dot_notation'])
for state_ret in ret.values():
self.assertTrue(state_ret['result'])
|
'Test if we are able to check if a function exists inside the "salt"
wrapper (AliasLoader) which is available on Jinja templates.'
| def test_salt_contains_function(self):
| ret = self.run_function('state.sls', ['jinja_salt_contains_function'])
for state_ret in ret.values():
self.assertTrue(state_ret['result'])
|
'ssh_known_hosts.present'
| def test_present(self):
| kwargs = {'name': 'github.com', 'user': 'root', 'fingerprint': GITHUB_FINGERPRINT, 'config': KNOWN_HOSTS}
ret = self.run_state('ssh_known_hosts.present', test=True, **kwargs)
self.assertSaltNoneReturn(ret)
ret = self.run_state('ssh_known_hosts.present', **kwargs)
try:
self.assertSaltTrueReturn(ret)
except AssertionError as err:
try:
self.assertInSaltComment('Unable to receive remote host key', ret)
self.skipTest('Unable to receive remote host key')
except AssertionError:
raise err
self.assertSaltStateChangesEqual(ret, GITHUB_FINGERPRINT, keys=('new', 'fingerprint'))
self.run_state('ssh_known_hosts.present', **kwargs)
ret = self.run_state('ssh_known_hosts.present', test=True, **kwargs)
self.assertSaltTrueReturn(ret)
ret = self.run_state('ssh_known_hosts.present', **dict(kwargs, name=GITHUB_IP))
try:
self.assertSaltStateChangesEqual(ret, GITHUB_FINGERPRINT, keys=('new', 'fingerprint'))
except AssertionError as err:
try:
self.assertInSaltComment('Unable to receive remote host key', ret)
self.skipTest('Unable to receive remote host key')
except AssertionError:
raise err
ret = self.run_function('ssh.get_known_host', ['root', 'github.com'], config=KNOWN_HOSTS)
try:
self.assertNotIn(ret, ('', None))
except AssertionError:
raise AssertionError("Salt return '{0}' is in ('', None).".format(ret))
ret = self.run_function('ssh.get_known_host', ['root', GITHUB_IP], config=KNOWN_HOSTS)
try:
self.assertNotIn(ret, ('', None, {}))
except AssertionError:
raise AssertionError(("Salt return '{0}' is in ('', None,".format(ret) + ' {})'))
|
'ssh_known_hosts.absent'
| def test_absent(self):
| known_hosts = os.path.join(RUNTIME_VARS.FILES, 'ssh', 'known_hosts')
shutil.copyfile(known_hosts, KNOWN_HOSTS)
if (not os.path.isfile(KNOWN_HOSTS)):
self.skipTest('Unable to copy {0} to {1}'.format(known_hosts, KNOWN_HOSTS))
kwargs = {'name': 'github.com', 'user': 'root', 'config': KNOWN_HOSTS}
ret = self.run_state('ssh_known_hosts.absent', test=True, **kwargs)
self.assertSaltNoneReturn(ret)
ret = self.run_state('ssh_known_hosts.absent', **kwargs)
self.assertSaltStateChangesEqual(ret, GITHUB_FINGERPRINT, keys=('old', 'fingerprint'))
ret = self.run_state('ssh_known_hosts.absent', **kwargs)
self.assertSaltStateChangesEqual(ret, {})
ret = self.run_state('ssh_known_hosts.absent', test=True, **kwargs)
self.assertSaltTrueReturn(ret)
|
'Test the error with multiple states of the same type'
| def test_multi_state(self):
| ret = self.run_function('state.sls', mods='fuzz.multi_state')
self.assertIsInstance(ret, list)
|
'Test when we have an error in a execution module
called by jinja'
| def test_jinja_deep_error(self):
| ret = self.run_function('state.sls', ['issue-10010'])
self.assertTrue((', in jinja_error' in ret[0].strip()))
self.assertTrue(ret[0].strip().endswith('Exception: hehehe'))
|
'rabbitmq_vhost.present null_host'
| def test_present(self):
| ret = self.run_state('rabbitmq_vhost.present', name='null_host', test=True)
self.assertSaltFalseReturn(ret)
|
'rabbitmq_vhost.absent null_host'
| def absent(self):
| ret = self.run_state('rabbitmq_vhost.absent', name='null_host', test=True)
self.assertSaltFalseReturn(ret)
|
'Test presence of MySQL server, enforce a root password'
| @destructiveTest
def setUp(self):
| super(MysqlDatabaseStateTest, 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.')
|
'Create db two times, test conn, remove it two times'
| def _test_database(self, db_name, second_db_name, test_conn, **kwargs):
| ret = self.run_state('mysql_database.absent', name=db_name, **kwargs)
ret = self.run_state('mysql_database.present', name=db_name, **kwargs)
self.assertSaltTrueReturn(ret)
self.assertInSaltComment((('The database ' + db_name) + ' has been created'), ret)
ret = self.run_state('mysql_database.present', name=second_db_name, **kwargs)
self.assertSaltTrueReturn(ret)
self.assertInSaltComment((('Database ' + db_name) + ' is already present'), 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 db '{0}': {1}".format(db_name, repr(ret)))
self.assertEqual([['1']], ret['results'])
kwargs.pop('character_set')
kwargs.pop('collate')
ret = self.run_state('mysql_database.absent', name=db_name, **kwargs)
self.assertSaltTrueReturn(ret)
self.assertInSaltComment((('Database ' + db_name) + ' has been removed'), ret)
ret = self.run_state('mysql_database.absent', name=second_db_name, **kwargs)
self.assertSaltTrueReturn(ret)
self.assertInSaltComment((('Database ' + db_name) + ' is not present, so it cannot be removed'), ret)
self.assertSaltStateChangesEqual(ret, {})
|
'mysql_database.present'
| @destructiveTest
def test_present_absent(self):
| self._test_database('testdb1', 'testdb1', test_conn=True, character_set='utf8', collate='utf8_general_ci', connection_user=self.user, connection_pass=self.password, connection_charset='utf8')
|
'mysql_database.present with utf-8 andf fuzzy db name'
| @destructiveTest
def test_present_absent_fuzzy(self):
| dbname_fuzzy = '":() ;,?@=`&/\'\\'
dbname_utf8 = '"();,?@=`&//\xe6\xa8\x99\'\\'
dbname_unicode = u'"();,?@=`&//\u6a19\'\\'
self._test_database(dbname_fuzzy, dbname_fuzzy, test_conn=True, character_set='utf8', collate='utf8_general_ci', connection_user=self.user, connection_pass=self.password, connection_charset='utf8')
self._test_database(dbname_utf8, dbname_unicode, test_conn=False, character_set='utf8', collate='utf8_general_ci', connection_user=self.user, connection_pass=self.password, connection_charset='utf8')
|
'Try to create/destroy an utf-8 database name from an sls file #8947'
| @destructiveTest
@skipIf(True, 'This tests needs issue #8947 to be fixed first')
def test_utf8_from_sls_file(self):
| expected_result = {'mysql_database_|-A_|-foo \xe6\xba\x96`bar_|-present': {'__run_num__': 0, 'comment': 'The database foo \xe6\xba\x96`bar has been created', 'result': True}, 'mysql_database_|-B_|-foo \xe6\xba\x96`bar_|-absent': {'__run_num__': 1, 'comment': 'Database foo \xe6\xba\x96`bar has been removed', 'result': True}}
result = {}
ret = self.run_function('state.sls', mods='mysql_utf8')
if (not isinstance(ret, dict)):
raise AssertionError('Unexpected result while testing external mysql utf8 sls: {0}'.format(repr(ret)))
for (item, descr) in six.iteritems(ret):
result[item] = {'__run_num__': descr['__run_num__'], 'comment': descr['comment'], 'result': descr['result']}
self.assertEqual(expected_result, result)
|
'Test presence of MySQL server, enforce a root password'
| @destructiveTest
def setUp(self):
| super(MysqlGrantsStateTest, 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_state('mysql_database.present', name=self.testdb1, character_set='utf8', collate='utf8_general_ci', connection_user=self.user, connection_pass=self.password)
self.run_state('mysql_database.present', name=self.testdb2, character_set='utf8', collate='utf8_general_ci', 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_state('mysql_database.absent', name=self.testdb1, connection_user=self.user, connection_pass=self.password)
self.run_function('mysql_database.absent', name=self.testdb2, connection_user=self.user, connection_pass=self.password)
|
'Create a test user'
| def _userCreation(self, uname, password=None):
| self.run_state('mysql_user.present', name=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_state('mysql_user.absent', name=uname, host='localhost', connection_user=self.user, connection_pass=self.password, connection_charset='utf8', saltenv={'LC_ALL': 'en_US.utf8'})
|
'mysql_database.present'
| @destructiveTest
def test_grant_present_absent(self):
| ret = self.run_state('mysql_grants.present', name='grant test 1', grant='SELECT, INSERT', database=(self.testdb1 + '.*'), user=self.users['user1']['name'], host='localhost', grant_option=True, revoke_first=True, connection_user=self.user, connection_pass=self.password, connection_charset='utf8')
self.assertSaltTrueReturn(ret)
ret = self.run_state('mysql_grants.present', name='grant test 2', grant='SELECT, ALTER,CREATE TEMPORARY tables, execute', database=(self.testdb1 + '.*'), user=self.users['user1']['name'], host='localhost', grant_option=True, revoke_first=True, connection_user=self.user, connection_pass=self.password, connection_charset='utf8')
self.assertSaltTrueReturn(ret)
ret = self.run_state('mysql_grants.present', name='grant test 3', grant='SELECT, INSERT', database=((self.testdb2 + '.') + self.table2), user=self.users['user2']['name'], host='localhost', grant_option=True, revoke_first=True, connection_user=self.user, connection_pass=self.password, connection_charset='utf8')
self.assertSaltTrueReturn(ret)
ret = self.run_state('mysql_grants.present', name='grant test 4', grant='SELECT, INSERT', database=((self.testdb2 + '.') + self.table2), user=self.users['user2']['name'], host='localhost', grant_option=True, revoke_first=True, connection_user=self.user, connection_pass=self.password, connection_charset='utf8')
self.assertSaltTrueReturn(ret)
ret = self.run_state('mysql_grants.present', name='grant test 5', grant='SELECT, UPDATE', database=(self.testdb2 + '.*'), user=self.users['user1']['name'], host='localhost', grant_option=True, revoke_first=False, connection_user=self.user, connection_pass=self.password, connection_charset='utf8')
self.assertSaltTrueReturn(ret)
ret = self.run_state('mysql_grants.absent', name='grant test 6', grant='SELECT,update', database=(self.testdb2 + '.*'), user=self.users['user1']['name'], host='localhost', grant_option=True, revoke_first=False, connection_user=self.user, connection_pass=self.password, connection_charset='utf8')
self.assertSaltTrueReturn(ret)
|
'rabbitmq_user.present null_name'
| def test_present(self):
| ret = self.run_state('rabbitmq_user.present', name='null_name', test=True)
self.assertSaltFalseReturn(ret)
self.assertInSaltComment("User 'null_name' is set to be created", ret)
|
'rabbitmq_user.absent null_name'
| def absent(self):
| ret = self.run_state('rabbitmq_user.absent', name='null_name', test=True)
self.assertSaltFalseReturn(ret)
|
'Basic test to determine if NPM module was successfully installed and
removed.'
| @requires_network()
@destructiveTest
def test_npm_installed_removed(self):
| ret = self.run_state('npm.installed', name='pm2')
self.assertSaltTrueReturn(ret)
ret = self.run_state('npm.removed', name='pm2')
self.assertSaltTrueReturn(ret)
|
'Determine if URL-referenced NPM module can be successfully installed.'
| @requires_network()
@destructiveTest
def test_npm_install_url_referenced_package(self):
| ret = self.run_state('npm.installed', name='git://github.com/request/request')
self.assertSaltTrueReturn(ret)
ret = self.run_state('npm.removed', name='git://github.com/request/request')
self.assertSaltTrueReturn(ret)
|
'Basic test to determine if NPM module successfully installs multiple
packages.'
| @requires_network()
@destructiveTest
def test_npm_installed_pkgs(self):
| ret = self.run_state('npm.installed', name=None, pkgs=['pm2', 'grunt'])
self.assertSaltTrueReturn(ret)
|
'Basic test to determine if NPM successfully cleans its cached packages.'
| @destructiveTest
def test_npm_cache_clean(self):
| ret = self.run_state('npm.cache_cleaned', name=None, force=True)
self.assertSaltTrueReturn(ret)
|
'network.managed'
| def test_managed(self):
| state_key = 'network_|-dummy0_|-dummy0_|-managed'
ret = self.run_function('state.sls', mods='network.managed', test=True)
self.assertEqual('Interface dummy0 is set to be added.', ret[state_key]['comment'])
|
'network.routes'
| def test_routes(self):
| state_key = 'network_|-routes_|-dummy0_|-routes'
expected_changes = 'Interface dummy0 routes are set to be added.'
ret = self.run_function('state.sls', mods='network.routes', test=True)
self.assertEqual(ret[state_key]['comment'], 'Interface dummy0 routes are set to be added.')
|
'network.system'
| def test_system(self):
| state_key = 'network_|-system_|-system_|-system'
global_settings = self.run_function('ip.get_network_settings')
ret = self.run_function('state.sls', mods='network.system', test=True)
self.assertIn('Global network settings are set to be {0}'.format(('added' if (not global_settings) else 'updated')), ret[state_key]['comment'])
|
'file.symlink'
| def test_symlink(self):
| name = os.path.join(TMP, 'symlink')
tgt = os.path.join(TMP, 'target')
if (IS_WINDOWS and (not os.path.isdir(tgt))):
os.mkdir(tgt)
if (IS_WINDOWS and self.run_function('file.is_link', [name])):
self.run_function('file.remove', [name])
ret = self.run_state('file.symlink', name=name, target=tgt)
self.assertSaltTrueReturn(ret)
|
'file.symlink test interface'
| def test_test_symlink(self):
| name = os.path.join(TMP, 'symlink2')
tgt = os.path.join(TMP, 'target')
ret = self.run_state('file.symlink', test=True, name=name, target=tgt)
self.assertSaltNoneReturn(ret)
|
'file.absent'
| def test_absent_file(self):
| name = os.path.join(TMP, 'file_to_kill')
with salt.utils.files.fopen(name, 'w+') as fp_:
fp_.write('killme')
ret = self.run_state('file.absent', name=name)
self.assertSaltTrueReturn(ret)
self.assertFalse(os.path.isfile(name))
|
'file.absent'
| def test_absent_dir(self):
| name = os.path.join(TMP, 'dir_to_kill')
if (not os.path.isdir(name)):
os.makedirs(name)
ret = self.run_state('file.absent', name=name)
self.assertSaltTrueReturn(ret)
self.assertFalse(os.path.isdir(name))
|
'file.absent'
| def test_absent_link(self):
| name = os.path.join(TMP, 'link_to_kill')
tgt = '{0}.tgt'.format(name)
if (IS_WINDOWS and (not os.path.isdir(tgt))):
os.mkdir(tgt)
if (not self.run_function('file.is_link', [name])):
self.run_function('file.symlink', [tgt, name])
ret = self.run_state('file.absent', name=name)
try:
self.assertSaltTrueReturn(ret)
self.assertFalse(self.run_function('file.is_link', [name]))
finally:
if self.run_function('file.is_link', [name]):
self.run_function('file.remove', [name])
|
'file.absent test interface'
| def test_test_absent(self):
| name = os.path.join(TMP, 'file_to_kill')
with salt.utils.files.fopen(name, 'w+') as fp_:
fp_.write('killme')
ret = self.run_state('file.absent', test=True, name=name)
try:
self.assertSaltNoneReturn(ret)
self.assertTrue(os.path.isfile(name))
finally:
os.remove(name)
|
'file.managed'
| def test_managed(self):
| name = os.path.join(TMP, 'grail_scene33')
ret = self.run_state('file.managed', name=name, source='salt://grail/scene33')
src = os.path.join(FILES, 'file', 'base', 'grail', 'scene33')
with salt.utils.files.fopen(src, 'r') as fp_:
master_data = fp_.read()
with salt.utils.files.fopen(name, 'r') as fp_:
minion_data = fp_.read()
self.assertEqual(master_data, minion_data)
self.assertSaltTrueReturn(ret)
|
'file.managed, correct file permissions'
| def test_managed_file_mode(self):
| desired_mode = 504
name = os.path.join(TMP, 'grail_scene33')
ret = self.run_state('file.managed', name=name, mode='0770', source='salt://grail/scene33')
if IS_WINDOWS:
expected = "The 'mode' option is not supported on Windows"
self.assertEqual(ret[ret.keys()[0]]['comment'], expected)
self.assertSaltFalseReturn(ret)
return
resulting_mode = stat.S_IMODE(os.stat(name).st_mode)
self.assertEqual(oct(desired_mode), oct(resulting_mode))
self.assertSaltTrueReturn(ret)
|
'Test using "mode: keep" in a file.managed state'
| def test_managed_file_mode_keep(self):
| _test_managed_file_mode_keep_helper(self, local=False)
|
'Test using "mode: keep" in a file.managed state, with a local file path
as the source.'
| def test_managed_file_mode_keep_local_source(self):
| _test_managed_file_mode_keep_helper(self, local=True)
|
'file.managed, existing file with replace=True, change permissions'
| def test_managed_file_mode_file_exists_replace(self):
| initial_mode = 504
desired_mode = 384
name = os.path.join(TMP, 'grail_scene33')
ret = self.run_state('file.managed', name=name, mode=oct(initial_mode), source='salt://grail/scene33')
if IS_WINDOWS:
expected = "The 'mode' option is not supported on Windows"
self.assertEqual(ret[ret.keys()[0]]['comment'], expected)
self.assertSaltFalseReturn(ret)
return
resulting_mode = stat.S_IMODE(os.stat(name).st_mode)
self.assertEqual(oct(initial_mode), oct(resulting_mode))
name = os.path.join(TMP, 'grail_scene33')
ret = self.run_state('file.managed', name=name, replace=True, mode=oct(desired_mode), source='salt://grail/scene33')
resulting_mode = stat.S_IMODE(os.stat(name).st_mode)
self.assertEqual(oct(desired_mode), oct(resulting_mode))
self.assertSaltTrueReturn(ret)
|
'file.managed, existing file with replace=False, change permissions'
| def test_managed_file_mode_file_exists_noreplace(self):
| initial_mode = 504
desired_mode = 384
name = os.path.join(TMP, 'grail_scene33')
ret = self.run_state('file.managed', name=name, replace=True, mode=oct(initial_mode), source='salt://grail/scene33')
if IS_WINDOWS:
expected = "The 'mode' option is not supported on Windows"
self.assertEqual(ret[ret.keys()[0]]['comment'], expected)
self.assertSaltFalseReturn(ret)
return
ret = self.run_state('file.managed', name=name, replace=False, mode=oct(desired_mode), source='salt://grail/scene33')
resulting_mode = stat.S_IMODE(os.stat(name).st_mode)
self.assertEqual(oct(desired_mode), oct(resulting_mode))
self.assertSaltTrueReturn(ret)
|
'Test to ensure we can render grains data into a managed
file.'
| def test_managed_file_with_grains_data(self):
| grain_path = os.path.join(TMP, 'file-grain-test')
self.run_function('grains.set', ['grain_path', grain_path])
state_file = 'file-grainget'
self.run_function('state.sls', [state_file])
self.assertTrue(os.path.exists(grain_path))
with salt.utils.files.fopen(grain_path, 'r') as fp_:
file_contents = fp_.readlines()
self.assertTrue(re.match('^minion$', file_contents[0]))
|
'Test to ensure pillar data in sls file
is rendered properly and file is created.'
| def test_managed_file_with_pillar_sls(self):
| state_name = 'file-pillarget'
ret = self.run_function('state.sls', [state_name])
self.assertSaltTrueReturn(ret)
check_file = self.run_function('file.file_exists', [FILEPILLAR])
self.assertTrue(check_file)
|
'Test to ensure when pillar data is not available
in sls file with pillar.get it uses the default
value.'
| def test_managed_file_with_pillardefault_sls(self):
| state_name = 'file-pillardefaultget'
ret = self.run_function('state.sls', [state_name])
self.assertSaltTrueReturn(ret)
check_file = self.run_function('file.file_exists', [FILEPILLARDEF])
self.assertTrue(check_file)
|
'Tests to ensure that file.managed creates directories with the
permissions requested with the dir_mode argument'
| @skip_if_not_root
def test_managed_dir_mode(self):
| desired_mode = 511
name = os.path.join(TMP, 'a', 'managed_dir_mode_test_file')
desired_owner = 'nobody'
ret = self.run_state('file.managed', name=name, source='salt://grail/scene33', mode=600, makedirs=True, user=desired_owner, dir_mode=oct(desired_mode))
if IS_WINDOWS:
expected = "The 'mode' option is not supported on Windows"
self.assertEqual(ret[ret.keys()[0]]['comment'], expected)
self.assertSaltFalseReturn(ret)
return
resulting_mode = stat.S_IMODE(os.stat(os.path.join(TMP, 'a')).st_mode)
resulting_owner = pwd.getpwuid(os.stat(os.path.join(TMP, 'a')).st_uid).pw_name
self.assertEqual(oct(desired_mode), oct(resulting_mode))
self.assertSaltTrueReturn(ret)
self.assertEqual(desired_owner, resulting_owner)
|
'file.managed test interface'
| def test_test_managed(self):
| name = os.path.join(TMP, 'grail_not_not_scene33')
ret = self.run_state('file.managed', test=True, name=name, source='salt://grail/scene33')
self.assertSaltNoneReturn(ret)
self.assertFalse(os.path.isfile(name))
|
'file.managed test interface'
| def test_managed_show_changes_false(self):
| name = os.path.join(TMP, 'grail_not_scene33')
with salt.utils.files.fopen(name, 'wb') as fp_:
fp_.write(six.b('test_managed_show_changes_false\n'))
ret = self.run_state('file.managed', name=name, source='salt://grail/scene33', show_changes=False)
changes = next(six.itervalues(ret))['changes']
self.assertEqual('<show_changes=False>', changes['diff'])
|
'file.managed test that \'salt://|\' protects unusual characters in file path'
| @skipIf(IS_WINDOWS, "Don't know how to fix for Windows")
def test_managed_escaped_file_path(self):
| funny_file = tempfile.mkstemp(prefix='?f!le? n@=3&', suffix='.file type')[1]
funny_file_name = os.path.split(funny_file)[1]
funny_url = ('salt://|' + funny_file_name)
funny_url_path = os.path.join(STATE_DIR, funny_file_name)
state_name = 'funny_file'
state_file_name = (state_name + '.sls')
state_file = os.path.join(STATE_DIR, state_file_name)
state_key = 'file_|-{0}_|-{0}_|-managed'.format(funny_file)
try:
with salt.utils.files.fopen(funny_url_path, 'w'):
pass
with salt.utils.files.fopen(state_file, 'w') as fp_:
fp_.write(textwrap.dedent(' {0}:\n file.managed:\n - source: {1}\n - makedirs: True\n '.format(funny_file, funny_url)))
ret = self.run_function('state.sls', [state_name])
self.assertTrue(ret[state_key]['result'])
finally:
os.remove(state_file)
os.remove(funny_file)
os.remove(funny_url_path)
|
'test file.managed with contents that is a boolean, string, integer,
float, list, and dictionary'
| def test_managed_contents(self):
| state_name = 'file-FileTest-test_managed_contents'
state_filename = (state_name + '.sls')
state_file = os.path.join(STATE_DIR, state_filename)
managed_files = {}
state_keys = {}
for typ in ('bool', 'str', 'int', 'float', 'list', 'dict'):
(fd_, managed_files[typ]) = tempfile.mkstemp()
try:
os.close(fd_)
except OSError as exc:
if (exc.errno != errno.EBADF):
raise exc
state_keys[typ] = 'file_|-{0} file_|-{1}_|-managed'.format(typ, managed_files[typ])
try:
with salt.utils.files.fopen(state_file, 'w') as fd_:
fd_.write(textwrap.dedent(' bool file:\n file.managed:\n - name: {bool}\n - contents: True\n\n str file:\n file.managed:\n - name: {str}\n - contents: Salt was here.\n\n int file:\n file.managed:\n - name: {int}\n - contents: 340282366920938463463374607431768211456\n\n float file:\n file.managed:\n - name: {float}\n - contents: 1.7518e-45 # gravitational coupling constant\n\n list file:\n file.managed:\n - name: {list}\n - contents: [1, 1, 2, 3, 5, 8, 13]\n\n dict file:\n file.managed:\n - name: {dict}\n - contents:\n C: charge\n P: parity\n T: time\n '.format(**managed_files)))
ret = self.run_function('state.sls', [state_name])
for typ in state_keys:
self.assertTrue(ret[state_keys[typ]]['result'])
self.assertIn('diff', ret[state_keys[typ]]['changes'])
finally:
os.remove(state_file)
for typ in managed_files:
os.remove(managed_files[typ])
|
'Test file.managed passing a basic check_cmd kwarg. See Issue #38111.'
| @skip_if_not_root
@skipIf(IS_WINDOWS, 'Windows does not support "mode" kwarg. Skipping.')
def test_managed_check_cmd(self):
| r_group = 'root'
if salt.utils.platform.is_darwin():
r_group = 'wheel'
if (not salt.utils.path.which('visudo')):
self.fail('sudo is missing')
try:
ret = self.run_state('file.managed', name='/tmp/sudoers', user='root', group=r_group, mode=440, check_cmd='visudo -c -s -f')
self.assertSaltTrueReturn(ret)
self.assertInSaltComment('Empty file', ret)
self.assertEqual(ret['file_|-/tmp/sudoers_|-/tmp/sudoers_|-managed']['changes'], {'new': 'file /tmp/sudoers created', 'mode': '0440'})
finally:
if os.path.exists('/tmp/sudoers'):
os.remove('/tmp/sudoers')
|
'file.directory'
| def test_directory(self):
| name = os.path.join(TMP, 'a_new_dir')
ret = self.run_state('file.directory', name=name)
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isdir(name))
|
'Ensure that symlinks are followed when file.directory is run with
test=True'
| def test_directory_symlink_dry_run(self):
| try:
tmp_dir = os.path.join(TMP, 'pgdata')
sym_dir = os.path.join(TMP, 'pg_data')
os.mkdir(tmp_dir, 448)
os.symlink(tmp_dir, sym_dir)
ret = self.run_state('file.directory', test=True, name=sym_dir, follow_symlinks=True, mode=700)
self.assertSaltTrueReturn(ret)
finally:
if os.path.isdir(tmp_dir):
shutil.rmtree(tmp_dir)
if os.path.islink(sym_dir):
os.unlink(sym_dir)
|
'file.directory
Test the max_depth option by iteratively increasing the depth and
checking that no changes deeper than max_depth have been attempted'
| @skip_if_not_root
@skipIf(IS_WINDOWS, 'Mode not available in Windows')
def test_directory_max_depth(self):
| def _get_oct_mode(name):
'\n Return a string octal representation of the permissions for name\n '
return salt.utils.normalize_mode(oct((os.stat(name).st_mode & 511)))
top = os.path.join(TMP, 'top_dir')
sub = os.path.join(top, 'sub_dir')
subsub = os.path.join(sub, 'sub_sub_dir')
dirs = [top, sub, subsub]
initial_mode = '0111'
changed_mode = '0555'
if (not os.path.isdir(subsub)):
os.makedirs(subsub, int(initial_mode, 8))
try:
for depth in range(0, 3):
ret = self.run_state('file.directory', name=top, max_depth=depth, dir_mode=changed_mode, recurse=['mode'])
self.assertSaltTrueReturn(ret)
for changed_dir in dirs[0:(depth + 1)]:
self.assertEqual(changed_mode, _get_oct_mode(changed_dir))
for untouched_dir in dirs[(depth + 1):]:
self.assertEqual(initial_mode, _get_oct_mode(untouched_dir))
finally:
shutil.rmtree(top)
|
'file.directory'
| def test_test_directory(self):
| name = os.path.join(TMP, 'a_not_dir')
ret = self.run_state('file.directory', test=True, name=name)
self.assertSaltNoneReturn(ret)
self.assertFalse(os.path.isdir(name))
|
'file.directory with clean=True'
| def test_directory_clean(self):
| name = os.path.join(TMP, 'directory_clean_dir')
if (not os.path.isdir(name)):
os.makedirs(name)
strayfile = os.path.join(name, 'strayfile')
with salt.utils.files.fopen(strayfile, 'w'):
pass
straydir = os.path.join(name, 'straydir')
if (not os.path.isdir(straydir)):
os.makedirs(straydir)
with salt.utils.files.fopen(os.path.join(straydir, 'strayfile2'), 'w'):
pass
ret = self.run_state('file.directory', name=name, clean=True)
try:
self.assertSaltTrueReturn(ret)
self.assertFalse(os.path.exists(strayfile))
self.assertFalse(os.path.exists(straydir))
self.assertTrue(os.path.isdir(name))
finally:
shutil.rmtree(name, ignore_errors=True)
|
'file.directory with clean=True and exclude_pat set'
| def test_directory_clean_exclude(self):
| name = os.path.join(TMP, 'directory_clean_dir')
if (not os.path.isdir(name)):
os.makedirs(name)
strayfile = os.path.join(name, 'strayfile')
with salt.utils.files.fopen(strayfile, 'w'):
pass
straydir = os.path.join(name, 'straydir')
if (not os.path.isdir(straydir)):
os.makedirs(straydir)
strayfile2 = os.path.join(straydir, 'strayfile2')
with salt.utils.files.fopen(strayfile2, 'w'):
pass
keepfile = os.path.join(straydir, 'keepfile')
with salt.utils.files.fopen(keepfile, 'w'):
pass
exclude_pat = 'E@^straydir(|/keepfile)$'
if IS_WINDOWS:
exclude_pat = 'E@^straydir(|\\\\keepfile)$'
ret = self.run_state('file.directory', name=name, clean=True, exclude_pat=exclude_pat)
try:
self.assertSaltTrueReturn(ret)
self.assertFalse(os.path.exists(strayfile))
self.assertFalse(os.path.exists(strayfile2))
self.assertTrue(os.path.exists(keepfile))
finally:
shutil.rmtree(name, ignore_errors=True)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.