def run_tests(TestCase):
'''
Run integration tests for a chosen test case.
Function uses optparse to set up test environment
'''
from saltunittest import TestLoader, TextTestRunner
opts = parse_opts()
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestCase)
print('Setting up Salt daemons to execute tests')
with TestDaemon(clean=opts.clean):
runner = TextTestRunner(verbosity=opts.verbosity).run(tests)
sys.exit(runner.wasSuccessful())
def run_tests(TestCase):
'''
Run integration tests for a chosen test case.
Function uses optparse to set up test environment
'''
from saltunittest import TestLoader, TextTestRunner
opts = parse_opts()
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestCase)
print('Setting up Salt daemons to execute tests')
with TestDaemon(clean=opts.clean):
runner = TextTestRunner(verbosity=opts.verbosity).run(tests)
sys.exit(runner.wasSuccessful())
Validate the pillar module
'''
def test_data(self):
'''
pillar.data
'''
grains = self.run_function('grains.items')
pillar = self.run_function('pillar.data')
self.assertEqual(pillar['os'], grains['os'])
self.assertEqual(pillar['monty'], 'python')
if grains['os'] == 'Fedora':
self.assertEqual(pillar['class'], 'redhat')
else:
self.assertEqual(pillar['class'], 'other')
def test_ext_cmd_yaml(self):
'''
pillar.data for ext_pillar cmd.yaml
'''
self.assertEqual(
self.run_function('pillar.data')['ext_spam'], 'eggs'
)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(PillarModuleTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
def test_in_docs(self):
'''
test the salt-run docs system
'''
data = self.run_run('-d')
data = '\n'.join(data)
self.assertIn('jobs.active:', data)
self.assertIn('jobs.list_jobs:', data)
self.assertIn('jobs.lookup_jid:', data)
self.assertIn('manage.down:', data)
self.assertIn('manage.up:', data)
self.assertIn('network.wol:', data)
self.assertIn('network.wollist:', data)
def test_notin_docs(self):
'''
Verify that hidden methods are not in run docs
'''
data = self.run_run('-d')
data = '\n'.join(data)
self.assertNotIn('jobs.SaltException:', data)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(RunTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
sass (3.1.15, 3.1.7)
'''
mock = MagicMock(return_value=output)
with patch.object(gem, '_gem', new=mock):
self.assertEqual(
{'actionmailer': ['2.3.14'],
'actionpack': ['2.3.14'],
'activerecord': ['2.3.14'],
'activeresource': ['2.3.14'],
'activesupport': ['3.0.5', '2.3.14'],
'rake': ['0.9.2', '0.8.7'],
'responds_to_parent': ['1.0.20091013'],
'sass': ['3.1.15', '3.1.7']},
gem.list())
def test_sources_list(self):
output = '''*** CURRENT SOURCES ***
http://rubygems.org/
'''
mock = MagicMock(return_value=output)
with patch.object(gem, '_gem', new=mock):
self.assertEqual(
['http://rubygems.org/'], gem.sources_list())
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestGemModule)
TextTestRunner(verbosity=1).run(tests)
fd.close()
finder = salt.utils.find.Finder({'name': 'test_name'})
self.assertEqual(list(finder.find('')), [])
finder = salt.utils.find.Finder({'name': 'hello.txt'})
self.assertEqual(list(finder.find(self.tmpdir)), [hello_file])
finder = salt.utils.find.Finder({'type': 'f', 'print': 'path'})
self.assertEqual(list(finder.find(self.tmpdir)),
[os.path.join(self.tmpdir, 'hello.txt')])
finder = salt.utils.find.Finder({'size': '+1G', 'print': 'path'})
self.assertEqual(list(finder.find(self.tmpdir)), [])
finder = salt.utils.find.Finder(
{'name': 'hello.txt', 'print': 'path name'}
)
self.assertEqual(
list(finder.find(self.tmpdir)), [[hello_file, 'hello.txt']]
)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestFind)
tests.addTests(loader.loadTestsFromTestCase(TestGrepOption))
tests.addTests(loader.loadTestsFromTestCase(TestPrintOption))
tests.addTests(loader.loadTestsFromTestCase(TestFinder))
TextTestRunner(verbosity=1).run(tests)
"""
self.assertEqual(
self.run_function("cmd.which", ["echo"]).rstrip(), self.run_function("cmd.run", ["which echo"]).rstrip()
)
def test_has_exec(self):
"""
cmd.has_exec
"""
self.assertTrue(self.run_function("cmd.has_exec", ["python"]))
self.assertFalse(self.run_function("cmd.has_exec", ["alllfsdfnwieulrrh9123857ygf"]))
def test_exec_code(self):
"""
cmd.exec_code
"""
code = """
import sys
sys.stdout.write('cheese')
"""
self.assertEqual(self.run_function("cmd.exec_code", ["python", code]).rstrip(), "cheese")
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(CMDModuleTest)
print("Setting up Salt daemons to execute tests")
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
# set variable identifying the chroot you work in (used in the prompt below)
if [ -z "$debian_chroot" ] && [ -r /etc/debian_chroot ]; then
debian_chroot=$(cat /etc/debian_chroot)
fi
# set variable identifying the chroot you work in (used in the prompt below)
if [ -z '$debian_chroot' ] && [ -r /etc/debian_chroot ]; then
debian_chroot=$(cat /etc/debian_chroot)
fi
"""
class TestRuntimeWhitespaceRegex(TestCase):
def test_single_quotes(self):
regex = build_whitepace_splited_regex(SINGLE_TXT)
self.assertTrue(re.search(regex, MATCH))
def test_double_quotes(self):
regex = build_whitepace_splited_regex(DOUBLE_TXT)
self.assertTrue(re.search(regex, MATCH))
def test_single_and_double_quotes(self):
regex = build_whitepace_splited_regex(SINGLE_DOUBLE_TXT)
self.assertTrue(re.search(regex, MATCH))
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestRuntimeWhitespaceRegex)
TextTestRunner(verbosity=1).run(tests)
fd.close()
finder = salt.utils.find.Finder({'name': 'test_name'})
self.assertEqual(list(finder.find('')), [])
finder = salt.utils.find.Finder({'name': 'hello.txt'})
self.assertEqual(list(finder.find(self.tmpdir)), [hello_file])
finder = salt.utils.find.Finder({'type': 'f', 'print': 'path'})
self.assertEqual(list(finder.find(self.tmpdir)),
[os.path.join(self.tmpdir, 'hello.txt')])
finder = salt.utils.find.Finder({'size': '+1G', 'print': 'path'})
self.assertEqual(list(finder.find(self.tmpdir)), [])
finder = salt.utils.find.Finder(
{'name': 'hello.txt', 'print': 'path name'}
)
self.assertEqual(
list(finder.find(self.tmpdir)), [[hello_file, 'hello.txt']]
)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestFind)
tests.addTests(loader.loadTestsFromTestCase(TestGrepOption))
tests.addTests(loader.loadTestsFromTestCase(TestPrintOption))
tests.addTests(loader.loadTestsFromTestCase(TestFinder))
TextTestRunner(verbosity=1).run(tests)
class CallTest(integration.ShellCase, integration.ShellCaseCommonTestsMixIn):
_call_binary_ = 'salt-call'
def test_default_output(self):
out = self.run_call('test.fib 3')
self.assertEqual(
"local: !!python/tuple\n- [0, 1, 1, 2]", '\n'.join(out[:-3])
)
def test_text_output(self):
out = self.run_call('--text-out test.fib 3')
self.assertEqual("local: ([0, 1, 1, 2]", ''.join(out).rsplit(",", 1)[0])
@skipIf(sys.platform.startswith('win'), 'This test does not apply on Win')
def test_user_delete_kw_output(self):
ret = self.run_call('-d user.delete')
self.assertIn(
'salt \'*\' user.delete name remove=True force=True',
''.join(ret)
)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(CallTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
self.skipTest('Failed to query the minion\'s subnets')
data = self.run_salt('-S {0} test.ping'.format(subnet))
data = '\n'.join(data)
self.assertIn('minion', data)
self.assertIn('sub_minion', data)
def test_static(self):
'''
test salt static call
'''
data = self.run_salt('minion test.ping --static')
data = '\n'.join(data)
self.assertIn('minion', data)
def test_salt_documentation(self):
'''
Test to see if we're supporting --doc
'''
data = self.run_salt('-d user.add')
self.assertIn('user.add:', data)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(MatchTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
:copyright: © 2012 UfSoft.org - :email:`Pedro Algarvio ([email protected])`
:license: Apache 2.0, see LICENSE for more details.
'''
from saltunittest import TestCase, TestLoader, TextTestRunner
from salt.utils.filebuffer import BufferedReader, InvalidFileMode
class TestFileBuffer(TestCase):
def test_read_only_mode(self):
with self.assertRaises(InvalidFileMode):
BufferedReader('/tmp/foo', mode='a')
with self.assertRaises(InvalidFileMode):
BufferedReader('/tmp/foo', mode='ab')
with self.assertRaises(InvalidFileMode):
BufferedReader('/tmp/foo', mode='w')
with self.assertRaises(InvalidFileMode):
BufferedReader('/tmp/foo', mode='wb')
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestFileBuffer)
TextTestRunner(verbosity=1).run(tests)
:copyright: © 2012 UfSoft.org - :email:`Pedro Algarvio ([email protected])` :license: Apache 2.0, see LICENSE for more details. """ from saltunittest import TestCase, TestLoader, TextTestRunner from salt.utils.filebuffer import BufferedReader, InvalidFileMode class TestFileBuffer(TestCase): def test_read_only_mode(self): with self.assertRaises(InvalidFileMode): BufferedReader("/tmp/foo", mode="a") with self.assertRaises(InvalidFileMode): BufferedReader("/tmp/foo", mode="ab") with self.assertRaises(InvalidFileMode): BufferedReader("/tmp/foo", mode="w") with self.assertRaises(InvalidFileMode): BufferedReader("/tmp/foo", mode="wb") if __name__ == "__main__": loader = TestLoader() tests = loader.loadTestsFromTestCase(TestFileBuffer) TextTestRunner(verbosity=1).run(tests)
except Exception, err:
raise AssertionError(
'No exception should have been raised: {0}'.format(err))
# Remove the testing handler
log.removeHandler(handler)
# Test for a format which does not include digits in name formatting.
log_format = '[%(name)s] %(message)s'
handler = TestsLoggingHandler(format=log_format)
log.addHandler(handler)
# Trigger TestsLoggingHandler.__enter__
with handler:
# Let's create another log instance to trigger salt's logging class
# calculations.
try:
saltlog.SaltLoggingClass('{0}.without_digits'.format(__name__))
except Exception, err:
raise AssertionError(
'No exception should have been raised: {0}'.format(err))
# Remove the testing handler
log.removeHandler(handler)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestLog)
TextTestRunner(verbosity=1).run(tests)
# -*- coding: utf-8 -*-
"""
tests.integration.shell.master
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
:copyright: © 2012 UfSoft.org - :email:`Pedro Algarvio ([email protected])`
:license: Apache 2.0, see LICENSE for more details.
"""
import sys
# Import salt libs
from saltunittest import TestLoader, TextTestRunner
import integration
from integration import TestDaemon
class MasterTest(integration.ShellCase, integration.ShellCaseCommonTestsMixIn):
_call_binary_ = 'salt-master'
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(MasterTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
self.assertIn('qux', data)
self.assertEqual(data['foo'], 'bar')
self.assertEqual(data['baz'], 'quo')
self.assertEqual(data['qux'], 'quux')
def test_full_returns(self):
'''
test cmd_iter
'''
ret = self.client.cmd_full_return(
'minion',
'test.kwarg',
['foo=bar', 'baz=quo'],
kwarg={'qux': 'quux'}
)
data = ret['minion']
self.assertIn('foo', data['ret'])
self.assertIn('baz', data['ret'])
self.assertIn('qux', data['ret'])
self.assertEqual(data['ret']['foo'], 'bar')
self.assertEqual(data['ret']['baz'], 'quo')
self.assertEqual(data['ret']['qux'], 'quux')
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(StdTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
# -*- coding: utf-8 -*-
'''
tests.integration.shell.minion
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
:codeauthor: :email:`Pedro Algarvio ([email protected])`
:copyright: © 2012 by the SaltStack Team, see AUTHORS for more details.
:license: Apache 2.0, see LICENSE for more details.
'''
# Import python libs
import sys
# Import salt libs
from saltunittest import TestLoader, TextTestRunner
import integration
class MinionTest(integration.ShellCase, integration.ShellCaseCommonTestsMixIn):
_call_binary_ = 'salt-minion'
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(MinionTest)
print('Setting up Salt daemons to execute tests')
with integration.TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
# after removal
ret = self.run_function('ssh.check_known_host', arg, **kwargs)
self.assertEqual(ret, 'add')
def test_set_known_host(self):
'''
ssh.set_known_host
'''
# add item
ret = self.run_function('ssh.set_known_host', ['root', 'github.com'],
config=KNOWN_HOSTS)
self.assertEqual(ret['status'], 'updated')
self.assertEqual(ret['old'], None)
self.assertEqual(ret['new']['fingerprint'], GITHUB_FINGERPRINT)
# check that item does exist
ret = self.run_function('ssh.get_known_host', ['root', 'github.com'],
config=KNOWN_HOSTS)
self.assertEqual(ret['fingerprint'], GITHUB_FINGERPRINT)
# add the same item once again
ret = self.run_function('ssh.set_known_host', ['root', 'github.com'],
config=KNOWN_HOSTS)
self.assertEqual(ret['status'], 'exists')
if __name__ == '__main__':
loader = TestLoader()
tests = loader.loadTestsFromTestCase(SSHModuleTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
pid = 100
self.add_process(pid=pid, cmd=None)
self.call_procs()
self.proc = self.result[pid]
def test_cmd_is_empty_string(self):
self.assertEqual(self.proc['cmd'], '')
class TestProcsComInitialization(TestProcsBase):
def setUp(self):
call_count = 5
for _ in range(call_count):
self.call_procs()
self.expected_calls = [call()] * call_count
def test_initialize_and_unintialize_called(self):
pythoncom.CoInitialize.assert_has_calls(self.expected_calls)
pythoncom.CoUninitialize.assert_has_calls(self.expected_calls)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestProcsCount)
tests = loader.loadTestsFromTestCase(TestProcsAttributes)
tests = loader.loadTestsFromTestCase(TestProcsUnicodeAttributes)
tests = loader.loadTestsFromTestCase(
TestProcsWMIGetOwnerAccessDeniedWorkaround)
tests = loader.loadTestsFromTestCase(TestProcsWMIGetOwnerErrorsAreLogged)
TextTestRunner(verbosity=1).run(tests)
:codeauthor: :email:`Pedro Algarvio ([email protected])` :copyright: © 2013 by the SaltStack Team, see AUTHORS for more details. :license: Apache 2.0, see LICENSE for more details. ''' # Import salt libs from saltunittest import TestCase, TestLoader, TextTestRunner import salt.version class VersionTestCase(TestCase): def test_git_describe_re(self): expect = ( ('v0.12.0-19-g767d4f9', ('0', '12', '0', '19', 'g767d4f9')), ('v0.12.0-85-g2880105', ('0', '12', '0', '85', 'g2880105')), ('debian/0.11.1+ds-1-3-ga0afcbd', ('0', '11', '1', '3', 'ga0afcbd')), ('0.12.1', ('0', '12', '1', None, None)), ('0.12.1', ('0', '12', '1', None, None)), ) for vs, groups in expect: self.assertEqual( groups, salt.version.GIT_DESCRIBE_RE.search(vs).groups() ) if __name__ == "__main__": loader = TestLoader() tests = loader.loadTestsFromVersionTestCase(VersionTestCase) TextTestRunner(verbosity=1).run(tests)
shutil.rmtree(tempdir)
def test_keys_generation_keysize_minmax(self):
tempdir = tempfile.mkdtemp()
arg_str = '--gen-keys minion --gen-keys-dir {0}'.format(tempdir)
try:
data, error = self.run_key(
arg_str + ' --keysize=1024', catch_stderr=True
)
self.assertIn(
'salt-key: error: The minimum value for keysize is 2048', error
)
data, error = self.run_key(
arg_str + ' --keysize=32769', catch_stderr=True
)
self.assertIn(
'salt-key: error: The maximum value for keysize is 32768', error
)
finally:
shutil.rmtree(tempdir)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(KeyTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
SED_CONTENT = """test
some
content
/var/lib/foo/app/test
here
"""
class FileModuleTestCase(TestCase):
def test_sed_limit_escaped(self):
with tempfile.NamedTemporaryFile() as tfile:
tfile.write(SED_CONTENT)
tfile.seek(0, 0)
path = tfile.name
before = "/var/lib/foo"
after = ""
limit = "^{0}".format(before)
filemod.sed(path, before, after, limit=limit)
with open(path, "rb") as newfile:
self.assertEquals(SED_CONTENT.replace(before, ""), newfile.read())
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(FileModuleTestCase)
TextTestRunner(verbosity=1).run(tests)
# Import python libs
import re
# Import salt libs
from saltunittest import TestCase, TestLoader, TextTestRunner
import salt.version
class VersionTestCase(TestCase):
def test_git_describe_re(self):
expect = (
('v0.12.0-19-g767d4f9', ('0', '12', '0', '19', 'g767d4f9')),
('v0.12.0-85-g2880105', ('0', '12', '0', '85', 'g2880105')),
('debian/0.11.1+ds-1-3-ga0afcbd', ('0', '11', '1', '3',
'ga0afcbd')),
('0.12.1', ('0', '12', '1', None, None)),
('0.12.1', ('0', '12', '1', None, None)),
)
for vs, groups in expect:
self.assertEqual(
groups,
re.search(salt.version.GIT_DESCRIBE_REGEX, vs).groups())
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromVersionTestCase(VersionTestCase)
TextTestRunner(verbosity=1).run(tests)
def test_active(self):
'''
jobs.active
'''
ret = self.run_run_plus('jobs.active')
self.assertFalse(ret['fun'])
self.assertFalse(ret['out'][1])
def test_lookup_jid(self):
'''
jobs.lookup_jid
'''
ret = self.run_run_plus('jobs.lookup_jid', '', '23974239742394')
self.assertFalse(ret['fun'])
self.assertFalse(ret['out'][1])
def test_list_jobs(self):
'''
jobs.list_jobs
'''
ret = self.run_run_plus('jobs.list_jobs')
self.assertIsInstance(ret['fun'], dict)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(RunTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
pid = 100
self.add_process(pid=pid, cmd=None)
self.call_procs()
self.proc = self.result[pid]
def test_cmd_is_empty_string(self):
self.assertEqual(self.proc['cmd'], '')
#class TestProcsComInitialization(TestProcsBase):
# def setUp(self):
# call_count = 5
# for _ in range(call_count):
# self.call_procs()
# self.expected_calls = [call()] * call_count
#
# def test_initialize_and_uninitialize_called(self):
# pythoncom.CoInitialize.assert_has_calls(self.expected_calls)
# pythoncom.CoUninitialize.assert_has_calls(self.expected_calls)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestProcsCount)
tests = loader.loadTestsFromTestCase(TestProcsAttributes)
tests = loader.loadTestsFromTestCase(TestProcsUnicodeAttributes)
tests = loader.loadTestsFromTestCase(
TestProcsWMIGetOwnerAccessDeniedWorkaround)
tests = loader.loadTestsFromTestCase(TestProcsWMIGetOwnerErrorsAreLogged)
TextTestRunner(verbosity=1).run(tests)
continue
data = yaml.load(line)
minions.extend(data.keys())
self.assertNotEqual(minions, [])
testfile = os.path.abspath(
os.path.join(
os.path.dirname(os.path.dirname(__file__)),
'files', 'file', 'base', 'testfile'
)
)
testfile_contents = open(testfile, 'r').read()
for minion in minions:
minion_testfile = os.path.join(
integration.TMP, "{0}_testfile".format(minion)
)
self.run_cp('{0} {1} {2}'.format(minion, testfile, minion_testfile))
self.assertTrue(os.path.isfile(minion_testfile))
self.assertTrue(open(minion_testfile, 'r').read() == testfile_contents)
os.unlink(minion_testfile)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(CopyTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
self.assertTrue(set_ret)
tgt_ret = self.run_function(
'aliases.list_aliases')
self.assertIsInstance(tgt_ret, dict)
self.assertIn('alias=fred', tgt_ret)
def test_rm_alias(self):
'''
aliases.rm_alias
'''
set_ret = self.run_function(
'aliases.set_target',
alias='frank',
target='greg')
self.assertTrue(set_ret)
set_ret = self.run_function(
'aliases.rm_alias',
alias='frank')
tgt_ret = self.run_function(
'aliases.list_aliases')
self.assertIsInstance(tgt_ret, dict)
self.assertNotIn('alias=frank', tgt_ret)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(AliasesTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
assert self.run_function(
'hosts.add_host', ['192.168.1.2', 'host2.fqdn.com']
)
assert self.run_function('hosts.add_host', ['192.168.1.2', 'host2'])
assert self.run_function('hosts.add_host', ['192.168.1.2', 'oldhost2'])
assert self.run_function(
'hosts.add_host', ['192.168.1.3', 'host3.fqdn.com']
)
assert self.run_function(
'hosts.add_host', ['192.168.1.2', 'host2-reorder']
)
assert self.run_function(
'hosts.add_host', ['192.168.1.1', 'host1-reorder']
)
# now read the lines and ensure they're formatted correctly
lines = open(HFN, 'r').readlines()
self.assertEqual(lines, [
"192.168.1.3\t\thost3.fqdn.com\n",
"192.168.1.2\t\thost2.fqdn.com\thost2\toldhost2\thost2-reorder\n",
"192.168.1.1\t\thost1.fqdn.com\thost1\thost1-reorder\n",
])
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(HostsModuleTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
'No exception should have been raised: {0}'.format(err)
)
# Remove the testing handler
log.removeHandler(handler)
# Test for a format which does not include digits in name formatting.
log_format = '[%(name)s] %(message)s'
handler = TestsLoggingHandler(format=log_format)
log.addHandler(handler)
# Trigger TestsLoggingHandler.__enter__
with handler:
# Let's create another log instance to trigger salt's logging class
# calculations.
try:
saltlog.SaltLoggingClass('{0}.without_digits'.format(__name__))
except Exception as err:
raise AssertionError(
'No exception should have been raised: {0}'.format(err)
)
# Remove the testing handler
log.removeHandler(handler)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestLog)
TextTestRunner(verbosity=1).run(tests)
# set variable identifying the chroot you work in (used in the prompt below)
if [ -z '$debian_chroot' ] && [ -r "/etc/debian_chroot" ]; then
debian_chroot=$(cat /etc/debian_chroot)
fi
"""
class TestRuntimeWhitespaceRegex(TestCase):
def test_single_quotes(self):
regex = build_whitespace_split_regex(SINGLE_TXT)
self.assertTrue(re.search(regex, MATCH))
def test_double_quotes(self):
regex = build_whitespace_split_regex(DOUBLE_TXT)
self.assertTrue(re.search(regex, MATCH))
def test_single_and_double_quotes(self):
regex = build_whitespace_split_regex(SINGLE_DOUBLE_TXT)
self.assertTrue(re.search(regex, MATCH))
def test_issue_2227(self):
regex = build_whitespace_split_regex(SINGLE_DOUBLE_SAME_LINE_TXT)
self.assertTrue(re.search(regex, MATCH))
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestRuntimeWhitespaceRegex)
TextTestRunner(verbosity=1).run(tests)
# -*- coding: utf-8 -*-
"""
tests.integration.shell.syndic
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
:copyright: © 2012 UfSoft.org - :email:`Pedro Algarvio ([email protected])`
:license: Apache 2.0, see LICENSE for more details.
"""
import sys
# Import salt libs
from saltunittest import TestLoader, TextTestRunner
import integration
from integration import TestDaemon
class SyndicTest(integration.ShellCase, integration.ShellCaseCommonTestsMixIn):
_call_binary_ = 'salt-syndic'
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(SyndicTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
)
self.assertEqual(
self.run_function(
'data.getval',
['spam']
),
'eggs'
)
self.assertTrue(
self.run_function(
'data.update',
['unladen', 'swallow']
)
)
self.assertEqual(
self.run_function(
'data.getvals',
['["spam", "unladen"]']
),
['eggs', 'swallow']
)
self._clear_db()
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(DataModuleTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
'No exception should have been raised: {0}'.format(err)
)
# Remove the testing handler
log.removeHandler(handler)
# Test for a format which does not include digits in name formatting.
log_format = '[%(name)s] %(message)s'
handler = TestsLoggingHandler(format=log_format)
log.addHandler(handler)
# Trigger TestsLoggingHandler.__enter__
with handler:
# Let's create another log instance to trigger salt's logging class
# calculations.
try:
saltlog.SaltLoggingClass('{0}.without_digits'.format(__name__))
except Exception, err:
raise AssertionError(
'No exception should have been raised: {0}'.format(err)
)
# Remove the testing handler
log.removeHandler(handler)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(ConfigTestCase)
TextTestRunner(verbosity=1).run(tests)
opts = dict(id='foo', ipc_mode='tcp')
me = event.MinionEvent(**opts)
self.assertEqual(me.puburi, 'tcp://127.0.0.1:4510')
self.assertEqual(me.pulluri, 'tcp://127.0.0.1:4511')
def test_minion_event_no_id(self):
me = event.MinionEvent(sock_dir=SOCK_DIR)
id_hash = hashlib.md5('').hexdigest()
self.assertEqual(
me.puburi,
'ipc://{0}'.format(
os.path.join(
SOCK_DIR, 'minion_event_{0}_pub.ipc'.format(id_hash)
)
)
)
self.assertEqual(
me.pulluri,
'ipc://{0}'.format(
os.path.join(
SOCK_DIR, 'minion_event_{0}_pull.ipc'.format(id_hash)
)
)
)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestSaltEvent)
TextTestRunner(verbosity=1).run(tests)
with_site = self.run_function('pip.freeze', bin_env=pip_bin)
self.run_function('file.remove', [self.venv_dir])
self.run_function('virtualenv.create',
[self.venv_dir])
without_site = self.run_function('pip.freeze', bin_env=pip_bin)
self.assertFalse(with_site == without_site)
def test_clear(self):
pip_bin = os.path.join(self.venv_dir, 'bin', 'pip')
self.run_function('virtualenv.create',
[self.venv_dir])
self.run_function('pip.install', [], pkgs='pep8', bin_env=pip_bin)
self.run_function('virtualenv.create',
[self.venv_dir],
clear=True)
packages = self.run_function('pip.list',
prefix='pep8',
bin_env=pip_bin)
self.assertFalse('pep8' in packages)
def tearDown(self):
self.run_function('file.remove', [self.venv_test_dir])
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(VirtualenvModuleTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
'''
test compound matcher
'''
match = 'P@test_grain:^cheese$ and * and G@test_grain:cheese'
data = self.run_salt('-t 1 -C \'{0}\' test.ping'.format(match))
data = '\n'.join(data)
self.assertIn('minion', data)
self.assertNotIn('sub_minion', data)
match = 'L@sub_minion and E@.*'
data = self.run_salt('-t 1 -C "{0}" test.ping'.format(match))
data = '\n'.join(data)
self.assertIn('sub_minion', data)
self.assertNotIn('minion', data.replace('sub_minion', 'stub'))
def test_static(self):
'''
test salt static call
'''
data = self.run_salt('minion test.ping --static')
data = '\n'.join(data)
self.assertIn('minion', data)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(KeyTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
self.assertTrue(isinstance(low[0], dict))
def test_catch_recurse(self):
'''
state.show_sls used to catch a recursive ref
'''
err = self.run_function('state.sls', mods='recurse_fail')
self.assertIn('recursive', err[0])
def test_no_recurse(self):
'''
verify that a sls structure is NOT a recursive ref
'''
sls = self.run_function('state.show_sls', mods='recurse_ok')
self.assertIn('snmpd', sls)
def test_no_recurse_two(self):
'''
verify that a sls structure is NOT a recursive ref
'''
sls = self.run_function('state.show_sls', mods='recurse_ok_two')
self.assertIn('/etc/nagios/nrpe.cfg', sls)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(StateModuleTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
SED_CONTENT = """test
some
content
/var/lib/foo/app/test
here
"""
class FileModuleTestCase(TestCase):
def test_sed_limit_escaped(self):
with tempfile.NamedTemporaryFile() as tfile:
tfile.write(SED_CONTENT)
tfile.seek(0, 0)
path = tfile.name
before = '/var/lib/foo'
after = ''
limit = '^{0}'.format(before)
filemod.sed(path, before, after, limit=limit)
with open(path, 'rb') as newfile:
self.assertEquals(SED_CONTENT.replace(before, ''),
newfile.read())
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(FileModuleTestCase)
TextTestRunner(verbosity=1).run(tests)
def test_active(self):
'''
jobs.active
'''
ret = self.run_run_plus('jobs.active')
self.assertFalse(ret['fun'])
self.assertFalse(ret['out'][1])
def test_lookup_jid(self):
'''
jobs.lookup_jid
'''
ret = self.run_run_plus('jobs.lookup_jid', '', '23974239742394')
self.assertFalse(ret['fun'])
self.assertFalse(ret['out'][1])
def test_list_jobs(self):
'''
jobs.list_jobs
'''
ret = self.run_run_plus('jobs.list_jobs')
self.assertIsInstance(ret['fun'], dict)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(ManageTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
gemset_list = MagicMock(return_value=gems)
gemset_create = MagicMock(return_value=True)
check_ruby = MagicMock(
return_value={'result': False, 'changes': {}})
with patch.object(rvm, '_check_ruby', new=check_ruby):
with patch.dict(rvm.__salt__,
{'rvm.gemset_list': gemset_list,
'rvm.gemset_create': gemset_create}):
ret = rvm.gemset_present('foo')
self.assertEqual(True, ret['result'])
ret = rvm.gemset_present('quux')
self.assertEqual(True, ret['result'])
gemset_create.assert_called_once_with(
'default', 'quux', runas=None)
def test_installed(self):
mock = MagicMock()
with patch.object(rvm, '_check_rvm') as mock_method:
mock_method.return_value = {'result': True}
with patch.object(rvm, '_check_and_install_ruby', new=mock):
rvm.installed("1.9.3", default=True)
mock.assert_called_once_with(
{'result': True}, '1.9.3', True, runas=None)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestRvmState)
TextTestRunner(verbosity=1).run(tests)
def test_removed(self):
gems = ['foo', 'bar']
gem_list = MagicMock(return_value=gems)
gem_uninstall_succeeds = MagicMock(return_value=True)
gem_uninstall_fails = MagicMock(return_value=False)
with patch.dict(gem.__salt__, {'gem.list': gem_list}):
with patch.dict(gem.__salt__,
{'gem.uninstall': gem_uninstall_succeeds}):
ret = gem.removed('quux')
self.assertEqual(True, ret['result'])
ret = gem.removed('foo')
self.assertEqual(True, ret['result'])
gem_uninstall_succeeds.assert_called_once_with('foo',
None,
runas=None)
with patch.dict(gem.__salt__,
{'gem.uninstall': gem_uninstall_fails}):
ret = gem.removed('bar')
self.assertEqual(False, ret['result'])
gem_uninstall_fails.assert_called_once_with('bar',
None,
runas=None)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestGemState)
TextTestRunner(verbosity=1).run(tests)
me = event.MinionEvent(**opts)
self.assertEqual(
me.puburi, 'ipc://{0}'.format(
os.path.join(SOCK_DIR, 'minion_event_foo_pub.ipc')))
self.assertEqual(
me.pulluri, 'ipc://{0}'.format(
os.path.join(SOCK_DIR, 'minion_event_foo_pull.ipc')))
def test_minion_event_tcp_ipc_mode(self):
opts = dict(id='foo', ipc_mode='tcp')
me = event.MinionEvent(**opts)
self.assertEqual(me.puburi, 'tcp://127.0.0.1:4510')
self.assertEqual(me.pulluri, 'tcp://127.0.0.1:4511')
def test_minion_event_no_id(self):
me = event.MinionEvent(sock_dir=SOCK_DIR)
self.assertEqual(
me.puburi,
'ipc://{0}'.format(os.path.join(SOCK_DIR,
'minion_event__pub.ipc')))
self.assertEqual(
me.pulluri,
'ipc://{0}'.format(os.path.join(SOCK_DIR,
'minion_event__pull.ipc')))
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestSaltEvent)
TextTestRunner(verbosity=1).run(tests)
# -*- coding: utf-8 -*-
"""
tests.integration.shell.syndic
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
:copyright: © 2012 UfSoft.org - :email:`Pedro Algarvio ([email protected])`
:license: Apache 2.0, see LICENSE for more details.
"""
import sys
# Import salt libs
from saltunittest import TestLoader, TextTestRunner
import integration
from integration import TestDaemon
class SyndicTest(integration.ShellCase, integration.ShellCaseCommonTestsMixIn):
_call_binary_ = 'salt-syndic'
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(SyndicTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
"""
tests.unit.config
~~~~~~~~~~~~~~~~~
:copyright: © 2012 UfSoft.org - :email:`Pedro Algarvio ([email protected])`
:license: Apache 2.0, see LICENSE for more details.
"""
import os
import tempfile
from saltunittest import TestCase, TestLoader, TextTestRunner
from salt import config as sconfig
class ConfigTestCase(TestCase):
def test_proper_path_joining(self):
fpath = tempfile.mktemp()
open(fpath, 'w').write(
"root_dir: /\n"
"key_logfile: key\n"
)
config = sconfig.master_config(fpath)
# os.path.join behaviour
self.assertEqual(config['key_logfile'], os.path.join('/', 'key'))
# os.sep.join behaviour
self.assertNotEqual(config['key_logfile'], '//key')
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(ConfigTestCase)
TextTestRunner(verbosity=1).run(tests)
# -*- coding: utf-8 -*-
"""
tests.integration.shell.master
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
:copyright: © 2012 UfSoft.org - :email:`Pedro Algarvio ([email protected])`
:license: Apache 2.0, see LICENSE for more details.
"""
import sys
# Import salt libs
from saltunittest import TestLoader, TextTestRunner
import integration
from integration import TestDaemon
class MasterTest(integration.ShellCase, integration.ShellCaseCommonTestsMixIn):
_call_binary_ = 'salt-master'
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(MasterTest)
print('Setting up Salt daemons to execute tests')
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
def test_salt_documentation(self):
"""
Test to see if we're supporting --doc
"""
data = self.run_salt("-d user.add")
self.assertIn("user.add:", data)
def test_salt_documentation_arguments_not_assumed(self):
"""
Test to see if we're not auto-adding '*' and 'sys.doc' to the call
"""
data = self.run_salt("-d")
self.assertIn("user.add:", data)
data = self.run_salt("'*' -d")
self.assertIn("user.add:", data)
data = self.run_salt("'*' -d user.add")
self.assertIn("user.add:", data)
data = self.run_salt("'*' sys.doc -d user.add")
self.assertIn("user.add:", data)
data = self.run_salt("'*' sys.doc user.add")
self.assertIn("user.add:", data)
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(MatchTest)
print("Setting up Salt daemons to execute tests")
with TestDaemon():
runner = TextTestRunner(verbosity=1).run(tests)
sys.exit(runner.wasSuccessful())
gemsets for ruby-head (found in /usr/local/rvm/gems/ruby-head)
global
headbar
headfoo
gemsets for jruby-1.6.5.1 (found in /usr/local/rvm/gems/jruby-1.6.5.1)
global
jbar
jfoo
gemsets for ruby-1.9.2-p180 (found in /usr/local/rvm/gems/ruby-1.9.2-p180)
global
'''
with patch.object(rvm, '_rvm_do') as mock_method:
mock_method.return_value = output
self.assertEqual(
{'jruby-1.6.5.1': ['global', 'jbar', 'jfoo'],
'ruby-1.9.2-p180': ['global'],
'ruby-1.9.3-p125': ['9bar', '9foo', 'global'],
'ruby-head': ['global', 'headbar', 'headfoo']},
rvm.gemset_list_all())
if __name__ == "__main__":
loader = TestLoader()
tests = loader.loadTestsFromTestCase(TestRvmModule)
TextTestRunner(verbosity=1).run(tests)
