desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'file.directory with test=True, clean=True and exclude_pat set'
| def test_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', test=True, name=name, clean=True, exclude_pat=exclude_pat)
comment = next(six.itervalues(ret))['comment']
try:
self.assertSaltNoneReturn(ret)
self.assertTrue(os.path.exists(strayfile))
self.assertTrue(os.path.exists(strayfile2))
self.assertTrue(os.path.exists(keepfile))
self.assertIn(strayfile, comment)
self.assertIn(strayfile2, comment)
self.assertNotIn(keepfile, comment)
finally:
shutil.rmtree(name, ignore_errors=True)
|
'file.directory test with clean=True and require_in file'
| def test_directory_clean_require_in(self):
| state_name = 'file-FileTest-test_directory_clean_require_in'
state_filename = (state_name + '.sls')
state_file = os.path.join(STATE_DIR, state_filename)
directory = tempfile.mkdtemp()
self.addCleanup((lambda : shutil.rmtree(directory)))
wrong_file = os.path.join(directory, 'wrong')
with salt.utils.files.fopen(wrong_file, 'w') as fp:
fp.write('foo')
good_file = os.path.join(directory, 'bar')
with salt.utils.files.fopen(state_file, 'w') as fp:
self.addCleanup((lambda : os.remove(state_file)))
fp.write(textwrap.dedent(' some_dir:\n file.directory:\n - name: {directory}\n - clean: true\n\n {good_file}:\n file.managed:\n - require_in:\n - file: some_dir\n '.format(directory=directory, good_file=good_file)))
ret = self.run_function('state.sls', [state_name])
self.assertTrue(os.path.exists(good_file))
self.assertFalse(os.path.exists(wrong_file))
|
'file.directory test with clean=True and require_in file with an ID
different from the file name'
| def test_directory_clean_require_in_with_id(self):
| state_name = 'file-FileTest-test_directory_clean_require_in_with_id'
state_filename = (state_name + '.sls')
state_file = os.path.join(STATE_DIR, state_filename)
directory = tempfile.mkdtemp()
self.addCleanup((lambda : shutil.rmtree(directory)))
wrong_file = os.path.join(directory, 'wrong')
with salt.utils.files.fopen(wrong_file, 'w') as fp:
fp.write('foo')
good_file = os.path.join(directory, 'bar')
with salt.utils.files.fopen(state_file, 'w') as fp:
self.addCleanup((lambda : os.remove(state_file)))
fp.write(textwrap.dedent(' some_dir:\n file.directory:\n - name: {directory}\n - clean: true\n\n some_file:\n file.managed:\n - name: {good_file}\n - require_in:\n - file: some_dir\n '.format(directory=directory, good_file=good_file)))
ret = self.run_function('state.sls', [state_name])
self.assertTrue(os.path.exists(good_file))
self.assertFalse(os.path.exists(wrong_file))
|
'file.directory test with clean=True and require with a file state
relatively to the state\'s name, not its ID.'
| def test_directory_clean_require_with_name(self):
| state_name = 'file-FileTest-test_directory_clean_require_in_with_id'
state_filename = (state_name + '.sls')
state_file = os.path.join(STATE_DIR, state_filename)
directory = tempfile.mkdtemp()
self.addCleanup((lambda : shutil.rmtree(directory)))
wrong_file = os.path.join(directory, 'wrong')
with salt.utils.files.fopen(wrong_file, 'w') as fp:
fp.write('foo')
good_file = os.path.join(directory, 'bar')
with salt.utils.files.fopen(state_file, 'w') as fp:
self.addCleanup((lambda : os.remove(state_file)))
fp.write(textwrap.dedent(' some_dir:\n file.directory:\n - name: {directory}\n - clean: true\n - require:\n # This requirement refers to the name of the following\n # state, not its ID.\n - file: {good_file}\n\n some_file:\n file.managed:\n - name: {good_file}\n '.format(directory=directory, good_file=good_file)))
ret = self.run_function('state.sls', [state_name])
self.assertTrue(os.path.exists(good_file))
self.assertFalse(os.path.exists(wrong_file))
|
'file.recurse'
| def test_recurse(self):
| name = os.path.join(TMP, 'recurse_dir')
ret = self.run_state('file.recurse', name=name, source='salt://grail')
try:
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isfile(os.path.join(name, '36', 'scene')))
finally:
if os.path.isdir(name):
shutil.rmtree(name, ignore_errors=True)
|
'file.recurse passing __env__'
| def test_recurse_specific_env(self):
| name = os.path.join(TMP, 'recurse_dir_prod_env')
ret = self.run_state('file.recurse', name=name, source='salt://holy', __env__='prod')
try:
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isfile(os.path.join(name, '32', 'scene')))
finally:
if os.path.isdir(name):
shutil.rmtree(name, ignore_errors=True)
name = os.path.join(TMP, 'recurse_dir_prod_env')
ret = self.run_state('file.recurse', name=name, source='salt://holy', saltenv='prod')
try:
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isfile(os.path.join(name, '32', 'scene')))
finally:
if os.path.isdir(name):
shutil.rmtree(name, ignore_errors=True)
|
'file.recurse passing __env__'
| def test_recurse_specific_env_in_url(self):
| name = os.path.join(TMP, 'recurse_dir_prod_env')
ret = self.run_state('file.recurse', name=name, source='salt://holy?saltenv=prod')
try:
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isfile(os.path.join(name, '32', 'scene')))
finally:
if os.path.isdir(name):
shutil.rmtree(name, ignore_errors=True)
name = os.path.join(TMP, 'recurse_dir_prod_env')
ret = self.run_state('file.recurse', name=name, source='salt://holy?saltenv=prod')
try:
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isfile(os.path.join(name, '32', 'scene')))
finally:
if os.path.isdir(name):
shutil.rmtree(name, ignore_errors=True)
|
'file.recurse test interface'
| def test_test_recurse(self):
| name = os.path.join(TMP, 'recurse_test_dir')
ret = self.run_state('file.recurse', test=True, name=name, source='salt://grail')
self.assertSaltNoneReturn(ret)
self.assertFalse(os.path.isfile(os.path.join(name, '36', 'scene')))
self.assertFalse(os.path.exists(name))
|
'file.recurse test interface'
| def test_test_recurse_specific_env(self):
| name = os.path.join(TMP, 'recurse_test_dir_prod_env')
ret = self.run_state('file.recurse', test=True, name=name, source='salt://holy', __env__='prod')
self.assertSaltNoneReturn(ret)
self.assertFalse(os.path.isfile(os.path.join(name, '32', 'scene')))
self.assertFalse(os.path.exists(name))
name = os.path.join(TMP, 'recurse_test_dir_prod_env')
ret = self.run_state('file.recurse', test=True, name=name, source='salt://holy', saltenv='prod')
self.assertSaltNoneReturn(ret)
self.assertFalse(os.path.isfile(os.path.join(name, '32', 'scene')))
self.assertFalse(os.path.exists(name))
|
'file.recurse with jinja template enabled'
| def test_recurse_template(self):
| _ts = 'TEMPLATE TEST STRING'
name = os.path.join(TMP, 'recurse_template_dir')
ret = self.run_state('file.recurse', name=name, source='salt://grail', template='jinja', defaults={'spam': _ts})
try:
self.assertSaltTrueReturn(ret)
with salt.utils.files.fopen(os.path.join(name, 'scene33'), 'r') as fp_:
contents = fp_.read()
self.assertIn(_ts, contents)
finally:
shutil.rmtree(name, ignore_errors=True)
|
'file.recurse with clean=True'
| def test_recurse_clean(self):
| name = os.path.join(TMP, 'recurse_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
with salt.utils.files.fopen(os.path.join(name, '36'), 'w'):
pass
os.makedirs(os.path.join(name, 'scene33'))
ret = self.run_state('file.recurse', name=name, source='salt://grail', clean=True)
try:
self.assertSaltTrueReturn(ret)
self.assertFalse(os.path.exists(strayfile))
self.assertTrue(os.path.isfile(os.path.join(name, '36', 'scene')))
self.assertTrue(os.path.isfile(os.path.join(name, 'scene33')))
finally:
shutil.rmtree(name, ignore_errors=True)
|
'file.recurse with clean=True and __env__=prod'
| def test_recurse_clean_specific_env(self):
| name = os.path.join(TMP, 'recurse_clean_dir_prod_env')
if (not os.path.isdir(name)):
os.makedirs(name)
strayfile = os.path.join(name, 'strayfile')
with salt.utils.files.fopen(strayfile, 'w'):
pass
with salt.utils.files.fopen(os.path.join(name, '32'), 'w'):
pass
os.makedirs(os.path.join(name, 'scene34'))
ret = self.run_state('file.recurse', name=name, source='salt://holy', clean=True, __env__='prod')
try:
self.assertSaltTrueReturn(ret)
self.assertFalse(os.path.exists(strayfile))
self.assertTrue(os.path.isfile(os.path.join(name, '32', 'scene')))
self.assertTrue(os.path.isfile(os.path.join(name, 'scene34')))
finally:
shutil.rmtree(name, ignore_errors=True)
|
'This tests the case where the source dir for the file.recurse state
does not contain any files (only subdirectories), and the dir_mode is
being managed. For a long time, this corner case resulted in the top
level of the destination directory being created with the wrong initial
permissions, a problem that would be corrected later on in the
file.recurse state via running state.directory. However, the
file.directory state only gets called when there are files to be
managed in that directory, and when the source directory contains only
subdirectories, the incorrectly-set initial perms would not be
repaired.
This was fixed in https://github.com/saltstack/salt/pull/35309'
| def test_recurse_issue_34945(self):
| dir_mode = '2775'
issue_dir = 'issue-34945'
name = os.path.join(TMP, issue_dir)
try:
ret = self.run_state('file.recurse', name=name, source=('salt://' + issue_dir), dir_mode=dir_mode)
self.assertSaltTrueReturn(ret)
actual_dir_mode = oct(stat.S_IMODE(os.stat(name).st_mode))[(-4):]
self.assertEqual(dir_mode, actual_dir_mode)
finally:
shutil.rmtree(name, ignore_errors=True)
|
'file.replace'
| def test_replace(self):
| name = os.path.join(TMP, 'replace_test')
with salt.utils.files.fopen(name, 'w+') as fp_:
fp_.write('change_me')
ret = self.run_state('file.replace', name=name, pattern='change', repl='salt', backup=False)
try:
with salt.utils.files.fopen(name, 'r') as fp_:
self.assertIn('salt', fp_.read())
self.assertSaltTrueReturn(ret)
finally:
os.remove(name)
|
'Test the (mis-)behaviour of file.replace as described in #18612:
Using \'prepend_if_not_found\' or \'append_if_not_found\' resulted in
an infinitely growing file as \'file.replace\' didn\'t check beforehand
whether the changes had already been done to the file
# Case description:
The tested file contains one commented line
The commented line should be uncommented in the end, nothing else should change'
| def test_replace_issue_18612(self):
| test_name = 'test_replace_issue_18612'
path_test = os.path.join(TMP, test_name)
with salt.utils.files.fopen(path_test, 'w+') as fp_test_:
fp_test_.write('# en_US.UTF-8')
ret = []
for x in range(0, 3):
ret.append(self.run_state('file.replace', name=path_test, pattern='^# en_US.UTF-8$', repl='en_US.UTF-8', append_if_not_found=True))
try:
with salt.utils.files.fopen(path_test, 'r') as fp_test_:
self.assertTrue((sum((1 for _ in fp_test_)) == 1))
with salt.utils.files.fopen(path_test, 'r') as fp_test_:
self.assertTrue(fp_test_.read().startswith('en_US.UTF-8'))
for item in ret:
self.assertSaltTrueReturn(item)
finally:
os.remove(path_test)
|
'Test the (mis-)behaviour of file.replace as described in #18612:
Using \'prepend_if_not_found\' or \'append_if_not_found\' resulted in
an infinitely growing file as \'file.replace\' didn\'t check beforehand
whether the changes had already been done to the file
# Case description:
The tested multifile contains multiple lines not matching the pattern or replacement in any way
The replacement pattern should be prepended to the file'
| def test_replace_issue_18612_prepend(self):
| test_name = 'test_replace_issue_18612_prepend'
path_in = os.path.join(FILES, 'file.replace', '{0}.in'.format(test_name))
path_out = os.path.join(FILES, 'file.replace', '{0}.out'.format(test_name))
path_test = os.path.join(TMP, test_name)
shutil.copyfile(path_in, path_test)
ret = []
for x in range(0, 3):
ret.append(self.run_state('file.replace', name=path_test, pattern='^# en_US.UTF-8$', repl='en_US.UTF-8', prepend_if_not_found=True))
try:
self.assertTrue(filecmp.cmp(path_test, path_out))
self.assertTrue(filecmp.cmp((path_test + '.bak'), path_in))
for item in ret:
self.assertSaltTrueReturn(item)
finally:
os.remove(path_test)
|
'Test the (mis-)behaviour of file.replace as described in #18612:
Using \'prepend_if_not_found\' or \'append_if_not_found\' resulted in
an infinitely growing file as \'file.replace\' didn\'t check beforehand
whether the changes had already been done to the file
# Case description:
The tested multifile contains multiple lines not matching the pattern or replacement in any way
The replacement pattern should be appended to the file'
| def test_replace_issue_18612_append(self):
| test_name = 'test_replace_issue_18612_append'
path_in = os.path.join(FILES, 'file.replace', '{0}.in'.format(test_name))
path_out = os.path.join(FILES, 'file.replace', '{0}.out'.format(test_name))
path_test = os.path.join(TMP, test_name)
shutil.copyfile(path_in, path_test)
ret = []
for x in range(0, 3):
ret.append(self.run_state('file.replace', name=path_test, pattern='^# en_US.UTF-8$', repl='en_US.UTF-8', append_if_not_found=True))
try:
self.assertTrue(filecmp.cmp(path_test, path_out))
self.assertTrue(filecmp.cmp((path_test + '.bak'), path_in))
for item in ret:
self.assertSaltTrueReturn(item)
finally:
os.remove(path_test)
|
'Test the (mis-)behaviour of file.replace as described in #18612:
Using \'prepend_if_not_found\' or \'append_if_not_found\' resulted in
an infinitely growing file as \'file.replace\' didn\'t check beforehand
whether the changes had already been done to the file
# Case description:
The tested multifile contains multiple lines not matching the pattern or replacement in any way
The \'not_found_content\' value should be appended to the file'
| def test_replace_issue_18612_append_not_found_content(self):
| test_name = 'test_replace_issue_18612_append_not_found_content'
path_in = os.path.join(FILES, 'file.replace', '{0}.in'.format(test_name))
path_out = os.path.join(FILES, 'file.replace', '{0}.out'.format(test_name))
path_test = os.path.join(TMP, test_name)
shutil.copyfile(path_in, path_test)
ret = []
for x in range(0, 3):
ret.append(self.run_state('file.replace', name=path_test, pattern='^# en_US.UTF-8$', repl='en_US.UTF-8', append_if_not_found=True, not_found_content="THIS LINE WASN'T FOUND! SO WE'RE APPENDING IT HERE!"))
try:
self.assertTrue(filecmp.cmp(path_test, path_out))
self.assertTrue(filecmp.cmp((path_test + '.bak'), path_in))
for item in ret:
self.assertSaltTrueReturn(item)
finally:
os.remove(path_test)
|
'Test the (mis-)behaviour of file.replace as described in #18612:
Using \'prepend_if_not_found\' or \'append_if_not_found\' resulted in
an infinitely growing file as \'file.replace\' didn\'t check beforehand
whether the changes had already been done to the file
# Case description:
The tested file contains 5 key=value pairs
The commented key=value pair #foo=bar should be changed to foo=salt
The comment char (#) in front of foo=bar should be removed'
| def test_replace_issue_18612_change_mid_line_with_comment(self):
| test_name = 'test_replace_issue_18612_change_mid_line_with_comment'
path_in = os.path.join(FILES, 'file.replace', '{0}.in'.format(test_name))
path_out = os.path.join(FILES, 'file.replace', '{0}.out'.format(test_name))
path_test = os.path.join(TMP, test_name)
shutil.copyfile(path_in, path_test)
ret = []
for x in range(0, 3):
ret.append(self.run_state('file.replace', name=path_test, pattern='^#foo=bar$', repl='foo=salt', append_if_not_found=True))
try:
self.assertTrue(filecmp.cmp(path_test, path_out))
self.assertTrue(filecmp.cmp((path_test + '.bak'), path_in))
for item in ret:
self.assertSaltTrueReturn(item)
finally:
os.remove(path_test)
|
'Test the (mis-)behaviour of file.replace as described in #18841:
Using file.replace in a way which shouldn\'t modify the file at all
results in changed mtime of the original file and a backup file being created.
# Case description
The tested file contains multiple lines
The tested file contains a line already matching the replacement (no change needed)
The tested file\'s content shouldn\'t change at all
The tested file\'s mtime shouldn\'t change at all
No backup file should be created'
| def test_replace_issue_18841_no_changes(self):
| test_name = 'test_replace_issue_18841_no_changes'
path_in = os.path.join(FILES, 'file.replace', '{0}.in'.format(test_name))
path_test = os.path.join(TMP, test_name)
shutil.copyfile(path_in, path_test)
fstats_orig = os.stat(path_test)
age = (((5 * 24) * 60) * 60)
os.utime(path_test, ((fstats_orig.st_mtime - age), (fstats_orig.st_atime - age)))
ret = self.run_state('file.replace', name=path_test, pattern='^hello world$', repl='goodbye world', show_changes=True, flags=['IGNORECASE'], backup=False)
fstats_post = os.stat(path_test)
try:
self.assertTrue(filecmp.cmp(path_in, path_test))
self.assertFalse(os.path.exists((path_test + '.bak')))
self.assertTrue(fstats_post.st_mtime, (fstats_orig.st_mtime - age))
self.assertSaltTrueReturn(ret)
finally:
os.remove(path_test)
|
'Test to ensure that file.serialize returns a data structure that\'s
both serialized and formatted properly'
| def test_serialize(self):
| path_test = os.path.join(TMP, 'test_serialize')
ret = self.run_state('file.serialize', name=path_test, dataset={'name': 'naive', 'description': 'A basic test', 'a_list': ['first_element', 'second_element'], 'finally': 'the last item'}, formatter='json')
with salt.utils.files.fopen(path_test, 'r') as fp_:
serialized_file = fp_.read()
expected_file = '{\n "a_list": [\n "first_element",\n "second_element"\n ],\n "description": "A basic test",\n "finally": "the last item",\n "name": "naive"\n}\n'
self.assertEqual(serialized_file, expected_file)
|
'Test the (mis-)behaviour of file.replace as described in #18841:
Using file.replace in a way which shouldn\'t modify the file at all
results in changed mtime of the original file and a backup file being created.
# Case description
The tested file contains multiple lines
The tested file contains a line already matching the replacement (no change needed)
The tested file\'s content shouldn\'t change at all
The tested file\'s mtime shouldn\'t change at all
No backup file should be created, although backup=False isn\'t explicitly defined'
| def test_replace_issue_18841_omit_backup(self):
| test_name = 'test_replace_issue_18841_omit_backup'
path_in = os.path.join(FILES, 'file.replace', '{0}.in'.format(test_name))
path_test = os.path.join(TMP, test_name)
shutil.copyfile(path_in, path_test)
fstats_orig = os.stat(path_test)
age = (((5 * 24) * 60) * 60)
os.utime(path_test, ((fstats_orig.st_mtime - age), (fstats_orig.st_atime - age)))
ret = self.run_state('file.replace', name=path_test, pattern='^hello world$', repl='goodbye world', show_changes=True, flags=['IGNORECASE'])
fstats_post = os.stat(path_test)
try:
self.assertTrue(filecmp.cmp(path_in, path_test))
self.assertFalse(os.path.exists((path_test + '.bak')))
self.assertTrue(fstats_post.st_mtime, (fstats_orig.st_mtime - age))
self.assertSaltTrueReturn(ret)
finally:
os.remove(path_test)
|
'file.comment'
| def test_comment(self):
| name = os.path.join(TMP, 'comment_test')
try:
with salt.utils.files.fopen(name, 'w+') as fp_:
fp_.write('comment_me')
ret = self.run_state('file.comment', test=True, name=name, regex='^comment')
self.assertSaltNoneReturn(ret)
ret = self.run_state('file.comment', name=name, regex='^comment')
self.assertSaltTrueReturn(ret)
with salt.utils.files.fopen(name, 'r') as fp_:
self.assertTrue(fp_.read().startswith('#comment'))
ret = self.run_state('file.comment', name=name, regex='^comment')
self.assertSaltTrueReturn(ret)
with salt.utils.files.fopen(name, 'r') as fp_:
self.assertTrue(fp_.read().startswith('#comment'))
ret = self.run_state('file.comment', test=True, name=name, regex='^comment')
self.assertSaltTrueReturn(ret)
finally:
os.remove(name)
|
'file.comment test interface'
| def test_test_comment(self):
| name = os.path.join(TMP, 'comment_test_test')
try:
with salt.utils.files.fopen(name, 'w+') as fp_:
fp_.write('comment_me')
ret = self.run_state('file.comment', test=True, name=name, regex='.*comment.*')
with salt.utils.files.fopen(name, 'r') as fp_:
self.assertNotIn('#comment', fp_.read())
self.assertSaltNoneReturn(ret)
finally:
os.remove(name)
|
'file.uncomment'
| def test_uncomment(self):
| name = os.path.join(TMP, 'uncomment_test')
try:
with salt.utils.files.fopen(name, 'w+') as fp_:
fp_.write('#comment_me')
ret = self.run_state('file.uncomment', name=name, regex='^comment')
with salt.utils.files.fopen(name, 'r') as fp_:
self.assertNotIn('#comment', fp_.read())
self.assertSaltTrueReturn(ret)
finally:
os.remove(name)
|
'file.comment test interface'
| def test_test_uncomment(self):
| name = os.path.join(TMP, 'uncomment_test_test')
try:
with salt.utils.files.fopen(name, 'w+') as fp_:
fp_.write('#comment_me')
ret = self.run_state('file.uncomment', test=True, name=name, regex='^comment.*')
with salt.utils.files.fopen(name, 'r') as fp_:
self.assertIn('#comment', fp_.read())
self.assertSaltNoneReturn(ret)
finally:
os.remove(name)
|
'file.append'
| def test_append(self):
| name = os.path.join(TMP, 'append_test')
try:
with salt.utils.files.fopen(name, 'w+') as fp_:
fp_.write('#salty!')
ret = self.run_state('file.append', name=name, text='cheese')
with salt.utils.files.fopen(name, 'r') as fp_:
self.assertIn('cheese', fp_.read())
self.assertSaltTrueReturn(ret)
finally:
os.remove(name)
|
'file.append test interface'
| def test_test_append(self):
| name = os.path.join(TMP, 'append_test_test')
try:
with salt.utils.files.fopen(name, 'w+') as fp_:
fp_.write('#salty!')
ret = self.run_state('file.append', test=True, name=name, text='cheese')
with salt.utils.files.fopen(name, 'r') as fp_:
self.assertNotIn('cheese', fp_.read())
self.assertSaltNoneReturn(ret)
finally:
os.remove(name)
|
'file.append but create directories if needed as an option, and create
the file if it doesn\'t exist'
| def test_append_issue_1864_makedirs(self):
| fname = 'append_issue_1864_makedirs'
name = os.path.join(TMP, fname)
try:
self.assertFalse(os.path.exists(name))
except AssertionError:
os.remove(name)
try:
if os.path.isfile(name):
os.remove(name)
ret = self.run_state('file.append', name=name, text='cheese', makedirs=True)
self.assertSaltTrueReturn(ret)
finally:
if os.path.isfile(name):
os.remove(name)
name = os.path.join(TMP, 'issue_1864', fname)
try:
ret = self.run_state('file.append', name=name, text='cheese', makedirs=True)
self.assertSaltTrueReturn(ret)
finally:
if os.path.isfile(name):
os.remove(name)
try:
ret = self.run_state('file.append', name=name, text='cheese')
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isfile(name))
finally:
shutil.rmtree(os.path.join(TMP, 'issue_1864'), ignore_errors=True)
|
'file.prepend but create directories if needed as an option, and create
the file if it doesn\'t exist'
| def test_prepend_issue_27401_makedirs(self):
| fname = 'prepend_issue_27401'
name = os.path.join(TMP, fname)
try:
self.assertFalse(os.path.exists(name))
except AssertionError:
os.remove(name)
try:
if os.path.isfile(name):
os.remove(name)
ret = self.run_state('file.prepend', name=name, text='cheese', makedirs=True)
self.assertSaltTrueReturn(ret)
finally:
if os.path.isfile(name):
os.remove(name)
name = os.path.join(TMP, 'issue_27401', fname)
try:
ret = self.run_state('file.prepend', name=name, text='cheese', makedirs=True)
self.assertSaltTrueReturn(ret)
finally:
if os.path.isfile(name):
os.remove(name)
try:
ret = self.run_state('file.prepend', name=name, text='cheese')
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isfile(name))
finally:
shutil.rmtree(os.path.join(TMP, 'issue_27401'), ignore_errors=True)
|
'file.touch'
| def test_touch(self):
| name = os.path.join(TMP, 'touch_test')
ret = self.run_state('file.touch', name=name)
try:
self.assertTrue(os.path.isfile(name))
self.assertSaltTrueReturn(ret)
finally:
os.remove(name)
|
'file.touch test interface'
| def test_test_touch(self):
| name = os.path.join(TMP, 'touch_test')
ret = self.run_state('file.touch', test=True, name=name)
self.assertFalse(os.path.isfile(name))
self.assertSaltNoneReturn(ret)
|
'file.touch a directory'
| def test_touch_directory(self):
| name = os.path.join(TMP, 'touch_test_dir')
try:
if (not os.path.isdir(name)):
os.makedirs(name)
except OSError:
self.skipTest('Failed to create directory {0}'.format(name))
self.assertTrue(os.path.isdir(name))
ret = self.run_state('file.touch', name=name)
try:
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isdir(name))
finally:
os.removedirs(name)
|
'Text to append includes a percent symbol'
| def test_issue_2227_file_append(self):
| tmp_file_append = os.path.join(TMP, 'test.append')
if os.path.isfile(tmp_file_append):
os.remove(tmp_file_append)
self.run_function('state.sls', mods='testappend')
self.run_function('state.sls', mods='testappend.step1')
self.run_function('state.sls', mods='testappend.step2')
try:
ret = self.run_function('state.sls', mods='testappend.issue-2227')
self.assertSaltTrueReturn(ret)
with salt.utils.files.fopen(tmp_file_append, 'r') as fp_:
contents_pre = fp_.read()
ret = self.run_function('state.sls', mods='testappend.issue-2227')
self.assertSaltTrueReturn(ret)
with salt.utils.files.fopen(tmp_file_append, 'r') as fp_:
contents_post = fp_.read()
self.assertEqual(contents_pre, contents_post)
except AssertionError:
if os.path.exists(tmp_file_append):
shutil.copy(tmp_file_append, (tmp_file_append + '.bak'))
raise
finally:
if os.path.isfile(tmp_file_append):
os.remove(tmp_file_append)
|
'Test some file operation with utf-8 characters on the sls
This is more generic than just a file test. Feel free to move'
| @skipIf(six.PY3, 'This test will have a LOT of rewriting to support both Py2 and Py3')
@skipIf(IS_WINDOWS, "Don't know how to fix for Windows")
def test_issue_8947_utf8_sls(self):
| korean_1 = u'\ud55c\uad6d\uc5b4 \uc2dc\ud5d8'
korean_2 = u'\uccab \ubc88\uc9f8 \ud589'
korean_3 = u'\ub9c8\uc9c0\ub9c9 \ud589'
test_file = os.path.join(TMP, u'salt_utf8_tests', u'{0}.txt'.format(korean_1))
test_file_encoded = salt.utils.stringutils.to_str(test_file)
template_path = os.path.join(TMP_STATE_TREE, 'issue-8947.sls')
template_lines = [u'# -*- coding: utf-8 -*-', u'some-utf8-file-create:', u' file.managed:', u" - name: '{0}'".format(test_file), u' - contents: {0}'.format(korean_1), u' - makedirs: True', u' - replace: True', u' - show_diff: True', u'some-utf8-file-create2:', u' file.managed:', u" - name: '{0}'".format(test_file), u' - contents: |', u' {0}'.format(korean_2), u' {0}'.format(korean_1), u' {0}'.format(korean_3), u' - replace: True', u' - show_diff: True', u'some-utf8-file-exists:', u' file.exists:', u" - name: '{0}'".format(test_file), u' - require:', u' - file: some-utf8-file-create2', u'some-utf8-file-content-test:', u' cmd.run:', u' - name: \'cat "{0}"\''.format(test_file), u' - require:', u' - file: some-utf8-file-exists', u'some-utf8-file-content-remove:', u' cmd.run:', u' - name: \'rm -f "{0}"\''.format(test_file), u' - require:', u' - cmd: some-utf8-file-content-test', u'some-utf8-file-removed:', u' file.missing:', u" - name: '{0}'".format(test_file), u' - require:', u' - cmd: some-utf8-file-content-remove']
with salt.utils.files.fopen(template_path, 'wb') as fp_:
fp_.write(salt.utils.stringutils.to_bytes(os.linesep.join(template_lines)))
try:
ret = self.run_function('state.sls', mods='issue-8947')
if (not isinstance(ret, dict)):
raise AssertionError('Something went really wrong while testing this sls: {0}'.format(repr(ret)))
if (sys.version_info < (2, 7)):
utf_diff = '--- \n+++ \n@@ -1,1 +1,3 @@\n'
else:
utf_diff = '--- \n+++ \n@@ -1 +1,3 @@\n'
utf_diff += salt.utils.stringutils.to_str(u'+\uccab \ubc88\uc9f8 \ud589\n \ud55c\uad6d\uc5b4 \uc2dc\ud5d8\n+\ub9c8\uc9c0\ub9c9 \ud589\n')
expected = {'file_|-some-utf8-file-create_|-{0}_|-managed'.format(test_file_encoded): {'name': '{0}'.format(test_file_encoded), '__run_num__': 0, 'comment': 'File {0} updated'.format(test_file_encoded), 'diff': 'New file'}, 'file_|-some-utf8-file-create2_|-{0}_|-managed'.format(test_file_encoded): {'name': '{0}'.format(test_file_encoded), '__run_num__': 1, 'comment': 'File {0} updated'.format(test_file_encoded), 'diff': utf_diff}, 'file_|-some-utf8-file-exists_|-{0}_|-exists'.format(test_file_encoded): {'name': '{0}'.format(test_file_encoded), '__run_num__': 2, 'comment': 'Path {0} exists'.format(test_file_encoded)}, 'cmd_|-some-utf8-file-content-test_|-cat "{0}"_|-run'.format(test_file_encoded): {'name': 'cat "{0}"'.format(test_file_encoded), '__run_num__': 3, 'comment': 'Command "cat "{0}"" run'.format(test_file_encoded), 'stdout': '{0}\n{1}\n{2}'.format(salt.utils.stringutils.to_str(korean_2), salt.utils.stringutils.to_str(korean_1), salt.utils.stringutils.to_str(korean_3))}, 'cmd_|-some-utf8-file-content-remove_|-rm -f "{0}"_|-run'.format(test_file_encoded): {'name': 'rm -f "{0}"'.format(test_file_encoded), '__run_num__': 4, 'comment': 'Command "rm -f "{0}"" run'.format(test_file_encoded), 'stdout': ''}, 'file_|-some-utf8-file-removed_|-{0}_|-missing'.format(test_file_encoded): {'name': '{0}'.format(test_file_encoded), '__run_num__': 5, 'comment': 'Path {0} is missing'.format(test_file_encoded)}}
result = {}
for (name, step) in six.iteritems(ret):
self.assertSaltTrueReturn({name: step})
result.update({name: {'name': step['name'], '__run_num__': step['__run_num__'], 'comment': step['comment']}})
if ('diff' in step['changes']):
result[name]['diff'] = step['changes']['diff']
if ('stdout' in step['changes']):
result[name]['stdout'] = step['changes']['stdout']
self.maxDiff = None
self.assertEqual(expected, result)
cat_id = 'cmd_|-some-utf8-file-content-test_|-cat "{0}"_|-run'.format(test_file_encoded)
self.assertEqual(result[cat_id]['stdout'], salt.utils.stringutils.to_str(((((korean_2 + '\n') + korean_1) + '\n') + korean_3)))
finally:
if os.path.isdir(test_file):
os.unlink(test_file)
os.unlink(template_path)
|
'Ensure that symlinks are properly chowned when recursing (following
symlinks)'
| @skip_if_not_root
@skipIf((not HAS_PWD), 'pwd not available. Skipping test')
@skipIf((not HAS_GRP), 'grp not available. Skipping test')
@with_system_user_and_group('user12209', 'group12209', on_existing='delete', delete=True)
def test_issue_12209_follow_symlinks(self, user, group):
| tmp_dir = os.path.join(TMP, 'test.12209')
if os.path.isdir(tmp_dir):
shutil.rmtree(tmp_dir)
elif os.path.isfile(tmp_dir):
os.remove(tmp_dir)
onedir = os.path.join(tmp_dir, 'one')
twodir = os.path.join(tmp_dir, 'two')
os.makedirs(onedir)
os.symlink(onedir, twodir)
try:
ret = self.run_state('file.directory', name=tmp_dir, follow_symlinks=True, user=user, group=group, recurse=['user', 'group'])
self.assertSaltTrueReturn(ret)
onestats = os.stat(onedir)
twostats = os.lstat(twodir)
self.assertEqual(pwd.getpwuid(onestats.st_uid).pw_name, user)
self.assertEqual(pwd.getpwuid(twostats.st_uid).pw_name, 'root')
self.assertEqual(grp.getgrgid(onestats.st_gid).gr_name, group)
if salt.utils.path.which('id'):
root_group = self.run_function('user.primary_group', ['root'])
self.assertEqual(grp.getgrgid(twostats.st_gid).gr_name, root_group)
finally:
if os.path.isdir(tmp_dir):
shutil.rmtree(tmp_dir)
|
'Ensure that symlinks are properly chowned when recursing (not following
symlinks)'
| @skip_if_not_root
@skipIf((not HAS_PWD), 'pwd not available. Skipping test')
@skipIf((not HAS_GRP), 'grp not available. Skipping test')
@with_system_user_and_group('user12209', 'group12209', on_existing='delete', delete=True)
def test_issue_12209_no_follow_symlinks(self, user, group):
| tmp_dir = os.path.join(TMP, 'test.12209')
if os.path.isdir(tmp_dir):
shutil.rmtree(tmp_dir)
elif os.path.isfile(tmp_dir):
os.remove(tmp_dir)
onedir = os.path.join(tmp_dir, 'one')
twodir = os.path.join(tmp_dir, 'two')
os.makedirs(onedir)
os.symlink(onedir, twodir)
try:
ret = self.run_state('file.directory', name=tmp_dir, follow_symlinks=False, user=user, group=group, recurse=['user', 'group'])
self.assertSaltTrueReturn(ret)
onestats = os.stat(onedir)
twostats = os.lstat(twodir)
self.assertEqual(pwd.getpwuid(onestats.st_uid).pw_name, user)
self.assertEqual(pwd.getpwuid(twostats.st_uid).pw_name, user)
self.assertEqual(grp.getgrgid(onestats.st_gid).gr_name, group)
self.assertEqual(grp.getgrgid(twostats.st_gid).gr_name, group)
finally:
if os.path.isdir(tmp_dir):
shutil.rmtree(tmp_dir)
|
'Test a file.managed state with a local file as the source. Test both
with the file:// protocol designation prepended, and without it.'
| def test_template_local_file(self):
| (fd_, source) = tempfile.mkstemp()
try:
os.close(fd_)
except OSError as exc:
if (exc.errno != errno.EBADF):
raise exc
(fd_, dest) = tempfile.mkstemp()
try:
os.close(fd_)
except OSError as exc:
if (exc.errno != errno.EBADF):
raise exc
with salt.utils.files.fopen(source, 'w') as fp_:
fp_.write('{{ foo }}\n')
try:
for prefix in ('file://', ''):
ret = self.run_state('file.managed', name=dest, source=(prefix + source), template='jinja', context={'foo': 'Hello world!'})
self.assertSaltTrueReturn(ret)
finally:
os.remove(source)
os.remove(dest)
|
'Test the case where a source file is in the minion\'s local filesystem,
and the source path is the same as the destination path.'
| def test_template_local_file_noclobber(self):
| (fd_, source) = tempfile.mkstemp()
try:
os.close(fd_)
except OSError as exc:
if (exc.errno != errno.EBADF):
raise exc
with salt.utils.files.fopen(source, 'w') as fp_:
fp_.write('{{ foo }}\n')
try:
ret = self.run_state('file.managed', name=source, source=source, template='jinja', context={'foo': 'Hello world!'})
self.assertSaltFalseReturn(ret)
self.assertIn('Source file cannot be the same as destination', ret[next(iter(ret))]['comment'])
finally:
os.remove(source)
|
'ensure force option in copy state does not delete target file'
| def test_issue_25250_force_copy_deletes(self):
| dest = os.path.join(TMP, 'dest')
source = os.path.join(TMP, 'source')
shutil.copyfile(os.path.join(FILES, 'hosts'), source)
shutil.copyfile(os.path.join(FILES, 'file/base/cheese'), dest)
self.run_state('file.copy', name=dest, source=source, force=True)
self.assertTrue(os.path.exists(dest))
self.assertTrue(filecmp.cmp(source, dest))
os.remove(source)
os.remove(dest)
|
'This tests for any regressions for this issue:
https://github.com/saltstack/salt/issues/30934'
| def test_contents_pillar_with_pillar_list(self):
| state_file = 'file_contents_pillar'
ret = self.run_function('state.sls', mods=state_file)
self.assertSaltTrueReturn(ret)
|
'remove files created in previous tests'
| def tearDown(self):
| all_files = [FILEPILLAR, FILEPILLARDEF, FILEPILLARGIT]
for file in all_files:
check_file = self.run_function('file.file_exists', [file])
if check_file:
self.run_function('file.remove', [file])
|
'Test a remote file with no hash'
| def test_file_managed_http_source_no_hash(self):
| ret = self.run_state('file.managed', name=self.name, source=self.source, skip_verify=False)
log.debug('ret = %s', ret)
self.assertSaltFalseReturn(ret)
|
'Test a remote file with no hash'
| def test_file_managed_http_source(self):
| ret = self.run_state('file.managed', name=self.name, source=self.source, source_hash=self.source_hash, skip_verify=False)
log.debug('ret = %s', ret)
self.assertSaltTrueReturn(ret)
|
'Test a remote file using skip_verify'
| def test_file_managed_http_source_skip_verify(self):
| ret = self.run_state('file.managed', name=self.name, source=self.source, skip_verify=True)
log.debug('ret = %s', ret)
self.assertSaltTrueReturn(ret)
|
'git.latest'
| def test_latest(self):
| name = os.path.join(TMP, 'salt_repo')
try:
ret = self.run_state('git.latest', name='https://{0}/saltstack/salt-test-repo.git'.format(self.__domain), target=name)
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isdir(os.path.join(name, '.git')))
finally:
shutil.rmtree(name, ignore_errors=True)
|
'git.latest'
| def test_latest_with_rev_and_submodules(self):
| name = os.path.join(TMP, 'salt_repo')
try:
ret = self.run_state('git.latest', name='https://{0}/saltstack/salt-test-repo.git'.format(self.__domain), rev='develop', target=name, submodules=True)
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isdir(os.path.join(name, '.git')))
finally:
shutil.rmtree(name, ignore_errors=True)
|
'git.latest'
| def test_latest_failure(self):
| name = os.path.join(TMP, 'salt_repo')
try:
ret = self.run_state('git.latest', name='https://youSpelledGitHubWrong.com/saltstack/salt-test-repo.git', rev='develop', target=name, submodules=True)
self.assertSaltFalseReturn(ret)
self.assertFalse(os.path.isdir(os.path.join(name, '.git')))
finally:
shutil.rmtree(name, ignore_errors=True)
|
'git.latest'
| def test_latest_empty_dir(self):
| name = os.path.join(TMP, 'salt_repo')
if (not os.path.isdir(name)):
os.mkdir(name)
try:
ret = self.run_state('git.latest', name='https://{0}/saltstack/salt-test-repo.git'.format(self.__domain), rev='develop', target=name, submodules=True)
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isdir(os.path.join(name, '.git')))
finally:
shutil.rmtree(name, ignore_errors=True)
|
'cwd=target was being passed to _run_check which blew up if
target dir did not already exist.'
| def test_latest_unless_no_cwd_issue_6800(self):
| name = os.path.join(TMP, 'salt_repo')
if os.path.isdir(name):
shutil.rmtree(name)
try:
ret = self.run_state('git.latest', name='https://{0}/saltstack/salt-test-repo.git'.format(self.__domain), rev='develop', target=name, unless='test -e {0}'.format(name), submodules=True)
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isdir(os.path.join(name, '.git')))
finally:
shutil.rmtree(name, ignore_errors=True)
|
'git.latest with numeric revision'
| def test_numeric_rev(self):
| name = os.path.join(TMP, 'salt_repo')
try:
ret = self.run_state('git.latest', name='https://{0}/saltstack/salt-test-repo.git'.format(self.__domain), rev=0.11, target=name, submodules=True, timeout=120)
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isdir(os.path.join(name, '.git')))
finally:
shutil.rmtree(name, ignore_errors=True)
|
'Ensure that we fail the state when there are local changes and succeed
when force_reset is True.'
| def test_latest_with_local_changes(self):
| name = os.path.join(TMP, 'salt_repo')
try:
ret = self.run_state('git.latest', name='https://{0}/saltstack/salt-test-repo.git'.format(self.__domain), target=name)
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isdir(os.path.join(name, '.git')))
with salt.utils.files.fopen(os.path.join(name, 'LICENSE'), 'a') as fp_:
fp_.write('Lorem ipsum dolor blah blah blah....\n')
self.assertTrue(self.run_function('git.diff', [name, 'HEAD']))
ret = self.run_state('git.latest', name='https://{0}/saltstack/salt-test-repo.git'.format(self.__domain), target=name, force_reset=False)
self.assertSaltTrueReturn(ret)
self.assertEqual(ret[next(iter(ret))]['comment'], "Repository {0} is up-to-date, but with local changes. Set 'force_reset' to True to purge local changes.".format(name))
ret = self.run_state('git.latest', name='https://{0}/saltstack/salt-test-repo.git'.format(self.__domain), target=name, force_reset=True)
self.assertSaltTrueReturn(ret)
self.assertFalse(self.run_function('git.diff', [name, 'HEAD']))
finally:
shutil.rmtree(name, ignore_errors=True)
|
'Test running git.latest state a second time after changes have been
made to the remote repo.'
| @uses_git_opts
def test_latest_fast_forward(self):
| def _head(cwd):
return self.run_function('git.rev_parse', [cwd, 'HEAD'])
repo_url = 'https://{0}/saltstack/salt-test-repo.git'.format(self.__domain)
mirror_dir = os.path.join(TMP, 'salt_repo_mirror')
mirror_url = ('file://' + mirror_dir)
admin_dir = os.path.join(TMP, 'salt_repo_admin')
clone_dir = os.path.join(TMP, 'salt_repo')
try:
self.run_function('git.clone', [mirror_dir], url=repo_url, opts='--mirror')
self.assertTrue(os.path.exists(mirror_dir))
ret = self.run_state('git.latest', name=mirror_url, target=admin_dir)
self.assertSaltTrueReturn(ret)
ret = self.run_state('git.latest', name=mirror_url, target=clone_dir)
self.assertSaltTrueReturn(ret)
head_pre = _head(admin_dir)
with salt.utils.files.fopen(os.path.join(admin_dir, 'LICENSE'), 'a') as fp_:
fp_.write('Hello world!')
self.run_function('git.commit', [admin_dir, 'added a line'], git_opts='-c user.name="Foo Bar" -c [email protected]', opts='-a')
head_post = _head(admin_dir)
self.assertNotEqual(head_pre, head_post)
self.run_function('git.push', [admin_dir, 'origin', 'develop'])
ret = self.run_state('git.latest', name=mirror_url, target=clone_dir)
self.assertSaltTrueReturn(ret)
self.assertEqual(head_post, _head(clone_dir))
finally:
for path in (mirror_dir, admin_dir, clone_dir):
shutil.rmtree(path, ignore_errors=True)
|
'We\'re testing two almost identical cases, the only thing that differs
is the rev used for the git.latest state.'
| def _changed_local_branch_helper(self, rev, hint):
| name = os.path.join(TMP, 'salt_repo')
try:
ret = self.run_state('git.latest', name='https://{0}/saltstack/salt-test-repo.git'.format(self.__domain), rev=rev, target=name)
self.assertSaltTrueReturn(ret)
self.run_function('git.checkout', [name, 'new_branch'], opts='-b')
with salt.utils.files.fopen(os.path.join(name, 'foo'), 'w'):
pass
self.run_function('git.add', [name, '.'])
self.run_function('git.commit', [name, 'add file'], git_opts='-c user.name="Foo Bar" -c [email protected]')
ret = self.run_state('git.latest', name='https://{0}/saltstack/salt-test-repo.git'.format(self.__domain), rev=rev, target=name)
self.assertSaltFalseReturn(ret)
comment = ret[next(iter(ret))]['comment']
self.assertTrue((hint in comment))
finally:
shutil.rmtree(name, ignore_errors=True)
|
'Test for presence of hint in failure message when the local branch has
been changed and a the rev is set to HEAD
This test will fail if the default branch for the salt-test-repo is
ever changed.'
| @uses_git_opts
def test_latest_changed_local_branch_rev_head(self):
| self._changed_local_branch_helper('HEAD', 'The default remote branch (develop) differs from the local branch (new_branch)')
|
'Test for presence of hint in failure message when the local branch has
been changed and a non-HEAD rev is specified'
| @uses_git_opts
def test_latest_changed_local_branch_rev_develop(self):
| self._changed_local_branch_helper('develop', 'The desired rev (develop) differs from the name of the local branch (new_branch)')
|
'Ensure that we don\'t exit early when checking for a fast-forward'
| @uses_git_opts
def test_latest_updated_remote_rev(self):
| name = tempfile.mkdtemp(dir=TMP)
target = os.path.join(TMP, 'test_latest_updated_remote_rev')
self.run_function('git.init', [name])
try:
with salt.utils.files.fopen(os.path.join(name, 'foo.txt'), 'w') as fp_:
fp_.write('Hello world\n')
self.run_function('git.add', [name, '.'])
self.run_function('git.commit', [name, 'initial commit'], git_opts='-c user.name="Foo Bar" -c [email protected]')
ret = self.run_state('git.latest', name=name, target=target)
self.assertSaltTrueReturn(ret)
with salt.utils.files.fopen(os.path.join(name, 'foo.txt'), 'w') as fp_:
fp_.write('Added a line\n')
self.run_function('git.commit', [name, 'added a line'], git_opts='-c user.name="Foo Bar" -c [email protected]', opts='-a')
ret = self.run_state('git.latest', name=name, target=target)
self.assertSaltTrueReturn(ret)
finally:
for path in (name, target):
try:
shutil.rmtree(path)
except OSError as exc:
if (exc.errno != errno.ENOENT):
raise exc
|
'git.present'
| def test_present(self):
| name = os.path.join(TMP, 'salt_repo')
try:
ret = self.run_state('git.present', name=name, bare=True)
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isfile(os.path.join(name, 'HEAD')))
finally:
shutil.rmtree(name, ignore_errors=True)
|
'git.present'
| def test_present_failure(self):
| name = os.path.join(TMP, 'salt_repo')
if (not os.path.isdir(name)):
os.mkdir(name)
try:
fname = os.path.join(name, 'stoptheprocess')
with salt.utils.files.fopen(fname, 'a') as fh_:
fh_.write('')
ret = self.run_state('git.present', name=name, bare=True)
self.assertSaltFalseReturn(ret)
self.assertFalse(os.path.isfile(os.path.join(name, 'HEAD')))
finally:
shutil.rmtree(name, ignore_errors=True)
|
'git.present'
| def test_present_empty_dir(self):
| name = os.path.join(TMP, 'salt_repo')
if (not os.path.isdir(name)):
os.mkdir(name)
try:
ret = self.run_state('git.present', name=name, bare=True)
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isfile(os.path.join(name, 'HEAD')))
finally:
shutil.rmtree(name, ignore_errors=True)
|
'git.config'
| def test_config_set_value_with_space_character(self):
| name = tempfile.mkdtemp(dir=TMP)
self.addCleanup(shutil.rmtree, name, ignore_errors=True)
self.run_function('git.init', [name])
ret = self.run_state('git.config_set', name='user.name', value='foo bar', repo=name, **{'global': False})
self.assertSaltTrueReturn(ret)
|
'Test the case where the remote branch has been removed
https://github.com/saltstack/salt/issues/36242'
| def test_renamed_default_branch(self):
| repo = tempfile.mkdtemp(dir=TMP)
admin = tempfile.mkdtemp(dir=TMP)
name = tempfile.mkdtemp(dir=TMP)
for dirname in (repo, admin, name):
self.addCleanup(shutil.rmtree, dirname, ignore_errors=True)
self.run_function('git.init', [repo], bare=True)
self.run_function('git.clone', [admin], url=repo)
with salt.utils.files.fopen(os.path.join(admin, 'foo'), 'w'):
pass
self.run_function('git.add', [admin, '.'])
self.run_function('git.commit', [admin, 'initial commit'], git_opts='-c user.name="Foo Bar" -c [email protected]')
self.run_function('git.push', [admin], remote='origin', ref='master')
os.rename(os.path.join(repo, 'refs', 'heads', 'master'), os.path.join(repo, 'refs', 'heads', 'develop'))
ret = self.run_state('git.latest', name=repo, target=name, rev='develop')
self.assertSaltFalseReturn(ret)
self.assertEqual(ret[next(iter(ret))]['comment'], "Remote HEAD refers to a ref that does not exist. This can happen when the default branch on the remote repository is renamed or deleted. If you are unable to fix the remote repository, you can work around this by setting the 'branch' argument (which will ensure that the named branch is created if it does not already exist).\n\nChanges already made: {0} cloned to {1}".format(repo, name))
self.assertEqual(ret[next(iter(ret))]['changes'], {'new': '{0} => {1}'.format(repo, name)})
ret = self.run_state('git.latest', name=repo, target=name, rev='develop')
self.assertSaltFalseReturn(ret)
self.assertEqual(ret[next(iter(ret))]['comment'], "Cannot set/unset upstream tracking branch, local HEAD refers to nonexistent branch. This may have been caused by cloning a remote repository for which the default branch was renamed or deleted. If you are unable to fix the remote repository, you can work around this by setting the 'branch' argument (which will ensure that the named branch is created if it does not already exist).")
self.assertEqual(ret[next(iter(ret))]['changes'], {})
ret = self.run_state('git.latest', name=repo, target=name, rev='develop', branch='develop')
self.assertSaltTrueReturn(ret)
self.assertSaltCommentRegexpMatches(ret, "New branch 'develop' was checked out, with origin/develop \\([0-9a-f]{7}\\) as a starting point")
self.assertEqual(list(ret[next(iter(ret))]['changes'].keys()), ['revision'])
self.assertEqual(ret[next(iter(ret))]['changes']['revision']['old'], None)
self.assertTrue((len(ret[next(iter(ret))]['changes']['revision']['new']) == 40))
self.assertTrue(all([(x in string.hexdigits) for x in ret[next(iter(ret))]['changes']['revision']['new']]))
|
'Tests installed and removed states'
| @skip_if_not_root
def test_pip_installed_removed(self):
| name = 'pudb'
if (name in self.run_function('pip.list')):
self.skipTest('{0} is already installed, uninstall to run this test'.format(name))
ret = self.run_state('pip.installed', name=name)
self.assertSaltTrueReturn(ret)
ret = self.run_state('pip.removed', name=name)
self.assertSaltTrueReturn(ret)
|
'Test multiple pip mirrors. This test only works with pip < 7.0.0'
| def test_issue_5940_multiple_pip_mirrors(self):
| ret = self.run_function('state.sls', mods='issue-5940-multiple-pip-mirrors')
venv_dir = os.path.join(RUNTIME_VARS.TMP, '5940-multiple-pip-mirrors')
try:
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isfile(os.path.join(venv_dir, 'bin', 'pep8')))
except (AssertionError, CommandExecutionError):
pip_version = self.run_function('pip.version', [venv_dir])
if salt.utils.compare_versions(ver1=pip_version, oper='>=', ver2='7.0.0'):
self.skipTest('the --mirrors arg has been deprecated and removed in pip==7.0.0')
finally:
if os.path.isdir(venv_dir):
shutil.rmtree(venv_dir)
|
'Test how an error can be recovered'
| def test_handle_error(self):
| ret = self.run_function('state.sls', ['issue-9983-handleerror'])
self.assertTrue(('An exception occurred in this state: Traceback' in ret[[a for a in ret][0]]['comment']))
|
'supervisord.running restart = False
When service is stopped.'
| def test_running_stopped(self):
| self.start_supervisord(autostart=False)
ret = self.run_state('supervisord.running', name='sleep_service', bin_env=self.venv_dir, conf_file=self.supervisor_conf)
self.assertSaltTrueReturn(ret)
self.assertInSaltReturn('sleep_service', ret, ['changes'])
|
'supervisord.running restart = False
When service is running.'
| def test_running_started(self):
| self.start_supervisord(autostart=True)
ret = self.run_state('supervisord.running', name='sleep_service', bin_env=self.venv_dir, conf_file=self.supervisor_conf)
self.assertSaltTrueReturn(ret)
self.assertNotInSaltReturn('sleep_service', ret, ['changes'])
|
'supervisord.running restart = False
When service needs to be added.'
| def test_running_needsupdate(self):
| self.start_supervisord(autostart=False)
self.run_function('supervisord.remove', ['sleep_service', None, self.supervisor_conf, self.venv_dir])
ret = self.run_state('supervisord.running', name='sleep_service', bin_env=self.venv_dir, conf_file=self.supervisor_conf)
self.assertSaltTrueReturn(ret)
self.assertInSaltReturn('sleep_service', ret, ['changes'])
|
'supervisord.running restart = False
When service doesn\'t exist.'
| def test_running_notexists(self):
| self.start_supervisord(autostart=True)
ret = self.run_state('supervisord.running', name='does_not_exist', bin_env=self.venv_dir, conf_file=self.supervisor_conf)
self.assertSaltFalseReturn(ret)
|
'supervisord.running restart = True
When service is running.'
| def test_restart_started(self):
| self.start_supervisord(autostart=True)
ret = self.run_state('supervisord.running', name='sleep_service', restart=True, bin_env=self.venv_dir, conf_file=self.supervisor_conf)
self.assertSaltTrueReturn(ret)
self.assertInSaltReturn('sleep_service', ret, ['changes'])
|
'supervisord.running restart = True
When service is stopped.'
| def test_restart_stopped(self):
| self.start_supervisord(autostart=False)
ret = self.run_state('supervisord.running', name='sleep_service', restart=True, bin_env=self.venv_dir, conf_file=self.supervisor_conf)
self.assertSaltTrueReturn(ret)
self.assertInSaltReturn('sleep_service', ret, ['changes'])
|
'supervisord.running restart = True
When service needs to be added.'
| def test_restart_needsupdate(self):
| self.start_supervisord(autostart=False)
self.run_function('supervisord.remove', ['sleep_service', None, self.supervisor_conf, self.venv_dir])
ret = self.run_state('supervisord.running', name='sleep_service', restart=True, bin_env=self.venv_dir, conf_file=self.supervisor_conf)
self.assertSaltTrueReturn(ret)
self.assertInSaltReturn('sleep_service', ret, ['changes'])
|
'supervisord.running restart = True
When service does not exist.'
| def test_restart_notexists(self):
| self.start_supervisord(autostart=True)
ret = self.run_state('supervisord.running', name='does_not_exist', restart=True, bin_env=self.venv_dir, conf_file=self.supervisor_conf)
self.assertSaltFalseReturn(ret)
self.assertNotInSaltReturn('sleep_service', ret, ['changes'])
|
'supervisord.dead
When service is running.'
| def test_dead_started(self):
| self.start_supervisord(autostart=True)
ret = self.run_state('supervisord.dead', name='sleep_service', bin_env=self.venv_dir, conf_file=self.supervisor_conf)
self.assertSaltTrueReturn(ret)
|
'supervisord.dead
When service is stopped.'
| def test_dead_stopped(self):
| self.start_supervisord(autostart=False)
ret = self.run_state('supervisord.dead', name='sleep_service', bin_env=self.venv_dir, conf_file=self.supervisor_conf)
self.assertSaltTrueReturn(ret)
|
'supervisord.dead
When service needs to be added.'
| def test_dead_removed(self):
| self.start_supervisord(autostart=False)
self.run_function('supervisord.remove', ['sleep_service', None, self.supervisor_conf, self.venv_dir])
ret = self.run_state('supervisord.dead', name='sleep_service', bin_env=self.venv_dir, conf_file=self.supervisor_conf)
self.assertSaltTrueReturn(ret)
|
'supervisord.dead
When service does not exist.'
| def test_dead_notexists(self):
| self.start_supervisord(autostart=True)
ret = self.run_state('supervisord.dead', name='does_not_exist', bin_env=self.venv_dir, conf_file=self.supervisor_conf)
self.assertSaltTrueReturn(ret)
|
''
| def setUp(self):
| self.run_state('docker_image.present', name='zookeeper')
self.run_state('docker_container.running', name='zookeeper', image='zookeeper', port_bindings='2181:2181')
|
'Test the error with multiple states of the same type'
| def test_handle_iorder(self):
| ret = self.run_function('state.show_low_sls', mods='issue-7649-handle-iorder')
sorted_chunks = [chunk['name'] for chunk in sorted(ret, key=(lambda c: c.get('order')))]
expected = ['./configure', 'make', 'make install']
self.assertEqual(expected, sorted_chunks)
|
''
| @classmethod
def setUpClass(cls):
| cls.image_build_rootdir = tempfile.mkdtemp(dir=TMP)
cls.image = _random_name(prefix='salt_busybox_')
script_path = os.path.join(FILES, 'file/base/mkimage-busybox-static')
cmd = [script_path, cls.image_build_rootdir, cls.image]
log.debug("Running '%s' to build busybox image", ' '.join(cmd))
process = subprocess.Popen(cmd, close_fds=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
output = process.communicate()[0]
log.debug('Output from mkimge-busybox-static:\n%s', output)
if (process.returncode != 0):
raise Exception('Failed to build image')
try:
salt.utils.files.rm_rf(cls.image_build_rootdir)
except OSError as exc:
if (exc.errno != errno.ENOENT):
raise
|
'This tests that a container created using the docker_container.running
state, with binds defined, will also create the corresponding volumes
if they aren\'t pre-defined in the image.'
| @with_random_name
def test_running_with_no_predefined_volume(self, name):
| try:
bind_dir_host = tempfile.mkdtemp(dir=TMP)
ret = self.run_state('docker_container.running', name=name, image=self.image, binds=(bind_dir_host + ':/foo'))
self.assertSaltTrueReturn(ret)
ret = self.run_function('docker.inspect_container', [name])
self.assertTrue(('/foo' in ret['Config']['Volumes']))
finally:
if (name in self.run_function('docker.list_containers', all=True)):
self.run_function('docker.rm', [name], force=True)
try:
salt.utils.files.rm_rf(bind_dir_host)
except OSError as exc:
if (exc.errno != errno.ENOENT):
raise
|
'This tests that a container created using the docker_container.running
state, with port_bindings defined, will also configure the
corresponding ports if they aren\'t pre-defined in the image.'
| @with_random_name
def test_running_with_no_predefined_ports(self, name):
| try:
ret = self.run_state('docker_container.running', name=name, image=self.image, port_bindings='14505-14506:24505-24506,2123:2123/udp,8080')
self.assertSaltTrueReturn(ret)
expected_ports = (4505, 4506, 8080, '2123/udp')
ret = self.run_function('docker.inspect_container', [name])
self.assertTrue(((x in ret['NetworkSettings']['Ports']) for x in expected_ports))
finally:
if (name in self.run_function('docker.list_containers', all=True)):
self.run_function('docker.rm', [name], force=True)
|
'This tests the case of an image being changed after the container is
created. The next time the state is run, the container should be
replaced because the image ID is now different.'
| @with_random_name
def test_running_updated_image_id(self, name):
| try:
ret = self.run_state('docker_container.running', name=name, image=self.image)
self.assertSaltTrueReturn(ret)
c_info = self.run_function('docker.inspect_container', [name])
(c_name, c_id) = (c_info[x] for x in ('Name', 'Id'))
self.assertEqual(self.run_function('docker.retcode', [name, 'touch /.salttest']), 0)
self.run_function('docker.commit', [c_id, self.image])
ret = self.run_state('docker_container.running', name=name, image=self.image)
self.assertSaltTrueReturn(ret)
ret = ret[next(iter(ret))]
self.assertTrue(('container_id' in ret['changes']))
self.assertTrue(('image' in ret['changes']))
self.assertTrue(('Container has a new image' in ret['comment']))
finally:
if (name in self.run_function('docker.list_containers', all=True)):
self.run_function('docker.rm', [name], force=True)
|
'Test that we do not start a container which is stopped, when it is not
being replaced.'
| @with_random_name
def test_running_start_false_without_replace(self, name):
| try:
ret = self.run_state('docker_container.running', name=name, image=self.image)
self.assertSaltTrueReturn(ret)
self.run_function('docker.stop', [name], force=True)
ret = self.run_state('docker_container.running', name=name, image=self.image, start=False)
self.assertSaltTrueReturn(ret)
ret = ret[next(iter(ret))]
self.assertTrue(('container_id' not in ret['changes']))
self.assertTrue(('state' not in ret['changes']))
finally:
if (name in self.run_function('docker.list_containers', all=True)):
self.run_function('docker.rm', [name], force=True)
|
'Test that we do start a container which was previously stopped, even
though start=False, because the container was replaced.'
| @with_random_name
def test_running_start_false_with_replace(self, name):
| try:
ret = self.run_state('docker_container.running', name=name, image=self.image)
self.assertSaltTrueReturn(ret)
self.run_function('docker.stop', [name], force=True)
ret = self.run_state('docker_container.running', name=name, image=self.image, command='sleep 600', start=False)
self.assertSaltTrueReturn(ret)
ret = ret[next(iter(ret))]
self.assertTrue(('container_id' in ret['changes']))
self.assertTrue(('state' not in ret['changes']))
finally:
if (name in self.run_function('docker.list_containers', all=True)):
self.run_function('docker.rm', [name], force=True)
|
'This tests that we *do* start a container that is stopped, when the
"start" argument is set to True.'
| @with_random_name
def test_running_start_true(self, name):
| try:
ret = self.run_state('docker_container.running', name=name, image=self.image)
self.assertSaltTrueReturn(ret)
self.run_function('docker.stop', [name], force=True)
ret = self.run_state('docker_container.running', name=name, image=self.image, start=True)
self.assertSaltTrueReturn(ret)
ret = ret[next(iter(ret))]
self.assertTrue(('container_id' not in ret['changes']))
self.assertTrue(('state' in ret['changes']))
self.assertTrue(("State changed from 'stopped' to 'running'" in ret['comment']))
finally:
if (name in self.run_function('docker.list_containers', all=True)):
self.run_function('docker.rm', [name], force=True)
|
'This tests that the input tranlation code identifies invalid input and
includes information about that invalid argument in the state return.'
| @with_random_name
def test_running_with_invalid_input(self, name):
| try:
ret = self.run_state('docker_container.running', name=name, image=self.image, ulimits='nofile:2048')
self.assertSaltFalseReturn(ret)
ret = ret[next(iter(ret))]
self.assertTrue(('container_id' not in ret['changes']))
self.assertTrue(("Ulimit definition 'nofile:2048' is not in the format type=soft_limit[:hard_limit]" in ret['comment']))
finally:
if (name in self.run_function('docker.list_containers', all=True)):
self.run_function('docker.rm', [name], force=True)
|
'this tests that the input tranlation code identifies an argument
collision (API args and their aliases being simultaneously used) and
includes information about them in the state return.'
| @with_random_name
def test_running_with_argument_collision(self, name):
| try:
ret = self.run_state('docker_container.running', name=name, image=self.image, ulimits='nofile=2048', ulimit='nofile=1024:2048')
self.assertSaltFalseReturn(ret)
ret = ret[next(iter(ret))]
self.assertTrue(('container_id' not in ret['changes']))
self.assertTrue(("'ulimit' is an alias for 'ulimits'" in ret['comment']))
finally:
if (name in self.run_function('docker.list_containers', all=True)):
self.run_function('docker.rm', [name], force=True)
|
'This tests that the input tranlation code identifies an argument
collision (API args and their aliases being simultaneously used)
includes information about them in the state return.'
| @with_random_name
def test_running_with_ignore_collisions(self, name):
| try:
ret = self.run_state('docker_container.running', name=name, image=self.image, ignore_collisions=True, ulimits='nofile=2048', ulimit='nofile=1024:2048')
self.assertSaltTrueReturn(ret)
ret = ret[next(iter(ret))]
self.assertTrue(('container_id' in ret['changes']))
c_info = self.run_function('docker.inspect_container', [name])
actual = c_info['HostConfig']['Ulimits']
expected = [{'Name': 'nofile', 'Soft': 2048, 'Hard': 2048}]
self.assertEqual(actual, expected)
finally:
if (name in self.run_function('docker.list_containers', all=True)):
self.run_function('docker.rm', [name], force=True)
|
'This tests that removing an argument from a created container will
be detected and result in the container being replaced.
It also tests that we revert back to the value from the image. This
way, when the "command" argument is removed, we confirm that we are
reverting back to the image\'s command.'
| @with_random_name
def test_running_with_removed_argument(self, name):
| try:
ret = self.run_state('docker_container.running', name=name, image=self.image, command='sleep 600')
self.assertSaltTrueReturn(ret)
ret = self.run_state('docker_container.running', name=name, image=self.image)
self.assertSaltTrueReturn(ret)
ret = ret[next(iter(ret))]
image_info = self.run_function('docker.inspect_image', [self.image])
self.assertEqual(ret['changes']['container']['Config']['Cmd']['new'], image_info['Config']['Cmd'])
finally:
if (name in self.run_function('docker.list_containers', all=True)):
self.run_function('docker.rm', [name], force=True)
|
'This tests the docker_container.absent state on a stopped container'
| @with_random_name
def test_absent_with_stopped_container(self, name):
| try:
self.run_function('docker.create', [self.image], name=name)
ret = self.run_state('docker_container.absent', name=name)
self.assertSaltTrueReturn(ret)
ret = ret[next(iter(ret))]
self.assertTrue(('removed' in ret['changes']))
ret = self.run_state('docker_container.absent', name=name)
self.assertSaltTrueReturn(ret)
ret = ret[next(iter(ret))]
self.assertEqual(ret['changes'], {})
self.assertEqual(ret['comment'], "Container '{0}' does not exist".format(name))
finally:
if (name in self.run_function('docker.list_containers', all=True)):
self.run_function('docker.rm', [name], force=True)
|
'This tests the docker_container.absent state and'
| @with_random_name
def test_absent_with_running_container(self, name):
| try:
ret = self.run_state('docker_container.running', name=name, image=self.image, command='sleep 600')
self.assertSaltTrueReturn(ret)
ret = self.run_state('docker_container.absent', name=name)
self.assertSaltFalseReturn(ret)
ret = ret[next(iter(ret))]
self.assertEqual(ret['changes'], {})
self.assertEqual(ret['comment'], 'Container is running, set force to True to forcibly remove it')
ret = self.run_state('docker_container.absent', name=name, force=True)
self.assertSaltTrueReturn(ret)
ret = ret[next(iter(ret))]
self.assertTrue(('removed' in ret['changes']))
self.assertEqual(ret['comment'], "Forcibly removed container '{0}'".format(name))
finally:
if (name in self.run_function('docker.list_containers', all=True)):
self.run_function('docker.rm', [name], force=True)
|
'dockerng.running environnment part. Testing issue 39838.'
| @with_random_name
def test_env_with_running_container(self, name):
| try:
ret = self.run_state('docker_container.running', name=name, image=self.image, env='VAR1=value1,VAR2=value2,VAR3=value3')
self.assertSaltTrueReturn(ret)
ret = self.run_function('docker.inspect_container', [name])
self.assertTrue(('VAR1=value1' in ret['Config']['Env']))
self.assertTrue(('VAR2=value2' in ret['Config']['Env']))
self.assertTrue(('VAR3=value3' in ret['Config']['Env']))
ret = self.run_state('docker_container.running', name=name, image=self.image, env='VAR1=value1,VAR2=value2')
self.assertSaltTrueReturn(ret)
ret = self.run_function('docker.inspect_container', [name])
self.assertTrue(('VAR1=value1' in ret['Config']['Env']))
self.assertTrue(('VAR2=value2' in ret['Config']['Env']))
self.assertTrue(('VAR3=value3' not in ret['Config']['Env']))
finally:
if (name in self.run_function('docker.list_containers', all=True)):
self.run_function('docker.rm', [name], force=True)
|
'helper method to check status of service'
| def check_service_status(self, exp_return):
| check_status = self.run_function('service.status', name=SERVICE_NAME)
if (check_status is not exp_return):
self.fail('status of service is not returning correctly')
|
'test service.dead state module'
| def test_service_dead(self):
| start_service = self.run_state('service.running', name=SERVICE_NAME)
self.assertSaltTrueReturn(start_service)
self.check_service_status(True)
ret = self.run_state('service.dead', name=SERVICE_NAME)
self.assertSaltTrueReturn(ret)
self.check_service_status(False)
|
'test service.dead state module with init_delay arg'
| def test_service_dead_init_delay(self):
| start_service = self.run_state('service.running', name=SERVICE_NAME)
self.assertSaltTrueReturn(start_service)
self.check_service_status(True)
ret = self.run_state('service.dead', name=SERVICE_NAME, init_delay=INIT_DELAY)
self.assertSaltTrueReturn(ret)
self.check_service_status(False)
|
'cmd.run'
| def test_run_simple(self):
| cmd = ('dir' if IS_WINDOWS else 'ls')
ret = self.run_state('cmd.run', name=cmd, cwd=tempfile.gettempdir())
self.assertSaltTrueReturn(ret)
|
'cmd.run test interface'
| def test_test_run_simple(self):
| ret = self.run_state('cmd.run', name='ls', cwd=tempfile.gettempdir(), test=True)
self.assertSaltNoneReturn(ret)
|
'test cmd.run unless'
| def test_run_unless(self):
| state_key = 'cmd_|-{0}_|-{0}_|-run'.format(self.test_tmp_path)
with salt.utils.files.fopen(self.state_file, 'w') as fb_:
fb_.write(textwrap.dedent('\n {0}:\n cmd.run:\n - unless: echo cheese > {1}\n '.format(self.test_tmp_path, self.test_file)))
ret = self.run_function('state.sls', [self.state_name])
self.assertTrue(ret[state_key]['result'])
|
'test cmd.run using multiple unless options where the first cmd in the
list will pass, but the second will fail. This tests the fix for issue
#35384. (The fix is in PR #35545.)'
| def test_run_unless_multiple_cmds(self):
| sls = self.run_function('state.sls', mods='issue-35384')
self.assertSaltTrueReturn(sls)
self.assertEqual(sls['cmd_|-cmd_run_unless_multiple_|-echo "hello"_|-run']['comment'], 'Command "echo "hello"" run')
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.