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)
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)
""" 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)
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)