From b228b295546aa82d2dfe588e3e52817e392ddb6a Mon Sep 17 00:00:00 2001 From: "Chris St. Pierre" Date: Thu, 8 Aug 2013 14:51:35 -0400 Subject: testsuite: Fixed base plugin tests --- testsuite/Testsrc/Testlib/TestLogger.py | 61 +++++++++++++++++ .../Testsrc/Testlib/TestServer/TestEncryption.py | 37 ++--------- .../Testlib/TestServer/TestPlugin/Testbase.py | 48 +------------- .../Testlib/TestServer/TestPlugin/Testhelpers.py | 76 ++++++++++------------ 4 files changed, 104 insertions(+), 118 deletions(-) create mode 100644 testsuite/Testsrc/Testlib/TestLogger.py (limited to 'testsuite/Testsrc') diff --git a/testsuite/Testsrc/Testlib/TestLogger.py b/testsuite/Testsrc/Testlib/TestLogger.py new file mode 100644 index 000000000..0da39deb2 --- /dev/null +++ b/testsuite/Testsrc/Testlib/TestLogger.py @@ -0,0 +1,61 @@ +import os +import sys +import logging +from mock import Mock +from Bcfg2.Logger import * + +# add all parent testsuite directories to sys.path to allow (most) +# relative imports in python 2.4 +path = os.path.dirname(__file__) +while path != '/': + if os.path.basename(path).lower().startswith("test"): + sys.path.append(path) + if os.path.basename(path) == "testsuite": + break + path = os.path.dirname(path) +from common import * + + +class TestDebuggable(Bcfg2TestCase): + test_obj = Debuggable + + def get_obj(self): + set_setup_default('debug', False) + return self.test_obj() + + def test__init(self): + d = self.get_obj() + self.assertIsInstance(d.logger, logging.Logger) + self.assertFalse(d.debug_flag) + + def test_set_debug(self): + d = self.get_obj() + self.assertEqual(True, d.set_debug(True)) + self.assertEqual(d.debug_flag, True) + + self.assertEqual(False, d.set_debug(False)) + self.assertEqual(d.debug_flag, False) + + def test_toggle_debug(self): + d = self.get_obj() + d.set_debug = Mock() + orig = d.debug_flag + self.assertEqual(d.toggle_debug(), + d.set_debug.return_value) + d.set_debug.assert_called_with(not orig) + + def test_debug_log(self): + d = self.get_obj() + d.logger = Mock() + d.debug_flag = False + d.debug_log("test") + self.assertFalse(d.logger.error.called) + + d.logger.reset_mock() + d.debug_log("test", flag=True) + self.assertTrue(d.logger.error.called) + + d.logger.reset_mock() + d.debug_flag = True + d.debug_log("test") + self.assertTrue(d.logger.error.called) diff --git a/testsuite/Testsrc/Testlib/TestServer/TestEncryption.py b/testsuite/Testsrc/Testlib/TestServer/TestEncryption.py index 8f69f3bf0..2267e9d6c 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestEncryption.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestEncryption.py @@ -35,7 +35,7 @@ baz @skipUnless(HAS_CRYPTO, "Encryption libraries not found") def setUp(self): - pass + Bcfg2.Options.setup.algorithm = "aes_256_cbc" def test_str_crypt(self): """ test str_encrypt/str_decrypt """ @@ -110,66 +110,41 @@ baz self.assertRaises(EVPError, ssl_decrypt, crypted, passwd) # bogus algorithm - @patch("Bcfg2.Options.get_option_parser") - def test_get_passphrases(self, mock_get_option_parser): - setup = Mock() - setup.cfp.has_section.return_value = False - mock_get_option_parser.return_value = setup - self.assertEqual(get_passphrases(), dict()) - - setup.cfp.has_section.return_value = True - setup.cfp.options.return_value = ["foo", "bar", CFG_ALGORITHM] - setup.cfp.get.return_value = "passphrase" - self.assertItemsEqual(get_passphrases(), - dict(foo="passphrase", - bar="passphrase")) - - @patch("Bcfg2.Server.Encryption.get_passphrases") - def test_bruteforce_decrypt(self, mock_passphrases): + def test_bruteforce_decrypt(self): passwd = "a simple passphrase" crypted = ssl_encrypt(self.plaintext, passwd) # test with no passphrases given nor in config - mock_passphrases.return_value = dict() + Bcfg2.Options.setup.passphrases = dict() self.assertRaises(EVPError, bruteforce_decrypt, crypted) - mock_passphrases.assert_called_with() # test with good passphrase given in function call - mock_passphrases.reset_mock() self.assertEqual(self.plaintext, bruteforce_decrypt(crypted, passphrases=["bogus pass", passwd, "also bogus"])) - self.assertFalse(mock_passphrases.called) # test with no good passphrase given nor in config - mock_passphrases.reset_mock() self.assertRaises(EVPError, bruteforce_decrypt, crypted, passphrases=["bogus", "also bogus"]) - self.assertFalse(mock_passphrases.called) # test with good passphrase in config file - mock_passphrases.reset_mock() - mock_passphrases.return_value = dict(bogus="bogus", - real=passwd, - bogus2="also bogus") + Bcfg2.Options.setup.passphrases = dict(bogus="bogus", + real=passwd, + bogus2="also bogus") self.assertEqual(self.plaintext, bruteforce_decrypt(crypted)) - mock_passphrases.assert_called_with() # test that passphrases given in function call take # precedence over config - mock_passphrases.reset_mock() self.assertRaises(EVPError, bruteforce_decrypt, crypted, passphrases=["bogus", "also bogus"]) - self.assertFalse(mock_passphrases.called) # test that different algorithms are used - mock_passphrases.reset_mock() crypted = ssl_encrypt(self.plaintext, passwd, algorithm=self.algo) self.assertEqual(self.plaintext, bruteforce_decrypt(crypted, algorithm=self.algo)) diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testbase.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testbase.py index 870983f60..db126b3a1 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testbase.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testbase.py @@ -1,6 +1,5 @@ import os import sys -import logging from mock import Mock, MagicMock, patch from Bcfg2.Server.Plugin.base import * @@ -14,50 +13,7 @@ while path != '/': break path = os.path.dirname(path) from common import * - - -class TestDebuggable(Bcfg2TestCase): - test_obj = Debuggable - - def get_obj(self): - return self.test_obj() - - def test__init(self): - d = self.get_obj() - self.assertIsInstance(d.logger, logging.Logger) - self.assertFalse(d.debug_flag) - - def test_set_debug(self): - d = self.get_obj() - self.assertEqual(True, d.set_debug(True)) - self.assertEqual(d.debug_flag, True) - - self.assertEqual(False, d.set_debug(False)) - self.assertEqual(d.debug_flag, False) - - def test_toggle_debug(self): - d = self.get_obj() - d.set_debug = Mock() - orig = d.debug_flag - self.assertEqual(d.toggle_debug(), - d.set_debug.return_value) - d.set_debug.assert_called_with(not orig) - - def test_debug_log(self): - d = self.get_obj() - d.logger = Mock() - d.debug_flag = False - d.debug_log("test") - self.assertFalse(d.logger.error.called) - - d.logger.reset_mock() - d.debug_log("test", flag=True) - self.assertTrue(d.logger.error.called) - - d.logger.reset_mock() - d.debug_flag = True - d.debug_log("test") - self.assertTrue(d.logger.error.called) +from TestLogger import TestDebuggable class TestPlugin(TestDebuggable): @@ -66,7 +22,7 @@ class TestPlugin(TestDebuggable): def get_obj(self, core=None): if core is None: core = Mock() - core.setup = MagicMock() + set_setup_default("debug", False) @patchIf(not isinstance(os.makedirs, Mock), "os.makedirs", Mock()) def inner(): return self.test_obj(core, datastore) diff --git a/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testhelpers.py b/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testhelpers.py index 834f8d3b6..3439d475f 100644 --- a/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testhelpers.py +++ b/testsuite/Testsrc/Testlib/TestServer/TestPlugin/Testhelpers.py @@ -53,24 +53,18 @@ class TestDatabaseBacked(TestPlugin): @skipUnless(HAS_DJANGO, "Django not found") def test__use_db(self): - core = Mock() - core.setup.cfp.getboolean.return_value = True - db = self.get_obj(core) + db = self.get_obj() + + Bcfg2.Options.setup.databasebacked_db = True self.assertTrue(db._use_db) - core = Mock() - core.setup.cfp.getboolean.return_value = False - db = self.get_obj(core) + Bcfg2.Options.setup.databasebacked_db = False self.assertFalse(db._use_db) Bcfg2.Server.Plugin.helpers.HAS_DJANGO = False - core = Mock() - db = self.get_obj(core) self.assertFalse(db._use_db) - core = Mock() - core.setup.cfp.getboolean.return_value = True - db = self.get_obj(core) + Bcfg2.Options.setup.databasebacked_db = False self.assertFalse(db._use_db) Bcfg2.Server.Plugin.helpers.HAS_DJANGO = True @@ -87,6 +81,7 @@ class TestFileBacked(Bcfg2TestCase): def get_obj(self, path=None): if path is None: path = self.path + set_setup_default("filemonitor", MagicMock()) return self.test_obj(path) @patch("%s.open" % builtins) @@ -138,6 +133,7 @@ class TestDirectoryBacked(Bcfg2TestCase): if fam is None: fam = Mock() + set_setup_default("filemonitor", MagicMock()) @patch("%s.%s.add_directory_monitor" % (self.test_obj.__module__, self.test_obj.__name__), Mock()) @@ -385,6 +381,8 @@ class TestXMLFileBacked(TestFileBacked): def get_obj(self, path=None, should_monitor=False): if path is None: path = self.path + set_setup_default("filemonitor", MagicMock()) + set_setup_default("encoding", 'utf-8') @patchIf(not isinstance(os.path.exists, Mock), "os.path.exists", Mock()) @@ -720,7 +718,7 @@ class TestStructFile(TestXMLFileBacked): loader = mock_TemplateLoader.return_value loader.load.assert_called_with(sf.name, cls=genshi.template.MarkupTemplate, - encoding=sf.encoding) + encoding=Bcfg2.Options.setup.encoding) self.assertEqual(sf.template, loader.load.return_value) @@ -728,9 +726,8 @@ class TestStructFile(TestXMLFileBacked): @skipUnless(HAS_CRYPTO, "No crypto libraries found, skipping") def test_Index_crypto(self): + Bcfg2.Options.setup.lax_decryption = False sf = self.get_obj() - sf.setup = Mock() - sf.setup.cfp.get.return_value = "strict" sf._decrypt = Mock() sf._decrypt.return_value = 'plaintext' sf.data = ''' @@ -757,7 +754,7 @@ class TestStructFile(TestXMLFileBacked): self.assertRaises(PluginExecutionError, sf.Index) # test failed decryption, lax - sf.setup.cfp.get.return_value = "lax" + Bcfg2.Options.setup.lax_decryption = True sf._decrypt.reset_mock() sf.Index() self.assertItemsEqual( @@ -766,30 +763,28 @@ class TestStructFile(TestXMLFileBacked): @skipUnless(HAS_CRYPTO, "No crypto libraries found, skipping") @patchIf(HAS_CRYPTO, "Bcfg2.Server.Encryption.ssl_decrypt") - @patchIf(HAS_CRYPTO, "Bcfg2.Server.Encryption.get_passphrases") @patchIf(HAS_CRYPTO, "Bcfg2.Server.Encryption.bruteforce_decrypt") - def test_decrypt(self, mock_bruteforce, mock_get_passphrases, mock_ssl): + def test_decrypt(self, mock_bruteforce, mock_ssl): sf = self.get_obj() def reset(): mock_bruteforce.reset_mock() - mock_get_passphrases.reset_mock() mock_ssl.reset_mock() + # test element without text contents + Bcfg2.Options.setup.passphrases = dict() self.assertIsNone(sf._decrypt(lxml.etree.Element("Test"))) self.assertFalse(mock_bruteforce.called) - self.assertFalse(mock_get_passphrases.called) self.assertFalse(mock_ssl.called) # test element with a passphrase in the config file reset() el = lxml.etree.Element("Test", encrypted="foo") el.text = "crypted" - mock_get_passphrases.return_value = dict(foo="foopass", bar="barpass") + Bcfg2.Options.setup.passphrases = dict(foo="foopass", bar="barpass") mock_ssl.return_value = "decrypted with ssl" self.assertEqual(sf._decrypt(el), mock_ssl.return_value) - mock_get_passphrases.assert_called_with() mock_ssl.assert_called_with(el.text, "foopass") self.assertFalse(mock_bruteforce.called) @@ -797,7 +792,6 @@ class TestStructFile(TestXMLFileBacked): reset() mock_ssl.side_effect = EVPError self.assertRaises(EVPError, sf._decrypt, el) - mock_get_passphrases.assert_called_with() mock_ssl.assert_called_with(el.text, "foopass") self.assertFalse(mock_bruteforce.called) @@ -806,7 +800,6 @@ class TestStructFile(TestXMLFileBacked): el.set("encrypted", "true") mock_bruteforce.return_value = "decrypted with bruteforce" self.assertEqual(sf._decrypt(el), mock_bruteforce.return_value) - mock_get_passphrases.assert_called_with() mock_bruteforce.assert_called_with(el.text) self.assertFalse(mock_ssl.called) @@ -814,7 +807,6 @@ class TestStructFile(TestXMLFileBacked): reset() mock_bruteforce.side_effect = EVPError self.assertRaises(EVPError, sf._decrypt, el) - mock_get_passphrases.assert_called_with() mock_bruteforce.assert_called_with(el.text) self.assertFalse(mock_ssl.called) @@ -881,6 +873,7 @@ class TestStructFile(TestXMLFileBacked): self.assertXMLEqual(el, sf._match(el, metadata)[0]) def test_do_match(self): + Bcfg2.Options.setup.lax_decryption = True sf = self.get_obj() sf._match = Mock() @@ -973,6 +966,7 @@ class TestStructFile(TestXMLFileBacked): def test_match_ordering(self): """ Match() returns elements in document order """ + Bcfg2.Options.setup.lax_decryption = True sf = self.get_obj() sf._match = Mock() @@ -1341,12 +1335,12 @@ class TestSpecificData(Bcfg2TestCase): test_obj = SpecificData path = os.path.join(datastore, "test.txt") - def get_obj(self, name=None, specific=None, encoding=None): + def get_obj(self, name=None, specific=None): if name is None: name = self.path if specific is None: specific = Mock() - return self.test_obj(name, specific, encoding) + return self.test_obj(name, specific) def test__init(self): pass @@ -1388,9 +1382,15 @@ class TestEntrySet(TestDebuggable): ignore = ["foo~", ".#foo", ".foo.swp", ".foo.swx", "test.txt.genshi_include", "test.G_foo.genshi_include"] - def get_obj(self, basename="test", path=datastore, entry_type=MagicMock(), - encoding=None): - return self.test_obj(basename, path, entry_type, encoding) + def get_obj(self, basename="test", path=datastore, entry_type=MagicMock()): + set_setup_default("default_owner") + set_setup_default("default_group") + set_setup_default("default_mode") + set_setup_default("default_secontext") + set_setup_default("default_important", False) + set_setup_default("default_paranoid", False) + set_setup_default("default_sensitive", False) + return self.test_obj(basename, path, entry_type) def test__init(self): for basename in self.basenames: @@ -1585,8 +1585,9 @@ class TestEntrySet(TestDebuggable): eset.entry_init(event) eset.specificity_from_filename.assert_called_with("test.txt", specific=None) - eset.entry_type.assert_called_with(os.path.join(eset.path, "test.txt"), - eset.specificity_from_filename.return_value, None) + eset.entry_type.assert_called_with( + os.path.join(eset.path, "test.txt"), + eset.specificity_from_filename.return_value) eset.entry_type.return_value.handle_event.assert_called_with(event) self.assertIn("test.txt", eset.entries) @@ -1607,8 +1608,7 @@ class TestEntrySet(TestDebuggable): eset.specificity_from_filename.assert_called_with("test2.txt", specific=specific) etype.assert_called_with(os.path.join(eset.path, "test2.txt"), - eset.specificity_from_filename.return_value, - None) + eset.specificity_from_filename.return_value) etype.return_value.handle_event.assert_called_with(event) self.assertIn("test2.txt", eset.entries) @@ -1745,12 +1745,7 @@ class TestGroupSpool(TestPlugin, TestGenerator): def get_obj(self, core=None): if core is None: core = MagicMock() - core.setup = MagicMock() - else: - try: - core.setup['encoding'] - except TypeError: - core.setup.__getitem__ = MagicMock() + set_setup_default("encoding", "utf-8") @patch("%s.%s.AddDirectoryMonitor" % (self.test_obj.__module__, self.test_obj.__name__), @@ -1821,8 +1816,7 @@ class TestGroupSpool(TestPlugin, TestGenerator): self.assertFalse(gs.AddDirectoryMonitor.called) gs.es_cls.assert_called_with(gs.filename_pattern, gs.data + ident, - gs.es_child_cls, - gs.encoding) + gs.es_child_cls) self.assertIn(ident, gs.entries) self.assertEqual(gs.entries[ident], gs.es_cls.return_value) self.assertIn(ident, gs.Entries[gs.entry_type]) -- cgit v1.2.3-1-g7c22